@@ -101,15 +101,15 @@ Where the detail's `capabilities.diff` is true, the details have a third tab, Co
 | --- | --- | --- |
 | Reading | The tab mounts the first time it shows and stays mounted while the panel shows the pull request (PullRequestDetailPanel.tsx:2784-2798). Its query reads the first slice, and reads it again when the tab mounts with an answer 60 seconds old. A sentinel 240 pixels under the files reads the next slice once it comes into view (PullRequestCodeTab.tsx:607-629). | The first slice is read the first time the Code shows after the details open, and read again then where it came a minute or more ago or failed. The next slice is read once a frame shows the end of the files within two pages of the view. One slice is read at a time. |
 | Reading again | `codeRefreshToken` (PullRequestDetailPanel.tsx:832) moves with each refresh number, a person's Refresh and a detail whose `updatedAt` changed (836-847), and the tab reads the first slice again | The same three read the first slice again. After `r`, the read waits until the read that sent `pullRequests.invalidate` is done, so T3 forgets the diff it held. The files read before show until the new ones come, and a file keeps its fold. A read again that fails keeps them under `May be out of date: t3term couldn't read the diff again.` and the reason. |
-| Commits | Where the change has commits, the toolbar's menu says `All commits` or the picked commit's headline. It lists `All commits`, then the commits newest first by when each was committed, 10 at a time with `Show more (13 left)`, each with its id's first seven characters (PullRequestCodeTab.tsx:683-692, 1063-1119). Picking one reads its own diff from its first slice, folds the files and closes the list off the diff (268-277), and places no thread on its lines, since a commit counts its lines apart from the change (454-458). A commit the change no longer lists goes back to All commits (1050-1062) | `› All commits` above the count, or `› Read the schema first · abc1234`. Enter or a click opens the list under it: `✓ All commits`, then each commit's headline cut to its row with the seven characters at the end, ✓ before the diff shown, and `Show more (13 left)`. ↑ and ↓ choose an entry, and Enter or a click shows its diff, reading it from its first slice, and closes the list with its row chosen. Commits at the same instant keep T3's order, and one whose time t3term can't read goes last. An empty headline reads `Untitled commit`, as on the Timeline. While a commit's diff shows, every thread is in the list off the diff. A read of the conversation that no longer lists the commit reads the whole change again. |
+| Commits | Where the change has commits, the toolbar's menu says `All commits` or the picked commit's headline. It lists `All commits`, then the commits newest first by when each was committed, 10 at a time with `Show more (13 left)`, each with its id's first seven characters (PullRequestCodeTab.tsx:683-692, 1063-1119). Picking one reads its own diff from its first slice, folds the files and closes the list off the diff (268-277), and places no thread on its lines, since a commit counts its lines apart from the change (454-458). A commit the change no longer lists goes back to All commits (1050-1062). The query of a diff picked before stays alive for 5 minutes once nothing shows it, so a read of it under way runs on and its answer is kept (packages/client-runtime/src/state/runtime.ts:534 and 590) | `› All commits` above the count, or `› Read the schema first · abc1234`. Enter or a click opens the list under it: `✓ All commits`, then each commit's headline cut to its row with the seven characters at the end, ✓ before the diff shown, and `Show more (13 left)`. ↑ and ↓ choose an entry, and Enter or a click shows its diff, reading it from its first slice, and closes the list with its row chosen. Commits at the same instant keep T3's order, and one whose time t3term can't read goes last. An empty headline reads `Untitled commit`, as on the Timeline. While a commit's diff shows, every thread is in the list off the diff. A read of the conversation that no longer lists the commit reads the whole change again. Picking another diff stops the read of the one before, whose answer t3term would drop. |
 | Count | `12 files`, with `+` while more slices come (PullRequestCodeTab.tsx:1124-1125), and a note when the host withheld part of the diff (1183-1195) | `12 files+`, then `The host withheld part of this diff, such as a binary file or a change too large to show.` in yellow where a slice says the host left something out or has text the parser found no file in. |
 | Files | Folded at first, as the `diffFilesCollapsed` setting is true until changed (pullRequestDiff.logic.ts:36-43, PullRequestCodeTab.tsx:230-232). The header has a chevron, an icon for how the file changed, the path, both paths of a rename, and `+3 -1` unless both are 0, from the host's own counts where the hunks it sent count none (822-823) | `› M src/lib.rs +3 -1`, with A, D, R or M in green, red, blue or yellow for an added, deleted, renamed or changed file. The path wraps under itself. Enter or a click unfolds it, `⌄`, and folds it again. A path one slice holds twice, as git writes a file whose type changed, shows once as its last part, as the desktop's `orderDiffFiles` keeps one file for each path (pullRequestFileOrder.logic.ts:152-153). |
 | Order | `orderDiffFiles` (pullRequestFileOrder.logic.ts:145-197) orders each slice on its own, so a later slice never moves the files above it (PullRequestCodeTab.tsx:404-411). Source comes first, each file after the changed files it imports. A quoted specifier after `from`, `import` or `require(` in any line of a file's hunks names a changed file by its path, with `./` and `../` resolved and a script's extension dropped, or by a name only one source file has. Where a cycle leaves no file ready, the lowest path goes next. Then the tests (`.test.`, `.spec.`, or a `test`, `tests` or `__tests__` directory), each after the source file whose name it has, then lockfiles, snapshots, minified files and files under `dist`, `build`, `vendor`, `__generated__` or `__snapshots__`, by path. Paths compare with `localeCompare` | The same order, worked out once when a slice comes. The diff library the desktop uses puts each unchanged line of a hunk on both sides, so an import in an unchanged line counts too (@pierre/diffs 1.5.2, dist/utils/parsePatchFiles.js:208-222), and t3term counts it. Paths compare as the root collation does for ASCII: punctuation, then digits, then letters with case ignored, then lowercase before uppercase. |
 | Lines | The stacked view: each line with its number, and `N unmodified lines` between hunks (apps/web/src/lib/diffRendering.ts:82) | Each line's number, the new one or the old for a removed line, then `+`, `-` or a space, in green, red or the text's color. A line that wraps leaves the number and the mark blank. Tabs stop every 4 columns, control characters go, and a line past 2,000 characters is cut with `…`. `⋯ 9 unmodified lines` comes before each hunk that doesn't start at the file's first line. A binary file, a file whose changes the host withheld and a rename that changed no line each say so. So does a file past t3term's 200,000 lines of a slice, or with lines t3term couldn't read, such as a hunk shorter or longer than its header counts. Only the files unfolded are laid out, each once for each width, so folding one or the minute changing doesn't lay out the others again. |
 | Review threads | Each thread on a file the tab shows, with a line inside one of its hunks, shows under that line (PullRequestCodeTab.tsx:452-472, pullRequestDiff.logic.ts:12-22). On a row with both numbers, a thread on the old side comes before one on the new (@pierre/diffs 1.5.2, dist/renderers/DiffHunksRenderer.js:1051-1075). `ReviewThreadCard` starts open unless resolved. Its header says `Open` or `Resolved`, the count of comments and `outdated`, and under it come the comments, `Load more comments` and buttons to resolve, reply, edit and react (PullRequestReviewAnnotation.tsx:89-358). `Load more comments` reads the next page through `pullRequests.threadComments`, reads `Loading...` until it comes, and adds its comments, keeping the first of each id (139-207, 305-313, pullRequestDetail.logic.ts:170-184). A failure shows a toast (PullRequestCodeTab.tsx:928-940) | `│ ⌄ Open · 3 comments · outdated` behind a bar, with `Resolved` in green. It starts open unless resolved, and Enter or a click on its first row opens and closes it. Open, it shows each comment as the Summary does, with a blank row between them, then `Load more comments` where the host has another page. Enter or a click reads that page, as [pull request reads](pull-request-reads.md#a-review-threads-remarks) says, and the row reads `Loading more comments…` until it comes. Its comments follow the thread's, each id once. A failed read shows `t3term couldn't read more comments.` and the reason above the button, which reads the same page again. Where the host has no page to offer but counts more, `2 more comments on the host.` shows instead. Only the threads of unfolded files show, and a thread stays open or closed across reads, by its id. t3term places a thread only on a line it read, so one on a line of a hunk shorter than its header counts goes to the list off the diff. The desktop checks the hunk's range alone. |
 | Off the diff | Above the code, closed at first: `Conversations not on the current diff`, or `on the diff loaded so far` while slices are left, and the count. Open, it lists the threads by path, each path once, with `Line 42` before each thread, at most 256 pixels high (1376-1440) | `› 2 conversations not on the current diff`, or `on the diff read so far`, above the files. Enter or a click opens it. Open, it lists each path once, then `Line 42` and the thread, for each thread on it. |
 | Waiting and failing | `Loading pull request diff...`, `Loading more files...` after the files, the first slice's error alone, and `The rest of this diff could not be loaded.` with Retry for a later slice (760-776) | `Loading pull request diff…` and `Loading more files…`. The first slice's failure shows alone, and `r` or showing the Code after the details open again reads it again. A later slice's failure shows `t3term couldn't read the rest of this diff.`, the reason and `↻ Retry`, which ↑ and ↓ choose. |
-| Empty | `This pull request has no file changes.`, or `This commit has no file changes.` for a commit's own diff (1366-1372) | The same, or `t3term couldn't split this patch into files.` where the patch has text but no file the parser could read. |
+| Empty | `This pull request has no file changes.`, or `This commit has no file changes.` for a commit's own diff (1366-1372), returned before the list off the diff (1376), so no review thread shows | The same, or `t3term couldn't split this patch into files.` where the patch has text but no file the parser could read. No review thread shows either, until a diff with files does. |
 
 ## Next slices
 
 
@@ -93,7 +93,8 @@ type WatchSetup = Box<dyn Fn(&str) -> mpsc::UnboundedReceiver<WatchEvent>>;
 /// as an action with the ask's ticket.
 type ReadPull = Box<dyn Fn(Reference, Ask)>;
 /// Reads a slice of a pull request's diff in the background as `DiffAsk` says, and sends the
-/// answer as an action with the ask's ticket.
+/// answer as an action with the ask's ticket. The details want only the answer to their newest
+/// ask, so a read stops the one under way before it.
 type ReadDiff = Box<dyn Fn(Reference, DiffAsk)>;
 /// Reads the next page of a review thread's remarks in the background as `CommentsAsk` says,
 /// and sends the answer as an action with the ask's ticket.
@@ -1023,15 +1024,23 @@ impl App {
                     read_pull_request(&client, &reference, &ask, send).await;
                 });
             }),
-            read_diff: Box::new(move |reference, ask: DiffAsk| {
-                let (client, answers) = (differ.clone(), diffs.clone());
-                tokio::spawn(async move {
-                    let (cursor, commit) = (ask.cursor.as_deref(), ask.commit.as_deref());
-                    let answer = read_diff(&client, &reference, cursor, commit).await;
-                    let ticket = ask.ticket;
-                    let _ = answers.send(ActionResult::PullRequestDiff { ticket, answer });
-                });
-            }),
+            read_diff: {
+                let under_way = std::cell::RefCell::new(None::<tokio::task::AbortHandle>);
+                Box::new(move |reference, ask: DiffAsk| {
+                    let (client, answers) = (differ.clone(), diffs.clone());
+                    let read = tokio::spawn(async move {
+                        let (cursor, commit) = (ask.cursor.as_deref(), ask.commit.as_deref());
+                        let answer = read_diff(&client, &reference, cursor, commit).await;
+                        let ticket = ask.ticket;
+                        let _ = answers.send(ActionResult::PullRequestDiff { ticket, answer });
+                    });
+                    // An ask comes only once the details have the answer to the last one or no
+                    // longer want it, as when another commit was picked, so that read stops.
+                    if let Some(before) = under_way.replace(Some(read.abort_handle())) {
+                        before.abort();
+                    }
+                })
+            },
             read_comments: Box::new(move |reference, ask: CommentsAsk| {
                 let (client, answers) = (pager.clone(), pages.clone());
                 tokio::spawn(async move {
@@ -15556,4 +15565,54 @@ mod tests {
         assert_eq!(sent["cursor"], "2");
         assert_eq!(sent["commit"], "abc1234def");
     }
+
+    #[tokio::test]
+    async fn the_apps_next_read_of_a_diff_stops_the_one_under_way() {
+        use crate::http::{Api, fake};
+        use std::sync::atomic::{AtomicUsize, Ordering};
+
+        // T3 answers one read at a time and holds the first back for a second, so the second
+        // read's answer comes after the first's unless the first stopped.
+        let body = json!({"patch": "", "truncated": false, "nextCursor": null});
+        let answer = fake::response("200 OK", &[], &body.to_string());
+        let reads = AtomicUsize::new(0);
+        let t3 = fake::Server::start(move |_| {
+            if reads.fetch_add(1, Ordering::SeqCst) == 0 {
+                std::thread::sleep(Duration::from_secs(1));
+            }
+            answer.clone()
+        });
+        let mut client = Client::offline();
+        client.api = Api::without_proxy(&t3.origin);
+        let (sender, mut results) = mpsc::unbounded_channel();
+        let app = App::new(
+            Arc::new(client),
+            Theme::new(Depth::TrueColor),
+            &Settings::default(),
+            sender,
+        );
+        let reference = Reference::new("p", Some("github.com"), "krishhgg/t3term", 31).unwrap();
+        let ask = |ticket, commit: &str| DiffAsk {
+            ticket,
+            host: "github.com".into(),
+            repository: "krishhgg/t3term".into(),
+            number: 31,
+            cursor: None,
+            commit: Some(commit.into()),
+        };
+        (app.read_diff)(reference.clone(), ask(7, "1111111aaaa"));
+        tokio::time::sleep(Duration::from_millis(200)).await;
+        (app.read_diff)(reference, ask(8, "2222222bbbb"));
+        let result = tokio::time::timeout(Duration::from_secs(5), results.recv())
+            .await
+            .expect("an answer within five seconds")
+            .expect("the answer");
+        let ActionResult::PullRequestDiff { ticket, .. } = result else {
+            panic!("an answer of another kind");
+        };
+        assert_eq!(ticket, 8);
+        assert!(results.try_recv().is_err());
+        let sent: Value = serde_json::from_str(&t3.bodies()[1]).unwrap();
+        assert_eq!(sent["commit"], "2222222bbbb");
+    }
 }