diff --git a/KNOWN-ISSUES.md b/KNOWN-ISSUES.md
index 14b318c..db125f8 100644
--- a/KNOWN-ISSUES.md
+++ b/KNOWN-ISSUES.md
@@ -15,6 +15,7 @@ What happens and how to reproduce it. What's known about the cause, with guesses
 In one run during slice 11, and not on the run before or after: `tests/e2e/prd.spec.ts`, "reads Drafting while it works, and comes back with a line beside it when the answer fails" (since slice 13, "says Drafting beside the next section while it works, …"), waited past its 5 seconds with the fake model's answer stuck after the saved section. It passed five times in a row on its own and in the full suites afterwards. A guess: it waits on the fake model's timing, which six workers on a busy machine stretch. Fixing it means finding what it waits on and waiting for that condition instead; if it fails again, note the run here. (The unit test that failed with it was a test reading storage too early, fixed with slice 12; `tests/AGENTS.md`, *Writing tests*.)
 Again during slice 14, in two full runs of five: 2 and then 3 tests (`prd.spec.ts`'s pop-over tests, "Start over asks once…", "follows the newest message…", `quota.spec.ts`'s "the chat and the PRD so far stay readable…"), each in `draftFirstSection` or its like, waiting past 5 seconds for the first draft's answer to end while the fake model was still streaming its reply. The same tests passed twice each on their own, and the three full runs after them passed, one of them without slice 14's change to the chat. So the wait is the fake model's answer under six workers, not what the page does.
 Again during slice 15 (2026-10-20), in full runs back to back on the finished code: one failed 2 tests (not recorded), one passed all 59, one failed 4: `layout.spec.ts`'s three Jump to latest tests and `prd.spec.ts`'s "follows the newest message…", each waiting past 5 seconds for a first draft's answer while the fake model was still at a search or the check. One of them, "offers Jump to latest once opened searches push…", now drafts after three searches (`FAKE_SEARCH_AGAIN`), a longer answer, so it has less room in that wait.
+Again during slice 20 (2026-10-21), in the first full run on the finished code: 6 tests (`prd.spec.ts`'s Drafting, light-up, See it and copy tests), each waiting past 5 seconds for the first draft's answer while it showed "Checking the quotes in Introduction / Overview…". All of `prd.spec.ts` passed on its own right after, and the next full run passed all 67.
 
 ## KI-8 · `next dev` adds its own block to `AGENTS.md`
 **Found:** 2026-10-20 · **Severity:** low
diff --git a/docs/plan.md b/docs/plan.md
index 10c6592..0d6e09e 100644
--- a/docs/plan.md
+++ b/docs/plan.md
@@ -20,12 +20,11 @@
 
 ### Build lane
 - **Where:** its own worktree per piece, on a branch from an up-to-date `main`. If the session isn't in a worktree yet (`git worktree list` shows its folder as the main checkout, not under `.claude/worktrees/`), it creates one before touching anything, and never checks out a branch in the main folder, where the measurement lane works. Claude Code's worktree option puts it under `.claude/worktrees/`; run `npm ci` there first. A worktree made with `git worktree add` gets no `.env.local`: run `npm run env:local` there, or the end-to-end tests find no interviews. Its browser check uses `app-build` in `.claude/launch.json` (port 3200), never `app` or `app-real`, which are the measurement lane's on port 3000. It never runs `measure`, `measure:fake` or `dev:real`, never edits the measurement lane's files above, and changes code in `src/server` only where its piece needs it, never what the model receives (listed above); its pull request says which `src/server` files it changed and why.
-- **Doing:** slice 19 is done on `feat/markdown-tables` (`.claude/worktrees/slice-19-tables`), from `main` at 32315ed (slice 18's merge), waiting for the owner's push and merge. Local checks on 2026-10-21: `verify` (468 unit tests; the card tests in `tests/unit/markdown.test.ts` and `tests/unit/rich-text.test.tsx` gave way to table tests) and `test:e2e` (66, 2 new in `tests/e2e/chat.spec.ts`) passed in two full runs; a first full run failed 10, the 2 new among them, all passing again with two workers, and the 2 new passed 12 times of 12 in parallel (KI-7). The page checked on a dev server from the worktree with the fakes, at 1440px and 375px: the header in medium weight over the stronger line, 12px padding, top-aligned; a six-column table scrolling inside the message, a stop for Shift+Tab with the white focus ring, and a two-column one fitting without a stop; the page never scrolls sideways. Unlike opencode's, each cell is at least 144px wide, since the six columns squeezed into the chat showed a word per line (`docs/decisions.md`, Design, 2026-10-20). It changes `src/lib/markdown.ts`, which only the browser uses, and nothing in `src/server`, so the measurement lane needn't wait for it.
+- **Doing:** slice 20 is done on `feat/thinking-line` (`.claude/worktrees/slice-20-thinking`), from `main` at b446e43 (slice 19's merge), waiting for the owner's push and merge. Local checks on 2026-10-21: `verify` (488 unit tests, 2 files new or changed for the thinking lines) passed, its build on a second try after a network error reaching Google Fonts; `test:e2e` (67, 1 new in `tests/e2e/chat.spec.ts`; slice 11's and slice 15's tests now read "Thinking" and count the thought lines) passed in the second full run, the first failing 6 waiting on the fake model's answer (KI-7). The page checked on a dev server from the worktree with the fakes, at 1440px and 375px: "Thinking" at 13px, medium, on a 16px line with the moving band; "Thought 2s" with the word in white and the time in grey; inside "Used 3 searches" the thoughts and searches alternate, rows 28px high and 36px apart; the times kept through a reload; no sideways scroll on a phone. It changes only `src/features` and its tests, nothing in `src/server` or `src/lib`; the times go back to the server inside the answers, and a unit test shows the model's input is the same with and without them, so the measurement lane needn't wait for it.
 - **Next:**
-  1. Slice 20 on its own branch from `main` once slice 19 is merged, in a fresh session; its form is decided (`docs/decisions.md`, Design, 2026-10-21). It changes only the browser's code and its tests, nothing in `src/server`.
-  2. Slice 8, the rate limit, once 9d is done and the owner has decided its legal basis and size (*Deferred*).
-- **Unverified:** on staging, a reload keeping the PRD and the downloaded file (local Chromium only); a stop ending the answer on Cloudflare too, where the call in flight may still be finished and counted; the quota message against Cloudflare's real refusal (the tests replay its reply of 2026-10-20) and whether its per-minute 429 carries a retry header; a source name's pop-over, "Your decision, not from the interviews." under a claim of the visitor's, the table fix and the intro screen; Safari and Firefox (only Chromium ran; without anchor positioning the pop-over is a centred box, by design, and without `field-sizing`, before Safari 26.2 and Firefox 152, the message box keeps its three lines; the moving band, whose fallback is the still grey line; the PRD's highlight and rolling count; Jump to latest; the folded line's slide, which falls back to showing at once; the words' fade; the copy button, its label and the clipboard; Inter and its resized fallback, which needs Arial installed, so Linux and Android show the system's font until Inter arrives; a table's cells keeping their 144px and its box's sideways scroll). On staging, a real reply's table. On staging, a reply that arrives whole fading in as one, and a section's copy over HTTPS pasted into another app. Expect the Security Advisor's lint 0028 on `search_passages` on staging; it's intended (`supabase/AGENTS.md`). Production waits for launch and its Cloudflare token.
-- **Waiting on the owner:** pushing `feat/markdown-tables`, its pull request and the merge; whether `next dev` may keep adding its block to `AGENTS.md` (KI-8); the GitHub description and topics whenever they like.
+  1. Slice 8, the rate limit, once 9d is done and the owner has decided its legal basis and size (*Deferred*). No other piece is planned for this lane.
+- **Unverified:** on staging, a reload keeping the PRD and the downloaded file (local Chromium only); a stop ending the answer on Cloudflare too, where the call in flight may still be finished and counted; the quota message against Cloudflare's real refusal (the tests replay its reply of 2026-10-20) and whether its per-minute 429 carries a retry header; a source name's pop-over, "Your decision, not from the interviews." under a claim of the visitor's, the table fix and the intro screen; Safari and Firefox (only Chromium ran; without anchor positioning the pop-over is a centred box, by design, and without `field-sizing`, before Safari 26.2 and Firefox 152, the message box keeps its three lines; the moving band, whose fallback is the still grey line; the PRD's highlight and rolling count; Jump to latest; the folded line's slide, which falls back to showing at once; the words' fade; the copy button, its label and the clipboard; Inter and its resized fallback, which needs Arial installed, so Linux and Android show the system's font until Inter arrives; a table's cells keeping their 144px and its box's sideways scroll; the Thinking line's band). On staging, a real reply's table, and the Thinking line through the real model's waits with the times it shows (the fake model's are about 0s). On staging, a reply that arrives whole fading in as one, and a section's copy over HTTPS pasted into another app. Expect the Security Advisor's lint 0028 on `search_passages` on staging; it's intended (`supabase/AGENTS.md`). Production waits for launch and its Cloudflare token.
+- **Waiting on the owner:** pushing `feat/thinking-line`, its pull request and the merge; whether `next dev` may keep adding its block to `AGENTS.md` (KI-8); the GitHub description and topics whenever they like.
 
 ### Shared rules
 - One branch per piece, from an up-to-date `main`; the owner pushes it, opens the pull request and merges it (`AGENTS.md`, Branches). After the other lane's merge, rebase an unpushed branch onto `main`, and merge `main` into a pushed one; never rewrite a pushed branch.
@@ -113,13 +112,6 @@
 
 ### 18 · A designed typeface · risk: normal · status: done (32315ed)
 
-### 19 · Tables like opencode's · risk: normal · status: done (on `feat/markdown-tables`; its id on `main` goes here after the merge)
+### 19 · Tables like opencode's · risk: normal · status: done (71e6e93)
 
-### 20 · Show when the model is thinking · risk: normal · status: todo
-- **Goal:** the visitor sees when the model is thinking and for how long, never what it thinks.
-- **Acceptance:**
-  - Its form is opencode's (the owner, 2026-10-21; `docs/decisions.md`, Design): "Thinking" while the model thinks, then "Thought" with the time in grey, as "Thought 8s", a line that doesn't open.
-  - The chat model gives whole replies (`src/server/ai/cloudflare.ts`; `src/server/AGENTS.md`, *Whole replies for chat*), so the server learns of the model's reasoning only with the reply, together with its text or its step, and can't say live when the reasoning starts or how long it took on its own. What the browser can see is each wait for a reply, and gpt-oss reasons before it replies (Harmony's analysis channel), so that wait is the sign: whenever an answer is on its way and no step is in progress and no text is arriving, slice 11's moving line reads as opencode's Thinking row instead of "Working…", and slice 11's tests change with it. The first wait starts with the request; a later one starts when a step finishes.
-  - Once the reply arrives, the line "Thought 8s" stays in the line's place in the answer: the wait, measured in the browser and kept with the conversation as slice 15 keeps the answer's time, so it outlasts a reload; an answer kept from before this piece shows none. With slice 15, these lines fold with the steps. For the answer's last reply the wait also covers the model writing its text; the owner chose opencode's word all the same.
-  - The reasoning's words never reach the browser, as today (`sendReasoning: false` in `src/server/chat.ts`; `src/server/AGENTS.md`, *Reasoning*): gpt-oss's chain of thought isn't held to the safety standards of its final answers, and OpenAI recommends hiding it from end users (https://github.com/openai/harmony/blob/main/docs/format.md, *Reasoning*, read 2026-10-20 through Context7).
-  - Nothing in `src/server` changes: the browser measures and keeps the waits itself, on the assistant's messages (a visitor's message may hold only text: `readChatRequest`). The model receives exactly what it receives today: a unit test runs the chat with the fake model on a conversation with and without the kept waits and shows the model's input is the same (the AI SDK's `convertToModelMessages` leaves out `data-` parts and a message's metadata, and `readChatRequest` accepts both; ai 7.0.143, read 2026-10-20). If that can't hold, it isn't built, and the owner hears why. `STORED_FORMAT` is raised if the kept form changes.
+### 20 · Show when the model is thinking · risk: normal · status: done (on `feat/thinking-line`; its id on `main` goes here after the merge)
diff --git a/src/features/AGENTS.md b/src/features/AGENTS.md
index 3315bc8..ad1b589 100644
--- a/src/features/AGENTS.md
+++ b/src/features/AGENTS.md
@@ -6,9 +6,10 @@
 - **What the PRD shows changing** (slice 13): "Drafting…" sits beside the heading of each section being drafted while the assistant works (`sectionsBeingDrafted` in `workspace/workspace.tsx`): the check-in's section from its message until it arrives, and any section whose save has started in the answer on its way. It's a sibling of the `<h3>`, not inside it, so the heading's and the region's names don't change, and it carries `.shimmer`. A section saved, or saved again with different statements (compared as JSON), lights up: a decorative `span.just-changed` behind it, remounted with a new `key` on each change so the fade restarts without touching the heading's focus, a white tint fading to transparent in 2s, which runs with reduced motion too, since a fade doesn't move. The sections the PRD mounts with, such as those brought back after a reload, and a save that changes nothing, don't count (`useChanges` in `prd/prd-document.tsx`, React's "storing information from previous renders" pattern). The title line's count rolls (`RollingNumber`, `.roll` in `src/app/globals.css`): plain text at rest, so a text query still finds the whole line; during a change the old number leaves and the new one comes in, clipped with `clip-path: inset(0)`, since `overflow: hidden` would move an inline block's baseline (MDN, `clip-path`, read 2026-10-20 through Context7). With reduced motion the old number is `display: none` and no `animationend` comes, so the rolling markup stays until the next change. jsdom has no `AnimationEvent`, so React listens for a vendor-prefixed event there; `tests/unit/animation-event.ts` defines one before React loads.
 - **Desktop layout:** the body takes the viewport height only on pages that hold `[data-workspace]` (`lg:has-[[data-workspace]]:h-dvh` in `src/app/layout.tsx`, Tailwind's `has-*` variant), so the two panes scroll on their own and the transcripts page scrolls as before. On those pages the page is at most 1600px wide (`max-w-workspace`, from `--container-workspace` in `src/app/globals.css`), and the chat's column is `clamp(25rem, 38%, 32.5rem)`: 400px on a 1024px screen, 520px from about 1416px, with the PRD taking the rest (`docs/decisions.md`, Design, 2026-10-20). The header, the main area's padding and the footer take 114px of the height. The header is 45px on every page, not only the workspace, so it doesn't change height when the intro gives way to the chat; the focused skip link fits inside it. `tests/e2e/layout.spec.ts` measures all of it.
 - **The typeface** (slice 18): Inter, through `next/font/google` in `src/app/layout.tsx` (Next.js 16, `next/font`, read 2026-10-21 through Context7): its files are downloaded at build time and served from `/_next/static/media/`, so the visitor's browser never asks Google, and the build needs Google Fonts to be reachable. Its licence is the SIL Open Font License 1.1 (https://github.com/rsms/inter, `LICENSE.txt`, read 2026-10-21), which allows bundling it with software. `variable: "--font-inter"` on `<html>` puts it first in `--font-sans` (`src/app/globals.css`, in `@theme inline`, so the variable resolves where it's used: Tailwind, *Theme variables*, read 2026-10-21 through Context7), with the system fonts behind it in case it fails. Inter is variable, so 400, 500 and 600 come from one file. Against a jump, Next adds "Inter Fallback", `local(Arial)` resized to Inter's metrics, shown until Inter arrives. On Windows Chromium, with Inter held back, the transcripts page grew 20px of 7,216 when it arrived, against 72px with plain Arial, and the layout-shift score stayed near 0 in both, as the top of the page barely moves; so `tests/e2e/pages.spec.ts` checks the fallback's form, not a measured jump. Where Arial isn't installed (Linux, Android), the fallback is the system's font, unresized.
-- **The chat's spacing:** 16px from a question to its answer, or to "Working…", and 32px between turns (`docs/decisions.md`, Design, 2026-10-20), through `data-role` on the conversation's items: a question that got no answer stays 32px from the next one. Inside an answer, 8px between steps in a row and 16px between a step and text either way (`spaceAbove` in `chat/conversation.tsx`, opencode's rule in `packages/session-ui/src/timeline/projection.ts` at 50c5fce, read 2026-10-20), and 24px before a failure notice, in the answer and above the chat's alert.
-- **The moving line** (slice 11): while an answer is on its way exactly one line moves, the latest step in progress, or "Working…" at the answer's end whenever no step runs and no text arrives. Text at the answer's end counts as arriving even once its part is `done`: a reply's steps come after its text, so trailing text means the answer is finishing, and a "Working…" that flashed there before the stream closed left the chat 48px off its end, so it stopped following when the message box grew (found 2026-10-20 by `tests/e2e/layout.spec.ts`). Nothing moves once the status leaves `submitted`/`streaming` (`activityOf` in `chat/conversation.tsx`). The band is the one shared class `.shimmer` in `src/app/globals.css`, for slices 13, 15 and 20 to reuse: a gradient clipped to the text, only under `prefers-reduced-motion: no-preference` and `forced-colors: none` and where `background-clip: text` is supported, so everywhere else the line is still and grey (MDN, `background-clip`, Accessibility, read 2026-10-20 through Context7). It is decoration: the screen reader's status line in `chat/chat.tsx` is unchanged. jsdom applies no media queries, so the unit tests check which line carries `.shimmer`, and `tests/e2e/chat.spec.ts` checks the animation and the still line with `page.emulateMedia({ reducedMotion })`.
-- **The search lines** (slice 15, `chat/search-step.tsx`, `chat/search-run.tsx`): opencode’s form at 50c5fce (`docs/decisions.md`, Design, 2026-10-20). Each search is a plain `<p>`, never a button: "Search" in medium weight, the query and what came of it in grey, 13px, one line cut off with `truncate` (a failure keeps its whole reason). The dot is `aria-hidden` and an `sr-only` "passages from" goes before the names. Searches in a row (`laidOut` in `chat/conversation.tsx`) fold into `SearchRun`: a button "Used 3 searches" with `aria-expanded`, whose count is the shared `RollingNumber` (`src/components/rolling-number.tsx`, also the PRD’s), then an inline SVG triangle, `-rotate-90` and `opacity-45` at rest, full on hover and turned down when open, through Tailwind’s `group-aria-expanded:`; its lines sit in `.fold` (`src/app/globals.css`), a one-row grid from `0fr` to `1fr` with `visibility` held back until the slide ends, and `inert` while closed, which takes them out of the accessibility tree and the tab order (MDN, `inert`, read 2026-10-20 through Context7). Interpolating the row from `0fr` was checked in Chromium only (2026-10-20); where it doesn’t interpolate, the lines appear at once. Rows are `leading-7`, 8px apart, 4px under the button. While a run’s search runs, the run’s span carries `.shimmer`, and its white parts drop their colour, since `text-foreground` would cover the band. The fake model searches three times when a message holds `FAKE_SEARCH_AGAIN`, which the end-to-end tests use.
+- **The chat's spacing:** 16px from a question to its answer, or to "Thinking", and 32px between turns (`docs/decisions.md`, Design, 2026-10-20), through `data-role` on the conversation's items: a question that got no answer stays 32px from the next one. Inside an answer, 8px between steps in a row and 16px between a step and text either way (`spaceAbove` in `chat/conversation.tsx`, opencode's rule in `packages/session-ui/src/timeline/projection.ts` at 50c5fce, read 2026-10-20), and 24px before a failure notice, in the answer and above the chat's alert.
+- **The moving line** (slice 11): while an answer is on its way exactly one line moves, the latest step in progress, or "Thinking" (slice 20, below) at the answer's end whenever no step runs and no reply arrives. Text at the answer's end counts as arriving even once its part is `done`, and so does a thought's time, which comes just before its reply: a reply's steps come after its text, so trailing text means the answer is finishing, and a "Working…", as the line read then, that flashed there before the stream closed left the chat 48px off its end, so it stopped following when the message box grew (found 2026-10-20 by `tests/e2e/layout.spec.ts`). Nothing moves once the status leaves `submitted`/`streaming` (`activityOf` in `chat/conversation.tsx`). The band is the one shared class `.shimmer` in `src/app/globals.css`, for slices 13, 15 and 20 to reuse: a gradient clipped to the text, only under `prefers-reduced-motion: no-preference` and `forced-colors: none` and where `background-clip: text` is supported, so everywhere else the line is still and grey (MDN, `background-clip`, Accessibility, read 2026-10-20 through Context7). It is decoration: the screen reader's status line in `chat/chat.tsx` is unchanged. jsdom applies no media queries, so the unit tests check which line carries `.shimmer`, and `tests/e2e/chat.spec.ts` checks the animation and the still line with `page.emulateMedia({ reducedMotion })`.
+- **The search lines** (slice 15, `chat/search-step.tsx`, `chat/search-run.tsx`): opencode’s form at 50c5fce (`docs/decisions.md`, Design, 2026-10-20). Each search is a plain `<p>`, never a button: "Search" in medium weight, the query and what came of it in grey, 13px, one line cut off with `truncate` (a failure keeps its whole reason). The dot is `aria-hidden` and an `sr-only` "passages from" goes before the names. Searches in a row (`laidOut` in `chat/conversation.tsx`) fold into `SearchRun`: a button "Used 3 searches" with `aria-expanded`, whose count is the shared `RollingNumber` (`src/components/rolling-number.tsx`, also the PRD’s), then an inline SVG triangle, `-rotate-90` and `opacity-45` at rest, full on hover and turned down when open, through Tailwind’s `group-aria-expanded:`; its lines sit in `.fold` (`src/app/globals.css`), a one-row grid from `0fr` to `1fr` with `visibility` held back until the slide ends, and `inert` while closed, which takes them out of the accessibility tree and the tab order (MDN, `inert`, read 2026-10-20 through Context7). Interpolating the row from `0fr` was checked in Chromium only (2026-10-20); where it doesn’t interpolate, the lines appear at once. Rows are `leading-7`, 8px apart, 4px under the button. While a run’s search runs, the run’s span carries `.shimmer`, and its white parts drop their colour, since `text-foreground` would cover the band. The fake model searches three times when a message holds `FAKE_SEARCH_AGAIN`, which the end-to-end tests use. A run takes in the thought lines (below) in its unbroken stretch of searches and thoughts, before, between and after the searches, as opencode's `groupContent` does; a stretch with one search stays plain lines, and the count counts searches only.
+- **How long the model thought** (slice 20, `chat/thoughts.ts`, `chat/thought-line.tsx`): opencode's form at 50c5fce (`docs/decisions.md`, Design, 2026-10-21): "Thinking" while it thinks, 13px medium on a 16px line with `.shimmer`, then "Thought" in medium weight and white with the time in grey and tabular figures, as "Thought 8s", and from a minute "1m 5s", whole seconds rounded (opencode's `AssistantReasoningContent` in `packages/session-ui/src/message/message-content.tsx` and its words in `packages/ui/src/i18n/en.ts`, read 2026-10-21). The line doesn't open. The server can't time the reasoning, since the chat model's replies arrive whole, so the browser times each wait for a reply: `TimedTransport` in `workspace/workspace.tsx` pipes each answer's stream through `timeThoughts`, which starts the first wait at the request and each later one when the last step running finishes (a tool output), and puts a `data-thought` chunk with `{ ms }` just before the chunk that begins the next reply (text or a tool's input). The AI SDK keeps it as a part of the answer in that place (any `data-*` chunk without `transient`, ai 7.0.143, `processUIMessageStream`), so it's stored and restored with the conversation; a wait the answer ends in, stopped or failed, gets none. The parts go back to the server with the conversation, where `safeValidateUIMessages` accepts any `data-*` part and `convertToModelMessages` drops it unless given `convertDataPart`, so the model's input doesn't change (`tests/unit/chat.test.ts` compares it with and without the times). `finishedOnly` counts a thought as nothing finished. An answer kept before slice 20 has none and shows none, so `STORED_FORMAT` stayed 2: the new part only adds to what fits.
 - **New text fades in** (slice 16, `chat/rich-text.tsx`): opencode's `markdown-word-enter` at 50c5fce, an opacity fade of 180ms (`.word-enter` in `src/app/globals.css`, only under `prefers-reduced-motion: no-preference`). Only an answer that came in after the conversation mounted fades (`shownAtFirst` in `chat/conversation.tsx`), never one it mounted with, such as a conversation brought back after a reload; this, not the chat's status, decides it, since an answer's last text can arrive in the same render that ends the answer. `RichText` keeps where each update's words begin (`starts`, in characters shown, React's "storing information from previous renders" pattern) and wraps each update's words in one span per run, so a reply that arrives in one piece, as on staging, fades as one and is still one text node for `getByText`; the fake model's words, one per 15ms, fade by groups. `Arrival` keeps from its mount whether it fades: the next update doesn't cut a fade short, and words mounted anew by a change of form (a table taking shape) don't fade again. Under reduced motion (`useReducedMotion`, `chat/use-reduced-motion.ts`, a `useSyncExternalStore` on `matchMedia`, which jsdom lacks, so there nothing asks for it) the text has no spans at all. The conversation stays out of any live region. axe reads a word mid-fade as low contrast, so `tests/e2e/accessibility.ts` finishes every fade while axe reads.
 - **Tables** (slice 19, `chat/rich-text.tsx`; the parser in `src/lib/markdown.ts`, which only the browser uses): opencode's at 50c5fce (`docs/decisions.md`, Design, 2026-10-20): a real `<table>`, its header's named cells `<th scope="col">` in medium weight over `border-border-strong`, rows over `border-border`, both `0.5px` (Chromium draws 1px on a screen of 1x), cells `p-3 align-top`. Each cell is `min-w-36`, which Chromium honours on table cells, so a wide table scrolls rather than squeezing its columns to a word per line. Every row is padded to the widest row or the header with empty `<td>`s, so the hairlines run the full width; a header's empty name is a `<td>` too, as it names nothing, and a row or header of nothing but empty cells is dropped by the parser. The table sits in `SideScroll`, an `overflow-x-auto` box that a `ResizeObserver` measures, on itself and on the table: while the table is wider, the box is `role="region"`, named "Table, scrolls sideways", with `tabIndex={0}`, so the keyboard reaches it (axe's `scrollable-region-focusable`, which checks only a box that overflows); a table that fits adds no tab stop. A hidden Browser pane delivers the observer's first measure only when it next draws. The cells' runs are built in `RichText`'s render, not inside `SideScroll`, so the fade's character count (`words.at`) keeps the rendered order. The fake model writes no table, so `tests/e2e/chat.spec.ts` opens a kept conversation that holds two.
 - **Stop** (slice 12): while the assistant works, the message box's Send button is Stop, one `<button>` whose label and type change, so focus stays on it; an empty Send is `aria-disabled`, not `disabled`, which would drop focus to the page. A Stop click calls `preventDefault()`: `useChat`'s `stop()` can end the answer and turn the button back into a submit button before the browser's default action, which then sent the draft (found 2026-10-20 by `tests/e2e/chat.spec.ts`; jsdom's `fireEvent` doesn't show it). `stop()` aborts the request, sets the status to `ready` and calls `onFinish` with `isAbort` (ai 7.0.143, `AbstractChat.stop` and `makeRequest` in `node_modules/ai/dist/index.js`, read 2026-10-20; the AI SDK's *Stopping Streams*, through Context7); `afterAnswer` marks the question as stopped only when `stopRequested` says the visitor pressed Stop, since "Start over" aborts too. The route hands the cancel to the model call (`request.signal`), so no further model calls follow; the call in flight is a whole reply, which Cloudflare may still finish and count.
@@ -22,7 +23,7 @@
 - **What's kept:** the whole conversation, in `localStorage` under `prd-assistant:conversation`, with `format` (`STORED_FORMAT`, 2 since slice 12 added `stopped`), `interrupted` and `stopped`, the questions whose answers the visitor stopped. The PRD isn't stored apart: it's rebuilt from the conversation, as always, and its chat quotes find their messages there. `Workspace` keeps it after every answer, finished or failed, never while one is on its way, and forgets it once the conversation is empty ("Start over", a failed first request). A browser that refuses storage or has no room keeps nothing, and nothing else changes.
 - **Browser-only rendering:** `use(browser())` from `react-dom` (React 19.3) inside a `<Suspense>` whose fallback is the intro without its handlers. The server's page is that intro; in the browser the workspace's first render already holds what's kept, so `useChat` starts with it (`messages`) and nothing flashes between hydration and the restored view (https://react.dev/reference/react-dom/browser and Next.js's *Single-Page Applications* guide, "Rendering components only in the browser", read 2026-10-20 through Context7). The fallback's buttons are `aria-disabled` until then: they look the same, and Playwright waits for them instead of clicking into nothing.
 - **A kept answer that broke off** (`interrupted`) shows as failed after the reload, with "Try again", until the next request, exactly as before it; sending a new message drops it first, as after any failure.
-- **The check:** `restoreConversation` checks the stored form with Zod, synchronously, before the first render. It checks to the letter what the browser reads (a saved section, a search's passages, each part's type and state) and lets the rest through loosely; the server checks every message again when the next one is sent. A conversation that doesn't fit is removed, and the intro says "The PRD you started earlier couldn't be brought back: the demo has changed since. You can start a new one." until the visitor goes on. The schemas are held to the types in `src/lib` with `satisfies`, so a change there fails the typecheck. **Raise `STORED_FORMAT`** with any change that could stop an older conversation fitting: `ChatMessage`, the checked section, the parts the chat shows, or an upgrade of `ai`.
+- **The check:** `restoreConversation` checks the stored form with Zod, synchronously, before the first render. It checks to the letter what the browser reads (a saved section, a search's passages, each part's type and state) and lets the rest through loosely; the server checks every message again when the next one is sent. A conversation that doesn't fit is removed, and the intro says "The PRD you started earlier couldn't be brought back: the demo has changed since. You can start a new one." until the visitor goes on. The schemas are held to the types in `src/lib` with `satisfies`, so a change there fails the typecheck. **Raise `STORED_FORMAT`** with any change that could stop an older conversation fitting: `ChatMessage`, the checked section, the parts the chat shows, or an upgrade of `ai`. A new kind of part that older conversations simply lack, such as the thinking times, doesn't need it.
 - **Kept out of `src/lib`,** like the intro's logic, so the measurement's comparison doesn't report it.
 
 ## The download (`prd/prd-markdown.ts`)
diff --git a/src/features/chat/conversation.tsx b/src/features/chat/conversation.tsx
index 26b6d86..5aad4d3 100644
--- a/src/features/chat/conversation.tsx
+++ b/src/features/chat/conversation.tsx
@@ -14,21 +14,26 @@ import { RichText } from "./rich-text";
 import { SearchRun } from "./search-run";
 import { SearchStep } from "./search-step";
 import { SectionStep } from "./section-step";
+import { ThinkingLine, ThoughtLine } from "./thought-line";
+import { isThought, type ThoughtPart } from "./thoughts";
 
 type ShownPart =
   | Extract<ChatMessagePart, { type: "text" }>
   | SearchNotesPart
   | SaveSectionPart
-  | FailedToolPart;
+  | FailedToolPart
+  | ThoughtPart;
 
 /**
- * The parts a visitor sees: the text, the searches, the saved sections, and
- * any tool call the app couldn't read.
+ * The parts a visitor sees: the text, the searches, the saved sections, any
+ * tool call the app couldn't read, and how long the model thought before
+ * each reply.
  */
 function shownParts(message: ChatMessage): ShownPart[] {
   return message.parts.filter(
     (part): part is ShownPart =>
       (part.type === "text" && part.text !== "") ||
+      isThought(part) ||
       part.type === "tool-searchNotes" ||
       part.type === "tool-saveSection" ||
       (part.type === "dynamic-tool" && part.state === "output-error"),
@@ -45,23 +50,29 @@ function inProgress(part: ShownPart): boolean {
 
 /**
  * What shows that an answer on its way is still being worked on: the latest
- * step in progress, the text as it arrives, or else "Working…" at its end.
- * Text at the end counts as arriving even once its part is done: a reply's
- * steps come after its text (whole replies, slice 8a), so trailing text means
- * the answer is finishing, and "Working…" would only flash before it ends.
+ * step in progress, the reply as it arrives, or else "Thinking" at its end,
+ * while the model thinks before its next reply (`chat/thoughts.ts`). Text at
+ * the end counts as arriving even once its part is done: a reply's steps come
+ * after its text (whole replies, slice 8a), so trailing text means the answer
+ * is finishing, and "Thinking" would only flash before it ends. A thought's
+ * time at the end means its reply has begun.
  */
-type Activity = { step: number } | "text" | "working";
+type Activity = { step: number } | "reply" | "thinking";
 
 function activityOf(parts: ShownPart[]): Activity {
   const step = parts.findLastIndex(inProgress);
   if (step !== -1) return { step };
-  return parts.at(-1)?.type === "text" ? "text" : "working";
+  const last = parts.at(-1);
+  return last !== undefined && (last.type === "text" || isThought(last))
+    ? "reply"
+    : "thinking";
 }
 
 /**
  * The messages so far. While the assistant works, its steps and its text
  * appear as they stream in, and exactly one line moves: the step in
- * progress, or "Working…" whenever no step runs and no text arrives. An
+ * progress, or "Thinking" whenever no step runs and no reply arrives. Each
+ * reply follows a line with how long the model thought before it. An
  * answer that broke off stays visible, marked as unfinished, until it's
  * retried or replaced. An answer the visitor stopped keeps what it finished
  * and says so. The text of an answer that came in after the chat showed
@@ -94,7 +105,7 @@ export function Conversation({
   if (messages.length === 0 && !waiting) return null;
 
   // A question sits closer to its own answer than to the turn before it:
-  // 16px to its answer, or to "Working…" while that's on its way, and 32px
+  // 16px to its answer, or to "Thinking" while that's on its way, and 32px
   // between turns, a question that got no answer included (docs/
   // decisions.md, Design, 2026-10-20).
   return (
@@ -141,22 +152,13 @@ export function Conversation({
       {waiting && (
         <li data-role="assistant">
           <p className="sr-only">Assistant</p>
-          <WorkingLine />
+          <ThinkingLine />
         </li>
       )}
     </ol>
   );
 }
 
-/** "Working…", with the moving band (`.shimmer` in `src/app/globals.css`). */
-function WorkingLine({ className }: { className?: string }) {
-  return (
-    <p className={cn("shimmer text-sm text-muted-foreground", className)}>
-      Working…
-    </p>
-  );
-}
-
 /** The step a tool call the app couldn't read was meant to be. */
 function failedStep(toolName: string): string {
   switch (toolName) {
@@ -184,38 +186,53 @@ function spaceAbove(
 
 /**
  * An answer's parts as the chat lays them out: two or more searches in a row
- * fold into one run (docs/decisions.md, Design, 2026-10-20); a text or a save
- * between them starts a new one. `first` and `last` are the run's indexes
- * among the parts.
+ * fold into one run (docs/decisions.md, Design, 2026-10-20), with the times
+ * the model thought before, between and after them, as opencode folds its
+ * reasoning with the tools around it (`groupContent` in
+ * `packages/session-ui/src/timeline/projection.ts` at 50c5fce, read
+ * 2026-10-21); a text or a save between them starts a new one. `first` and
+ * `last` are the run's indexes among the parts.
  */
+type RunPart = SearchNotesPart | ThoughtPart;
+
 type Laid =
   | { part: ShownPart; first: number; last: number }
-  | { run: SearchNotesPart[]; first: number; last: number };
+  | { run: RunPart[]; first: number; last: number };
 
 function laidOut(parts: ShownPart[]): Laid[] {
   const laid: Laid[] = [];
+  let stretch: { parts: RunPart[]; first: number } | undefined;
+  const endStretch = () => {
+    if (stretch === undefined) return;
+    const { parts: run, first } = stretch;
+    if (run.filter((part) => !isThought(part)).length >= 2) {
+      laid.push({ run, first, last: first + run.length - 1 });
+    } else {
+      run.forEach((part, offset) =>
+        laid.push({ part, first: first + offset, last: first + offset }),
+      );
+    }
+    stretch = undefined;
+  };
   parts.forEach((part, index) => {
-    const before = laid.at(-1);
-    if (part.type === "tool-searchNotes" && before !== undefined) {
-      if ("run" in before) {
-        before.run.push(part);
-        before.last = index;
-        return;
-      }
-      if (before.part.type === "tool-searchNotes") {
-        laid[laid.length - 1] = {
-          run: [before.part, part],
-          first: before.first,
-          last: index,
-        };
-        return;
-      }
+    if (part.type === "tool-searchNotes" || isThought(part)) {
+      stretch ??= { parts: [], first: index };
+      stretch.parts.push(part);
+      return;
     }
+    endStretch();
     laid.push({ part, first: index, last: index });
   });
+  endStretch();
   return laid;
 }
 
+/** A run's key: its first search's, which stays first as the run grows. */
+function runKey(run: RunPart[]): string {
+  const search = run.find((part) => part.type === "tool-searchNotes");
+  return search?.toolCallId ?? "run";
+}
+
 function AssistantMessage({
   parts,
   arriving = false,
@@ -249,7 +266,7 @@ function AssistantMessage({
         if ("run" in laid) {
           return (
             <SearchRun
-              key={laid.run[0]!.toolCallId}
+              key={runKey(laid.run)}
               parts={laid.run}
               stopped={stopped}
               moving={moving}
@@ -259,6 +276,9 @@ function AssistantMessage({
         }
         const { part, first: index } = laid;
         const step = cn(space, moving && "shimmer");
+        if (isThought(part)) {
+          return <ThoughtLine key={index} part={part} className={space} />;
+        }
         switch (part.type) {
           case "text":
             return (
@@ -299,8 +319,8 @@ function AssistantMessage({
             );
         }
       })}
-      {activity === "working" && (
-        <WorkingLine className={lastPart?.type === "text" ? "mt-4" : "mt-2"} />
+      {activity === "thinking" && (
+        <ThinkingLine className={lastPart?.type === "text" ? "mt-4" : "mt-2"} />
       )}
       {unfinished && (
         <p className="mt-6 text-sm font-medium">
diff --git a/src/features/chat/search-run.tsx b/src/features/chat/search-run.tsx
index a9ad876..ce38d10 100644
--- a/src/features/chat/search-run.tsx
+++ b/src/features/chat/search-run.tsx
@@ -5,6 +5,8 @@ import { RollingNumber } from "@/components/rolling-number";
 import type { SearchNotesPart } from "@/lib/chat";
 import { cn } from "@/lib/utils";
 import { SearchStep } from "./search-step";
+import { ThoughtLine } from "./thought-line";
+import { isThought, type ThoughtPart } from "./thoughts";
 
 /**
  * Two or more searches in a row, folded into one line that opens to their
@@ -12,7 +14,9 @@ import { SearchStep } from "./search-step";
  * 3 searches", its count rolling up as each search starts, then a small
  * triangle that turns down when the line opens (docs/decisions.md, Design,
  * 2026-10-20). The lines slide open (`.fold` in `src/app/globals.css`) and
- * are inert while closed, so screen readers and the keyboard skip them.
+ * are inert while closed, so screen readers and the keyboard skip them. The
+ * times the model thought around the searches fold with them, as opencode
+ * folds its reasoning, and the count counts only the searches.
  */
 export function SearchRun({
   parts,
@@ -20,7 +24,7 @@ export function SearchRun({
   moving = false,
   className,
 }: {
-  parts: SearchNotesPart[];
+  parts: Array<SearchNotesPart | ThoughtPart>;
   /** Its answer was stopped, so a search still running never finished. */
   stopped?: boolean;
   /** The line in progress carries the moving band (`.shimmer`). */
@@ -29,6 +33,7 @@ export function SearchRun({
 }) {
   const [open, setOpen] = useState(false);
   const linesId = useId();
+  const searches = parts.filter((part) => !isThought(part)).length;
   return (
     <div className={cn("text-[0.8125rem]", className)}>
       <button
@@ -42,7 +47,7 @@ export function SearchRun({
         <span className={cn(moving && "shimmer")}>
           Used{" "}
           <span className={cn("font-medium", !moving && "text-foreground")}>
-            <RollingNumber value={parts.length} /> searches
+            <RollingNumber value={searches} /> searches
           </span>
         </span>
         <svg
@@ -61,14 +66,18 @@ export function SearchRun({
       >
         <div>
           <div className="flex flex-col gap-2 pt-1">
-            {parts.map((part) => (
-              <SearchStep
-                key={part.toolCallId}
-                part={part}
-                stopped={stopped}
-                className="leading-7"
-              />
-            ))}
+            {parts.map((part, index) =>
+              isThought(part) ? (
+                <ThoughtLine key={index} part={part} className="leading-7" />
+              ) : (
+                <SearchStep
+                  key={part.toolCallId}
+                  part={part}
+                  stopped={stopped}
+                  className="leading-7"
+                />
+              ),
+            )}
           </div>
         </div>
       </div>
diff --git a/src/features/chat/thought-line.tsx b/src/features/chat/thought-line.tsx
new file mode 100644
index 0000000..f272579
--- /dev/null
+++ b/src/features/chat/thought-line.tsx
@@ -0,0 +1,43 @@
+import { cn } from "@/lib/utils";
+import { thoughtTime, type ThoughtPart } from "./thoughts";
+
+// opencode's lines for the model's reasoning, at 50c5fce (docs/decisions.md,
+// Design, 2026-10-21): "Thinking" while it thinks, then "Thought" with the
+// time in grey, at 13px with a 16px line height, the form of the search
+// lines. Unlike opencode's, the line doesn't open: the reasoning's words
+// never reach the browser.
+
+/** "Thinking", with the moving band (`.shimmer` in `src/app/globals.css`). */
+export function ThinkingLine({ className }: { className?: string }) {
+  return (
+    <p
+      className={cn(
+        "shimmer text-[0.8125rem] leading-4 font-medium text-muted-foreground",
+        className,
+      )}
+    >
+      Thinking
+    </p>
+  );
+}
+
+/** How long the model thought before a reply, as "Thought 8s". */
+export function ThoughtLine({
+  part,
+  className,
+}: {
+  part: ThoughtPart;
+  className?: string;
+}) {
+  return (
+    <p
+      className={cn(
+        "text-[0.8125rem] leading-4 text-muted-foreground",
+        className,
+      )}
+    >
+      <span className="font-medium text-foreground">Thought</span>{" "}
+      <span className="tabular-nums">{thoughtTime(part.data.ms)}</span>
+    </p>
+  );
+}
diff --git a/src/features/chat/thoughts.ts b/src/features/chat/thoughts.ts
new file mode 100644
index 0000000..6a27163
--- /dev/null
+++ b/src/features/chat/thoughts.ts
@@ -0,0 +1,86 @@
+import type { UIMessageChunk } from "ai";
+import type { ChatMessagePart } from "@/lib/chat";
+
+// How long the model thought before each reply, measured in the browser. The
+// chat model gives whole replies (`src/server/ai/cloudflare.ts`), and gpt-oss
+// reasons before it replies, so each wait for a reply is the sign that it's
+// thinking: from the request, or from the moment a step finished, to the
+// reply's first text or step. The reasoning's words never reach the browser
+// (`sendReasoning: false` in `src/server/chat.ts`), only these times.
+//
+// Each time is a `data-thought` part of the answer, placed where the reply
+// began, so it's kept with the conversation and outlasts a reload. The model
+// never sees it: `convertToModelMessages` leaves out data parts (ai 7.0.143),
+// which `tests/unit/chat.test.ts` holds.
+
+export const THOUGHT_PART = "data-thought";
+
+/** How long the model thought before a reply, in milliseconds. */
+export type ThoughtPart = {
+  type: typeof THOUGHT_PART;
+  id?: string;
+  data: { ms: number };
+};
+
+export function isThought(part: ChatMessagePart): part is ThoughtPart {
+  return part.type === THOUGHT_PART;
+}
+
+/**
+ * The time as opencode writes it after "Thought": whole seconds, then
+ * minutes and seconds from a minute on, as "8s" and "1m 5s"
+ * (`packages/session-ui/src/message/message-content.tsx` and
+ * `packages/ui/src/i18n/en.ts` at 50c5fce, read 2026-10-21).
+ */
+export function thoughtTime(ms: number): string {
+  const total = Math.max(0, Math.round(ms / 1000));
+  if (total < 60) return `${total}s`;
+  return `${Math.floor(total / 60)}m ${total % 60}s`;
+}
+
+/** The chunks that begin a reply: its text, or one of its steps. */
+const REPLY_STARTS = new Set<UIMessageChunk["type"]>([
+  "text-start",
+  "tool-input-start",
+  "tool-input-available",
+  "tool-input-error",
+]);
+
+/** The chunks that end a step. */
+const STEP_ENDS = new Set<UIMessageChunk["type"]>([
+  "tool-output-available",
+  "tool-output-error",
+  "tool-output-denied",
+]);
+
+/**
+ * Times the waits in an answer's stream: the first from `requested`, each
+ * later one from the moment the last step running finished. A `data-thought`
+ * chunk goes in just before the reply that ends the wait. A wait the answer
+ * ends in, stopped or failed, has no reply and gets none.
+ */
+export function timeThoughts(
+  requested: number,
+  now: () => number = () => performance.now(),
+): TransformStream<UIMessageChunk, UIMessageChunk> {
+  let waitingSince: number | undefined = requested;
+  const running = new Set<string>();
+  return new TransformStream({
+    transform(chunk, controller) {
+      if (REPLY_STARTS.has(chunk.type)) {
+        if (waitingSince !== undefined) {
+          controller.enqueue({
+            type: THOUGHT_PART,
+            data: { ms: Math.round(now() - waitingSince) },
+          });
+          waitingSince = undefined;
+        }
+        if ("toolCallId" in chunk) running.add(chunk.toolCallId);
+      } else if (STEP_ENDS.has(chunk.type) && "toolCallId" in chunk) {
+        running.delete(chunk.toolCallId);
+        if (running.size === 0) waitingSince = now();
+      }
+      controller.enqueue(chunk);
+    },
+  });
+}
diff --git a/src/features/workspace/stopped-answer.ts b/src/features/workspace/stopped-answer.ts
index 8475c78..3f6cf4d 100644
--- a/src/features/workspace/stopped-answer.ts
+++ b/src/features/workspace/stopped-answer.ts
@@ -1,4 +1,5 @@
 import { isToolUIPart } from "ai";
+import { isThought } from "@/features/chat/thoughts";
 import type { ChatMessage, ChatMessagePart } from "@/lib/chat";
 
 // An answer the visitor stopped keeps what it finished: its text so far, its
@@ -23,7 +24,10 @@ export function finishedOnly(messages: ChatMessage[]): ChatMessage[] {
   return messages.flatMap((message) => {
     if (message.role !== "assistant") return [message];
     const parts = message.parts.filter((part) => !unfinishedStep(part));
-    if (parts.every((part) => part.type === "step-start")) return [];
+    // A time the model thought is no reply of its own (`chat/thoughts.ts`).
+    if (parts.every((part) => part.type === "step-start" || isThought(part))) {
+      return [];
+    }
     return [{ ...message, parts }];
   });
 }
diff --git a/src/features/workspace/stored-conversation.ts b/src/features/workspace/stored-conversation.ts
index ab4c204..76c42cf 100644
--- a/src/features/workspace/stored-conversation.ts
+++ b/src/features/workspace/stored-conversation.ts
@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { THOUGHT_PART, type ThoughtPart } from "@/features/chat/thoughts";
 import type { ChatMessage, SearchNotesOutput } from "@/lib/chat";
 import {
   PRD_SECTIONS,
@@ -20,7 +21,9 @@ export const STORAGE_KEY = "prd-assistant:conversation";
  * The stored form's version. Raise it whenever a stored conversation could
  * stop fitting the code: a change to `ChatMessage`, to the checked section or
  * to the parts the chat shows, or an upgrade of `ai`. An older one is then
- * discarded with a notice, not shown broken.
+ * discarded with a notice, not shown broken. A new kind of part that older
+ * conversations simply lack, such as the model's thinking times, needs no
+ * raise: they still fit.
  */
 export const STORED_FORMAT = 2;
 
@@ -110,8 +113,19 @@ function toolPart<Type extends string, Output extends z.ZodType>(
   ]);
 }
 
-/** The parts the server's answers hold (`src/server/chat.ts`). */
+/** How long the model thought before a reply, as the browser timed it. */
+const thoughtPartSchema = z.object({
+  type: z.literal(THOUGHT_PART),
+  id: z.string().optional(),
+  data: z.object({ ms: z.number().nonnegative() }),
+}) satisfies z.ZodType<ThoughtPart>;
+
+/**
+ * The parts the server's answers hold (`src/server/chat.ts`), and the times
+ * the browser adds to them. An answer kept before the times existed has none.
+ */
 const partSchema = z.union([
+  thoughtPartSchema,
   z.looseObject({ type: z.literal("text"), text: z.string() }),
   z.looseObject({ type: z.literal("step-start") }),
   toolPart("tool-searchNotes", searchNotesOutputSchema),
diff --git a/src/features/workspace/workspace.tsx b/src/features/workspace/workspace.tsx
index 451c70e..ca74e0c 100644
--- a/src/features/workspace/workspace.tsx
+++ b/src/features/workspace/workspace.tsx
@@ -13,6 +13,7 @@ import {
 } from "react";
 import { browser } from "react-dom";
 import { Chat, MESSAGE_BOX_ID } from "@/features/chat/chat";
+import { timeThoughts } from "@/features/chat/thoughts";
 import { PrdDocument } from "@/features/prd/prd-document";
 import {
   latestSave,
@@ -33,7 +34,18 @@ import { Intro, INTRO_TITLE_ID } from "./intro";
 import { keepConversation, restoreConversation } from "./stored-conversation";
 import { finishedOnly, unfinishedStep } from "./stopped-answer";
 
-const transport = new DefaultChatTransport<ChatMessage>({
+/** The chat's requests, with each wait for the model's reply timed. */
+class TimedTransport extends DefaultChatTransport<ChatMessage> {
+  override async sendMessages(
+    options: Parameters<DefaultChatTransport<ChatMessage>["sendMessages"]>[0],
+  ) {
+    const requested = performance.now();
+    const stream = await super.sendMessages(options);
+    return stream.pipeThrough(timeThoughts(requested));
+  }
+}
+
+const transport = new TimedTransport({
   api: "/api/chat",
   // A stopped answer goes back with only the parts it finished.
   prepareSendMessagesRequest: ({ body, id, messages, trigger, messageId }) => ({
diff --git a/tests/e2e/chat.spec.ts b/tests/e2e/chat.spec.ts
index a06c4fe..f7aa903 100644
--- a/tests/e2e/chat.spec.ts
+++ b/tests/e2e/chat.spec.ts
@@ -58,6 +58,38 @@ test.describe("chat", () => {
     await expect(conversation(page).getByRole("button")).toHaveCount(0);
   });
 
+  test("says how long the model thought before each reply, in a line that doesn't open, after a reload too", async ({
+    page,
+  }) => {
+    await openChat(page);
+    await ask(page, QUESTION);
+    await expect(conversation(page)).toContainText(FAKE_NOTE);
+
+    // The fake model searches, then replies: a wait before each.
+    const thoughts = conversation(page).getByText(/^Thought \d+s$/);
+    await expect(thoughts).toHaveCount(2);
+    const answer = conversation(page).getByRole("listitem").nth(1);
+    await expect(answer).toHaveText(
+      /^Assistant\s*Thought \d+s\s*Search “[^”]+” · passages from [^]*Thought \d+s\s*I searched the interviews/,
+    );
+    await expect(thoughts.first()).toHaveCSS("font-size", "13px");
+    await expect(thoughts.first()).toHaveCSS("line-height", "16px");
+    await expect(thoughts.first()).toHaveCSS("color", "rgb(180, 180, 180)");
+    await expect(thoughts.first().getByText("Thought")).toHaveCSS(
+      "font-weight",
+      "500",
+    );
+    await expect(conversation(page).getByRole("button")).toHaveCount(0);
+    const shown = await thoughts.allTextContents();
+
+    await expect(page.getByRole("button", { name: "Send" })).toBeVisible();
+    await page.reload();
+
+    await expect(conversation(page).getByText(/^Thought \d+s$/)).toHaveText(
+      shown,
+    );
+  });
+
   test("folds searches in a row into one line that slides open to them", async ({
     page,
   }) => {
@@ -79,11 +111,26 @@ test.describe("chat", () => {
 
     await expect(line).toHaveAttribute("aria-expanded", "true");
     for (const each of await lines.all()) await expect(each).toBeVisible();
-    const [first, second] = await lines.all();
-    const gap =
-      (await second!.boundingBox())!.y - (await first!.boundingBox())!.y;
+    // The times the model thought fold with the searches, around each one.
+    const rows = page.locator(
+      `[id="${await line.getAttribute("aria-controls")}"] p`,
+    );
+    await expect(rows).toHaveText([
+      /^Thought \d+s$/,
+      /^Search “/,
+      /^Thought \d+s$/,
+      /^Search “/,
+      /^Thought \d+s$/,
+      /^Search “/,
+      /^Thought \d+s$/,
+    ]);
+    const tops = await Promise.all(
+      (await rows.all()).map(async (row) => (await row.boundingBox())!.y),
+    );
     // 28px rows, 8px apart, as opencode's (docs/decisions.md, Design, 2026-10-20).
-    expect(gap).toBe(36);
+    for (let row = 1; row < tops.length; row++) {
+      expect(tops[row]! - tops[row - 1]!).toBe(36);
+    }
 
     await line.click();
 
@@ -132,7 +179,7 @@ test.describe("chat", () => {
   });
 
   for (const reducedMotion of ["no-preference", "reduce"] as const) {
-    test(`moves Working… while the answer is on its way, unless motion is reduced (${reducedMotion})`, async ({
+    test(`moves Thinking while the answer is on its way, unless motion is reduced (${reducedMotion})`, async ({
       page,
     }) => {
       await page.emulateMedia({ reducedMotion });
@@ -149,8 +196,14 @@ test.describe("chat", () => {
       await openChat(page);
       await ask(page, QUESTION);
 
-      const working = conversation(page).getByText("Working…");
+      const working = conversation(page).getByText("Thinking", {
+        exact: true,
+      });
       await expect(working).toBeVisible();
+      // opencode's Thinking row: 13px, medium weight, 16px high.
+      await expect(working).toHaveCSS("font-size", "13px");
+      await expect(working).toHaveCSS("font-weight", "500");
+      await expect(working).toHaveCSS("line-height", "16px");
       await expect(working).toHaveCSS(
         "animation-name",
         reducedMotion === "reduce" ? "none" : "shimmer",
diff --git a/tests/e2e/layout.spec.ts b/tests/e2e/layout.spec.ts
index 5f9c67d..25b30c0 100644
--- a/tests/e2e/layout.spec.ts
+++ b/tests/e2e/layout.spec.ts
@@ -124,10 +124,11 @@ test.describe("the workspace on a 1440px-wide laptop", () => {
 
     // A question, its answer, the next question and its answer.
     expectGaps(await childGaps(conversation(page)), [16, 32, 16]);
-    // The draft: its search and its save, steps in a row, then its text.
-    expectGaps(await childGaps(turns(page).nth(1)), [8, 16]);
-    // The answer: its search, then its text.
-    expectGaps(await childGaps(turns(page).nth(3)), [16]);
+    // The draft: its search and its save, steps in a row with the time the
+    // model thought before each reply, then its text.
+    expectGaps(await childGaps(turns(page).nth(1)), [8, 8, 8, 8, 16]);
+    // The answer: a time, its search, a time, then its text.
+    expectGaps(await childGaps(turns(page).nth(3)), [8, 8, 16]);
   });
 
   test("puts a failure notice 24px under what came before it", async ({
@@ -144,8 +145,8 @@ test.describe("the workspace on a 1440px-wide laptop", () => {
     await expect(answer).toContainText(
       "This answer stopped before it finished.",
     );
-    // Its search, its text so far, then the notice.
-    expectGaps(await childGaps(answer), [16, 24]);
+    // A time, its search, a time, its text so far, then the notice.
+    expectGaps(await childGaps(answer), [8, 8, 16, 24]);
     // The conversation, then the alert with "Try again".
     expectGaps(await childGaps(page.locator("#chat-title + div")), [24]);
   });
@@ -270,7 +271,7 @@ test.describe("the workspace on a 1440px-wide laptop", () => {
       { times: 1 },
     );
     await ask(page, QUESTION);
-    const working = conversation(page).getByText("Working…");
+    const working = conversation(page).getByText("Thinking", { exact: true });
     await expect(working).toBeInViewport();
 
     const scroller = page.locator("#chat-title + div");
diff --git a/tests/unit/chat.test.ts b/tests/unit/chat.test.ts
index a2ba9b9..77169d5 100644
--- a/tests/unit/chat.test.ts
+++ b/tests/unit/chat.test.ts
@@ -924,6 +924,58 @@ describe("earlier answers, as they reach the model again", () => {
       ]),
     });
   });
+
+  it("reach the model exactly as before when they hold the browser's thinking times, which the request check accepts", async () => {
+    // The browser keeps how long the model thought before each reply as a
+    // data part of the answer (`src/features/chat/thoughts.ts`).
+    const stepped = (parts: ChatMessage["parts"]): ChatMessage["parts"] =>
+      parts.flatMap((part) => [{ type: "step-start" as const }, part]);
+    const thought = (ms: number) => ({
+      type: "data-thought" as const,
+      data: { ms },
+    });
+    const without = [
+      visitor("Draft the first section."),
+      { ...earlier, parts: stepped(earlier.parts) },
+      visitor("Who wants a ping for every item?", "visitor-2"),
+    ];
+    const withTimes = [
+      without[0]!,
+      {
+        ...earlier,
+        parts: earlier.parts.flatMap((part, index) => [
+          { type: "step-start" as const },
+          thought(1_000 * (index + 1)),
+          part,
+        ]),
+      },
+      without[2]!,
+    ];
+
+    const accepted = await readChatRequest({ messages: withTimes });
+    expect(accepted).toEqual(withTimes);
+    const prompts = async (messages: ChatMessage[]) => {
+      const fake = createFakeChatModel({
+        chunkDelayInMs: 0,
+        failedMessages: new Set(),
+      });
+      const calls: ChatModelCall[] = [];
+      const model: ChatModel = {
+        ...fake,
+        doStream: (call) => {
+          calls.push(call);
+          return fake.doStream(call);
+        },
+      };
+      await answer(messages, model);
+      return calls.map((call) => call.prompt);
+    };
+
+    const seen = await prompts(accepted);
+    expect(seen.length).toBeGreaterThan(1);
+    expect(seen).toEqual(await prompts(without));
+    expect(JSON.stringify(seen)).not.toContain("data-thought");
+  });
 });
 
 describe("when something fails", () => {
diff --git a/tests/unit/conversation.test.tsx b/tests/unit/conversation.test.tsx
index f34a374..12d1bef 100644
--- a/tests/unit/conversation.test.tsx
+++ b/tests/unit/conversation.test.tsx
@@ -2,6 +2,7 @@ import { fireEvent, render, screen, within } from "@testing-library/react";
 import type { ChatStatus } from "ai";
 import { describe, expect, it, vi } from "vitest";
 import { Conversation } from "@/features/chat/conversation";
+import type { ThoughtPart } from "@/features/chat/thoughts";
 import type { ChatMessage, SaveSectionPart, SearchNotesPart } from "@/lib/chat";
 import type { CheckedSection } from "@/lib/prd";
 import type { PassageMatch } from "@/lib/transcripts";
@@ -51,6 +52,11 @@ function search(
   } as SearchNotesPart;
 }
 
+/** How long the model thought before a reply. */
+function thought(ms: number): ThoughtPart {
+  return { type: "data-thought", data: { ms } };
+}
+
 /** A step's line, by its whole text. */
 function stepLine(text: string | RegExp): HTMLElement {
   return screen.getByText(stepText(text));
@@ -244,14 +250,14 @@ describe("Conversation", () => {
       return container.querySelectorAll(".shimmer");
     }
 
-    it("shows Working… before the first step", () => {
+    it("shows Thinking before the first reply", () => {
       const { container } = show([question], "submitted");
 
       expect(moving(container)).toHaveLength(1);
-      expect(moving(container)[0]).toHaveTextContent(/^Working…$/);
+      expect(moving(container)[0]).toHaveTextContent(/^Thinking$/);
     });
 
-    it("moves the step in progress, with no Working…", () => {
+    it("moves the step in progress, with no Thinking", () => {
       const { container } = show(
         [
           question,
@@ -260,7 +266,7 @@ describe("Conversation", () => {
         "streaming",
       );
 
-      expect(screen.queryByText("Working…")).not.toBeInTheDocument();
+      expect(screen.queryByText("Thinking")).not.toBeInTheDocument();
       expect(moving(container)).toHaveLength(1);
       expect(moving(container)[0]).toHaveTextContent(
         "Search “notifications for new items”…",
@@ -279,7 +285,7 @@ describe("Conversation", () => {
         "streaming",
       );
 
-      expect(screen.queryByText("Working…")).not.toBeInTheDocument();
+      expect(screen.queryByText("Thinking")).not.toBeInTheDocument();
       expect(moving(container)).toHaveLength(1);
       expect(moving(container)[0]).toHaveTextContent(/^Used 2 searches$/);
     });
@@ -304,7 +310,7 @@ describe("Conversation", () => {
       expect(moving(container)[0]).toHaveTextContent("Search “pings”…");
     });
 
-    it("shows Working… at the end of the answer between steps, and the finished step stays still", () => {
+    it("shows Thinking at the end of the answer between steps, and the finished step stays still", () => {
       const { container } = show(
         [
           question,
@@ -316,18 +322,18 @@ describe("Conversation", () => {
       const [, assistant] = within(
         screen.getByRole("list", { name: "Conversation" }),
       ).getAllByRole("listitem");
-      expect(assistant).toHaveTextContent(/Working…$/);
+      expect(assistant).toHaveTextContent(/Thinking$/);
       expect(moving(container)).toHaveLength(1);
-      expect(moving(container)[0]).toHaveTextContent(/^Working…$/);
+      expect(moving(container)[0]).toHaveTextContent(/^Thinking$/);
     });
 
-    it("doesn't flash Working… after the answer's last words while it finishes", () => {
+    it("doesn't flash Thinking after the answer's last words while it finishes", () => {
       const { container } = show(
         [question, answer({ type: "text", text: "Henk does.", state: "done" })],
         "streaming",
       );
 
-      expect(screen.queryByText("Working…")).not.toBeInTheDocument();
+      expect(screen.queryByText("Thinking")).not.toBeInTheDocument();
       expect(moving(container)).toHaveLength(0);
     });
 
@@ -344,10 +350,23 @@ describe("Conversation", () => {
         "streaming",
       );
 
-      expect(screen.queryByText("Working…")).not.toBeInTheDocument();
+      expect(screen.queryByText("Thinking")).not.toBeInTheDocument();
       expect(moving(container)).toHaveLength(0);
     });
 
+    it("stops Thinking once the reply begins with how long it thought", () => {
+      const { container } = show(
+        [question, answer(thought(3_000))],
+        "streaming",
+      );
+
+      expect(screen.queryByText("Thinking")).not.toBeInTheDocument();
+      expect(moving(container)).toHaveLength(0);
+      expect(screen.getByText("Thought").parentElement).toHaveTextContent(
+        /^Thought 3s$/,
+      );
+    });
+
     it.each(["ready", "error"] as const)(
       "moves nothing once the answer ends (%s)",
       (status) => {
@@ -363,12 +382,83 @@ describe("Conversation", () => {
           status,
         );
 
-        expect(screen.queryByText("Working…")).not.toBeInTheDocument();
+        expect(screen.queryByText("Thinking")).not.toBeInTheDocument();
         expect(moving(container)).toHaveLength(0);
       },
     );
   });
 
+  describe("how long the model thought", () => {
+    const done = (toolCallId: string, query: string) =>
+      search("output-available", {
+        toolCallId,
+        input: { query },
+        output: { passages: [HENK] },
+      });
+
+    it("shows a line before each reply, which doesn't open", () => {
+      show([
+        question,
+        answer(thought(4_400), done("call-1", "pings"), thought(61_000), {
+          type: "text",
+          text: "Henk does.",
+        }),
+      ]);
+
+      const [, assistant] = within(
+        screen.getByRole("list", { name: "Conversation" }),
+      ).getAllByRole("listitem");
+      expect(assistant).toHaveTextContent(
+        /^Assistant\s*Thought 4s\s*Search “pings” · passages from Henk\s*Thought 1m 1s\s*Henk does\.$/,
+      );
+      expect(screen.queryByRole("button")).not.toBeInTheDocument();
+    });
+
+    it("shows none for an answer kept from before the times", () => {
+      show([question, answer(done("call-1", "pings"))]);
+
+      expect(screen.queryByText("Thought")).not.toBeInTheDocument();
+    });
+
+    it("folds the times around searches in a row with them, counting only the searches", () => {
+      show([
+        question,
+        answer(
+          thought(2_000),
+          done("call-1", "pings"),
+          thought(1_000),
+          done("call-2", "lists"),
+          thought(5_000),
+          { type: "text", text: "Henk does." },
+        ),
+      ]);
+
+      const line = screen.getByRole("button", { name: "Used 2 searches" });
+      const lines = document.getElementById(
+        line.getAttribute("aria-controls") ?? "",
+      );
+      expect(lines).toHaveTextContent(
+        /^Thought 2s\s*Search “pings” · passages from Henk\s*Thought 1s\s*Search “lists” · passages from Henk\s*Thought 5s$/,
+      );
+      expect(lines).not.toContainElement(screen.getByText("Henk does."));
+    });
+
+    it("keeps the time before a lone search or a save on a line of its own", () => {
+      show([
+        question,
+        answer(thought(2_000), done("call-1", "pings"), thought(3_000), {
+          type: "tool-saveSection",
+          toolCallId: "save-1",
+          state: "input-available",
+          input: { section: "Goals / Objectives", statements: [] },
+        } as SaveSectionPart),
+      ]);
+
+      expect(screen.queryByRole("button")).not.toBeInTheDocument();
+      expect(screen.getAllByText("Thought")).toHaveLength(2);
+    });
+  });
+
   it("marks an answer that broke off as unfinished", () => {
     show([question, answer({ type: "text", text: "Henk wants" })], "error");
 
diff --git a/tests/unit/kept-conversation.test.tsx b/tests/unit/kept-conversation.test.tsx
index 3e2e69c..2b5269e 100644
--- a/tests/unit/kept-conversation.test.tsx
+++ b/tests/unit/kept-conversation.test.tsx
@@ -230,6 +230,21 @@ describe("the kept conversation", () => {
         stopped: [],
       },
     ],
+    [
+      "a thinking time in another form",
+      {
+        format: STORED_FORMAT,
+        messages: [
+          DRAFTED[0],
+          {
+            ...DRAFTED[1],
+            parts: [{ type: "data-thought", data: { seconds: 3 } }],
+          },
+        ],
+        interrupted: false,
+        stopped: [],
+      },
+    ],
     [
       "a role the chat doesn't send",
       {
@@ -390,6 +405,41 @@ describe("the home page after a reload", () => {
     });
   });
 
+  it("keeps how long the model thought before each reply, and brings it back", async () => {
+    fetchMock.mockResolvedValueOnce(answer(text("reply-1", "Henk does.")));
+    const { unmount } = render(<Workspace />);
+    fireEvent.click(
+      screen.getByRole("button", { name: "Or ask your own question first" }),
+    );
+    fireEvent.change(screen.getByRole("textbox", { name: "Your message" }), {
+      target: { value: "Who wants pings?" },
+    });
+    fireEvent.click(screen.getByRole("button", { name: "Send" }));
+
+    expect(await screen.findByText("Henk does.")).toBeInTheDocument();
+    const shown = () =>
+      within(screen.getByRole("list", { name: "Conversation" }))
+        .getAllByRole("listitem")
+        .at(-1);
+    expect(shown()).toHaveTextContent(
+      /^Assistant\s*Thought \d+s\s*Henk does\.$/,
+    );
+    await waitFor(() => {
+      const value = kept() as { messages: ChatMessage[] } | null;
+      expect(value?.messages.at(-1)?.parts).toEqual([
+        { type: "data-thought", data: { ms: expect.any(Number) } },
+        expect.objectContaining({ type: "text", text: "Henk does." }),
+      ]);
+    });
+
+    unmount();
+    render(<Workspace />);
+
+    expect(shown()).toHaveTextContent(
+      /^Assistant\s*Thought \d+s\s*Henk does\.$/,
+    );
+  });
+
   it("still reads a stopped answer as stopped, with no Try again", () => {
     // The drafted answer, stopped while a second search ran.
     const messages = DRAFTED.map((message) =>
diff --git a/tests/unit/thoughts.test.ts b/tests/unit/thoughts.test.ts
new file mode 100644
index 0000000..36ff623
--- /dev/null
+++ b/tests/unit/thoughts.test.ts
@@ -0,0 +1,144 @@
+import type { UIMessageChunk } from "ai";
+import { describe, expect, it } from "vitest";
+import { thoughtTime, timeThoughts } from "@/features/chat/thoughts";
+
+// How long the model thought before each reply, timed in the browser on the
+// answer's stream (`src/features/chat/thoughts.ts`).
+
+/** Runs the chunks through the timer, each arriving at its time in ms. */
+async function timed(
+  requested: number,
+  arrivals: Array<[number, UIMessageChunk]>,
+): Promise<UIMessageChunk[]> {
+  let clock = requested;
+  const timer = timeThoughts(requested, () => clock);
+  const out: UIMessageChunk[] = [];
+  const reading = (async () => {
+    for await (const chunk of timer.readable) out.push(chunk);
+  })();
+  const writer = timer.writable.getWriter();
+  // Each write settles once the timer has passed its chunk on, so the clock
+  // reads that chunk's arrival.
+  for (const [at, chunk] of arrivals) {
+    clock = at;
+    await writer.write(chunk);
+  }
+  await writer.close();
+  await reading;
+  return out;
+}
+
+const search = (id: string, toolName = "searchNotes"): UIMessageChunk => ({
+  type: "tool-input-available",
+  toolCallId: id,
+  toolName,
+  input: { query: "pings" },
+});
+
+const found = (id: string): UIMessageChunk => ({
+  type: "tool-output-available",
+  toolCallId: id,
+  output: { passages: [] },
+});
+
+const thought = (ms: number): UIMessageChunk => ({
+  type: "data-thought",
+  data: { ms },
+});
+
+describe("timing the model's thinking", () => {
+  it("times the first wait from the request to the reply's first text", async () => {
+    const chunks = await timed(1_000, [
+      [1_010, { type: "start" }],
+      [1_020, { type: "start-step" }],
+      [8_400, { type: "text-start", id: "t" }],
+      [8_410, { type: "text-delta", id: "t", delta: "Henk does." }],
+      [8_420, { type: "text-end", id: "t" }],
+      [8_430, { type: "finish-step" }],
+      [8_440, { type: "finish" }],
+    ]);
+
+    expect(chunks.map((chunk) => chunk.type)).toEqual([
+      "start",
+      "start-step",
+      "data-thought",
+      "text-start",
+      "text-delta",
+      "text-end",
+      "finish-step",
+      "finish",
+    ]);
+    expect(chunks[2]).toEqual(thought(7_400));
+  });
+
+  it("times each later wait from the moment the last step running finished", async () => {
+    const chunks = await timed(0, [
+      [3_000, search("a")],
+      [3_000, search("b")],
+      [3_200, found("a")],
+      [3_500, found("b")],
+      [3_600, { type: "finish-step" }],
+      [3_600, { type: "start-step" }],
+      [5_500, { type: "text-start", id: "t" }],
+    ]);
+
+    expect(chunks.filter((chunk) => chunk.type === "data-thought")).toEqual([
+      thought(3_000),
+      thought(2_000),
+    ]);
+    expect(chunks.map((chunk) => chunk.type)).toEqual([
+      "data-thought",
+      "tool-input-available",
+      "tool-input-available",
+      "tool-output-available",
+      "tool-output-available",
+      "finish-step",
+      "start-step",
+      "data-thought",
+      "text-start",
+    ]);
+  });
+
+  it("times nothing between a reply's text and its steps, nor while a step runs", async () => {
+    const chunks = await timed(0, [
+      [2_000, { type: "text-start", id: "t" }],
+      [2_000, { type: "text-end", id: "t" }],
+      [
+        2_000,
+        { type: "tool-input-start", toolCallId: "a", toolName: "saveSection" },
+      ],
+      [2_000, search("a", "saveSection")],
+      [2_000, { type: "finish" }],
+    ]);
+
+    expect(chunks.filter((chunk) => chunk.type === "data-thought")).toEqual([
+      thought(2_000),
+    ]);
+  });
+
+  it("times no wait that the answer ends in", async () => {
+    const chunks = await timed(0, [
+      [1_000, search("a")],
+      [1_500, found("a")],
+      [9_000, { type: "error", errorText: "Broke off." }],
+    ]);
+
+    expect(chunks.filter((chunk) => chunk.type === "data-thought")).toEqual([
+      thought(1_000),
+    ]);
+  });
+});
+
+describe("the time after Thought", () => {
+  it.each([
+    [0, "0s"],
+    [499, "0s"],
+    [7_400, "7s"],
+    [59_499, "59s"],
+    [59_500, "1m 0s"],
+    [65_000, "1m 5s"],
+    [3_725_000, "62m 5s"],
+  ])("writes %i ms as %s, as opencode does", (ms, written) => {
+    expect(thoughtTime(ms)).toBe(written);
+  });
+});
diff --git a/tests/unit/workspace.test.tsx b/tests/unit/workspace.test.tsx
index afbfe42..8e539e2 100644
--- a/tests/unit/workspace.test.tsx
+++ b/tests/unit/workspace.test.tsx
@@ -621,7 +621,12 @@ describe("the Stop button", () => {
             ? part.text
             : `${part.type} ${"state" in part ? part.state : ""}`,
         ),
-    ).toEqual(["tool-saveSection output-available", "I saved Introduction"]);
+    ).toEqual([
+      "data-thought ",
+      "tool-saveSection output-available",
+      "data-thought ",
+      "I saved Introduction",
+    ]);
     // The stopped answer still reads as stopped.
     expect(screen.getByText("You stopped this answer.")).toBeInTheDocument();
   });
@@ -654,6 +659,45 @@ describe("the Stop button", () => {
     ]);
   });
 
+  it("drops an answer stopped during its first search, though it timed the thinking before it", async () => {
+    fetchMock.mockImplementationOnce(async (_, init) =>
+      answerOnItsWay(
+        [
+          {
+            type: "tool-input-available",
+            toolCallId: "call-1",
+            toolName: "searchNotes",
+            input: { query: "pings" },
+          },
+        ],
+        init?.signal,
+      ),
+    );
+    render(<Workspace />);
+    fireEvent.click(
+      screen.getByRole("button", { name: "Or ask your own question first" }),
+    );
+    fireEvent.change(messageBox(), { target: { value: "Who wants pings?" } });
+    fireEvent.click(screen.getByRole("button", { name: "Send" }));
+    await screen.findByText(stepText("Search “pings”…"));
+    expect(screen.getByText("Thought")).toBeInTheDocument();
+    fireEvent.click(screen.getByRole("button", { name: "Stop" }));
+    await screen.findByText("You stopped this answer.");
+    fetchMock.mockResolvedValueOnce(answer(text("reply-2", "Henk does.")));
+
+    fireEvent.change(messageBox(), { target: { value: "And Daan?" } });
+    fireEvent.click(screen.getByRole("button", { name: "Send" }));
+
+    expect(await screen.findByText("Henk does.")).toBeInTheDocument();
+    const body = JSON.parse(String(fetchMock.mock.lastCall?.[1]?.body)) as {
+      messages: ChatMessage[];
+    };
+    expect(body.messages.map((message) => message.role)).toEqual([
+      "user",
+      "user",
+    ]);
+  });
+
   it("isn't needed by Start over, which still stops and clears without marking anything stopped", async () => {
     await askAndWait();