diff --git a/AGENTS.md b/AGENTS.md
index 7cd25bcb..9a545ce0 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -60,6 +60,7 @@ Performance invariants — all deliberate, keep them:
 
 - The full index is never shipped to or rendered by the UI. Always paginate.
 - Meta parsing reads at most 256KB per file. Parsers are failure-tolerant: session log formats are provider-internal and drift between releases, so skip anything unreadable rather than fail the scan.
+- What a tool call hands the person — a plan, a to-do list, an edit — rides its transcript row as `SessionMessage.artifact`, read off the call's own input in main by `src/main/parsers/artifacts.ts` (shared by the three parsers and the stream parsers in `chat.ts` and `acp-core.ts`) and bounded there (files per call, lines per file, line width), because it crosses IPC on every transcript read. A call that failed is marked on its own row (`failed`), matched to its result by id where the log has one. The renderer only folds these for the Work panel (`work.ts`); it never parses tool JSON.
 - A parser reports only what its log states (`SessionMeta.logBranch`), never what the disk says. Anything derived from the checkout — `repo`, `isWorktree`, `gitBranch` — is the indexer's `annotate()`, is recomputed on every scan, and is stripped before the stat-cache is written so a renamed remote or a moved worktree can't freeze into it. Branches are the live example: Copilot stopped writing `context.branch` after CLI 1.0.80 and most Codex rollouts carry no `git` block, so for those the checkout's HEAD is the only source.
 - A session can span several files: Codex paginates a long thread into a new rollout whose `session_meta.history_base` names where the previous one's history ends. The parser reports that (`SessionMeta.historyBase`), `foldThread` in the indexer folds every file carrying one id into a session on the newest file with the earlier ones as `segments`, and anything that reads or removes a session's log — transcript, search, profile, cleanup — reads every file (`sessionLogFiles`; an earlier page only up to its `endByte` where the thread's history is what counts), never `sourcePath` alone. Only liveness reads just the newest file, the one being written.
 - The stat-cache (mtime+size, persisted to userData) means restarts only re-parse changed files; scans yield to the event loop so IPC never blocks.
diff --git a/design-system/cockpit/MASTER.md b/design-system/cockpit/MASTER.md
index c300e705..cb0aedcc 100644
--- a/design-system/cockpit/MASTER.md
+++ b/design-system/cockpit/MASTER.md
@@ -127,7 +127,8 @@ Reuse these; don't invent parallel variants:
 - **`.rail-resizer`** (`RailResizer.tsx`) — the sash on the rail's right edge: the sidebar's width is the person's, dragged between 200px and what the deck can spare (`rail.ts`, remembered per machine in localStorage, never in config), invisible at rest and an accent hairline on hover, focus and while dragging. A `role=separator` whose value is the rail's *measured* width; ← → move it 16px (64 with ⇧), Home/End reach the bounds, double-click resets. Because the rail is dragged, anything that sheds *inside* it asks the rail (`@container rail`), never the window. See `pages/sidebar.md`.
 - **Cards:** `.ns-card` — ONE width (`min(760px, 94%)`) shared by every card view (Settings, Agents, Profile, Cleanup, New session); navigating between them must never make the dialog jump sizes. `.composer-card` for the home prompt, in home's own `--home-col`.
 - **Card tabs** (`TabList` + `TabPanel`, `Tabs.tsx`) — the one way a card view pages its content: a `.pnl-tabs.ns-tabs` row of `.pnl-pill` tabs (hairline under it) over **one** mounted panel. Settings, Agents, Profile and Cleanup all use it. **A tab replaces the panel; nothing in a card scrolls to a heading further down** — a jump row that scrolled took the title, the row and Close off screen with it, and a card of stacked sections read as one long page. Switching mounts the panel fresh (two panels built alike must never share internal state) and puts the card's scroller back at `scrollTop 0`. The row is one tab stop (roving `tabIndex`; ←/→ wrap, Home/End), only the selected tab carries `aria-controls`, and the panel is named by its tab — so a panel holding one group carries no heading that repeats the pill, and a panel holding several names each group with an `h3` that doesn't either. A tab may carry its count (`.pnl-pill-n`, left off at zero), a warn tone or an amber dot. Controls that govern every tab (Cleanup's threshold, Agents' scope, Profile's headline numbers) sit above the row; the pill row must hold in two rows at the 560px floor. A new card view that grows past a screen gets tabs, not a jump row.
-- **Chat:** user bubbles right (accent tint), assistant left with avatar; `.tool-row` = collapsed `<details>` one-liners; `.sys-row` = dotted-left-border annotations; streaming = accent left border.
+- **Chat:** user bubbles right (accent tint), assistant left with avatar; `.tool-row` = collapsed `<details>` one-liners, or a `.tool-open` button when the call carries a plan, to-dos or an edit; `.sys-row` = dotted-left-border annotations; streaming = accent left border.
+- **`.work-panel`** (`WorkPanel.tsx`) — the agent's plan, to-dos and edits beside the transcript (chat only, `.btn-work` / ⌘J, or one click on a `.tool-row.tool-open` row): card tabs over one scroller, the review's file blocks for edits, and under 720px of `@container chat-deck` it covers the conversation instead. See `pages/chat.md`.
 - **`.review`** — the worktree's changes in the transcript's place (chat only, `.btn-review` / ⌘D): the instructions review's `.idiff-*` line grammar with line numbers, a scope switch, and line notes that go back to the agent through the composer. With an open PR it leads with `.review-pr` (what the PR waits on + "Fix with <Agent>") and shows reviewers' unresolved threads (`.review-thread`) under their lines. See `pages/chat.md`.
 - **Semantic count pills:** bordered pill = "session count on a repo"; org counts are plain text.
 - **`Select`** — the one dropdown (see Native Controls); never a raw `<select>`.
diff --git a/design-system/cockpit/pages/chat.md b/design-system/cockpit/pages/chat.md
index 10ff5018..15cf62bb 100644
--- a/design-system/cockpit/pages/chat.md
+++ b/design-system/cockpit/pages/chat.md
@@ -16,15 +16,17 @@ gives way like the branch chip) for a session another session started — then b
 cwd that copies its full path — displayed via `cwdLabel`: a worktree as `worktree · <slug>`, or bare
 `worktree` when the slug is the branch chip's own name (its location is only where a tool keeps
 worktrees), anything else `~`-abbreviated; the full path is always in the tooltip — and "· not started" when no native session yet) · PR affordance · `Changes` ·
-`Continue in…`.
+`Work` (only once the transcript carries a plan, to-dos or an edit) · `Continue in…`.
 Header min-height is 52px — it's the drag region, keep it a real grab target.
 
 - **The header is identity, never settings.** The permission mode lives in the composer
   (see below); a header that also carried it lost the session title entirely at the
   560px floor.
-- **Labels shed to their marks before the title truncates** — ≤780px the `Changes` and
-  `Continue in…` keys fold to 28px squares (`.lbl` hidden; `DiffIcon`/`HandoffIcon`
-  stay, each with an `aria-label`), and an open PR's badge drops its state word
+- **Labels shed to their marks before the title truncates** — ≤780px the `Changes`
+  and `Continue in…` keys fold to 28px squares (`.lbl` hidden; `DiffIcon`/`HandoffIcon`
+  stay, each with an `aria-label`). The `Work` key (`.btn-review.btn-work`) is that
+  square at every width — `WorkIcon`, named by its `aria-label` and tooltip: a fourth
+  label cost the title ~70px at 900px, and the rows are the way in. An open PR's badge drops its state word
   (`.pr-word`) to keep the number beside its checks glyph, unresolved-thread count
   (`.pr-threads`) and review mark — the state stays in the badge's `aria-label` and
   tooltip; ≤700px the agent badge drops
@@ -80,6 +82,14 @@ Header min-height is 52px — it's the drag region, keep it a real grab target.
     wide) a peek longer than twelve characters collapses to zero width while a short
     one (`.tool-peek-short` — `ok`, `20 passed`) keeps its place; at 40% each, the
     command and the verdict were both twelve characters and neither could be read.
+  - **a tool call that carries work → `.tool-row.tool-open`**, the same one-line
+    grammar as one `<button>` instead of a `<details>`: chip · headline · `DiffStat` for
+    an edit · `didn't apply` (warn, the word itself) for a failed call · the `WorkIcon`
+    at the right edge, accent on hover. The headline is the artifact's own: a plan's
+    title, `3 of 7 done`, the task it adds, the files an edit touched. A click opens the
+    Work panel at that row (below); there is no raw JSON to expand — the panel is the
+    detail. A blank 10px lead keeps its chip in line with the ▸ of the rows around it.
+    Roundtables pass no `onOpenWork`, so their rows stay ordinary `.tool-row`s.
   - paths under the session's cwd render relative to it (`Message`'s `cwd` prop) — the
     header already names the directory
   - **four or more tool rows in a row fold into one `.tool-run`** — `⚙︎ work · 5 steps ·
@@ -87,7 +97,8 @@ Header min-height is 52px — it's the drag region, keep it a real grab target.
     `runSummary`). A twelve-step run between two paragraphs buried the paragraphs. The
     fold breaks wherever the agent speaks, so prose is never swallowed, and the **tail
     run of a live turn never folds** — watching the steps arrive is the point while a
-    turn runs. Earlier runs in that same turn still fold.
+    turn runs. Earlier runs in that same turn still fold. A plan row never folds either:
+    a plan is a message of its own, like the agent's prose.
   - system → `.sys-row` dotted-left-border annotation, aligned with the assistant column
   - **a question waiting on you → `.ask-card`** (`AskPicker.tsx`), the one tool call that
     never collapses: the agent's own options are the message, so a `⚙︎` one-liner would
@@ -104,7 +115,11 @@ Header min-height is 52px — it's the drag region, keep it a real grab target.
     question is history and renders as the ordinary tool row. A read-only seat session
     gets none: the table owns that conversation. Parsed in main
     (`src/shared/asks.ts` — Claude's `AskUserQuestion`/`ExitPlanMode`, Codex's
-    `request_user_input`), never from the raw JSON in the renderer.
+    `request_user_input`), never from the raw JSON in the renderer. **A plan gate shows
+    the plan** above its two answers (`.ask-plan-body`: the plan's markdown on
+    `--bg-deep`, 320px max, a named, focusable `role=region` so the keyboard can scroll
+    it), with `Open in the Work panel` (`.btn-ghost.small`) under it — approving a title
+    was approving something unread.
 - Tool/system glyphs are text-presentation unicode (`⚙︎` with U+FE0E, `↳`) — if these
   ever grow, switch to SVGs from `logos.tsx`; never bare emoji-presentation glyphs.
 - **DOM bound, with a way up:** only the last `RENDER_LAST` (400) messages render, and
@@ -158,6 +173,51 @@ Header min-height is 52px — it's the drag region, keep it a real grab target.
 - Code blocks get a hover/focus Copy button; highlight.js tokens map to app palette
   variables — no imported highlight theme.
 
+## Work panel (`WorkPanel.tsx`, `.work-panel`)
+
+What the agent handed the person to look at — a plan, a to-do list, edits — beside the
+conversation. Everything in it comes from the agents' own tool calls, parsed in main
+(`src/main/parsers/artifacts.ts` → `SessionMessage.artifact`, bounded there) and folded
+in the renderer (`work.ts`), never from raw JSON in the renderer.
+
+- **Beside, not instead of.** Under the header the chat is a row, `.chat-deck`: the
+  conversation (`.chat-main` — transcript or review, the permission card, the composer)
+  and the panel (`clamp(300px, 38%, 460px)`, hairline left border, `--pane`). The deck is
+  a `container: chat-deck`, and under 720px of it (the panel's 300px floor beside ~420px
+  of conversation) the panel covers `.chat-main` instead, on solid `--bg` — the way
+  Changes takes the transcript's place. Asked of the deck, never the window: the rail is
+  dragged. Changes (header, ⌘D, or the Edits tab's link) closes a panel that covers the
+  conversation first — it would otherwise open unseen behind it; beside the
+  conversation the panel stays, so what the agent said and what is on disk read side
+  by side.
+- Opened by the header's **Work** key (`.btn-review.btn-work`, `aria-pressed`, ⌘J —
+  offered only once the transcript carries something for it) on the tab that matters
+  now (`defaultTab`: a plan waiting for approval, else a list still under way, else the
+  edits), or by a `.tool-open` row at that row. Opening moves focus to the selected tab;
+  Escape (or the ×, `XIcon`) closes it and hands focus back to what opened it. It closes
+  when the session's directory changes, like review.
+- **Tabs** are the card tabs (`TabList`, `.pnl-pill`) without the card's rule under
+  them: **Plan** (amber dot while a plan waits for approval), **To-dos** (count = steps
+  not done), **Edits** (count = files). The body (`.work-body`) is the panel's one
+  scroller, `tabIndex=0` so a keyboard reaches it, and goes back to the top on a tab
+  switch. Each tab leads with a `.work-meta` readout in the mono voice; an empty tab
+  says, in one sentence, what would appear there (`.work-empty`).
+- **Plan**: the plan's markdown at `--fs-prose`. Earlier versions are one step away
+  (`Earlier` / `version 2 of 3` / `Later`, `.btn-ghost.small`); a row opens its own
+  version. `waiting for your approval` (`.work-flag`, warn) while it is the pending ask.
+- **To-dos**: an `<ol>` of `.work-todo` rows, the state as a shape (`TodoMark`: ring,
+  ring with a dot, ring with a check) *and* an `sr-only` word; the step under way wears
+  an accent tint, done steps dim their text. `todos` artifacts replace the list; Claude's
+  `TaskCreate`/`TaskUpdate` fold into it by task number.
+- **Edits**: `N edits · M files` + `DiffStat`, then a `.work-note` that the edits are as
+  the calls described them — with a `Changes` link to the worktree's real diff where
+  there is one. Files are review file blocks (`.idiff.review-file.work-file` in an
+  `.idiff-list`), open by default while there are three or fewer (files that arrive
+  mid-turn follow the same default; only what the person toggled is remembered); each edit under an
+  `.idiff-rail` (time · tool, `didn't apply` in warn when the call failed), its hunks in
+  the shared `DiffLines` grammar, unified only. A row that opened the panel opens its
+  file and rings its edit (`.work-edit.ringed`, an accent inset) for two seconds.
+
 ## Permission prompt (`PermissionAsk`, `.perm-card`)
 
 A turn Cockpit drives over ACP can stop mid-turn and ask (`session/request_permission`).
diff --git a/docs/guide/chat.md b/docs/guide/chat.md
index 8aca1726..b560b16b 100644
--- a/docs/guide/chat.md
+++ b/docs/guide/chat.md
@@ -73,6 +73,11 @@ question, its options with the agent's own one-line descriptions, and **Send ans
 Multi-select questions take several picks; a question the conversation has moved past
 stays a plain tool row.
 
+When the question is Claude's plan gate, the card shows the plan itself above
+**Approve the plan** and **Keep planning**, so you approve what you have read, not a
+title. A long plan scrolls inside the card, or **Open in the Work panel** gives it the
+whole side of the window.
+
 The pick is sent as your next message, worded from the question (`Answering your
 question: - Which layout…? → packages/<runtime>`), so it stands on its own in the
 transcript the agent resumes from — and you can always ignore the card and type your
@@ -84,6 +89,44 @@ and in the Dock badge, whether the session runs in Cockpit or in a terminal; see
 [Notifications](/guide/notifications).
 :::
 
+## Plans, to-dos and edits: the Work panel
+
+Agents hand you things to look at while they work: a plan to approve, a to-do list they
+tick off, and edits to your files. Cockpit reads each of them from the agent's own tool
+calls and opens them in the **Work** panel beside the conversation. The panel has three
+tabs:
+
+- **Plan**: the plan the agent proposed (Claude Code's plan mode, Copilot CLI's
+  `exit_plan_mode`), rendered as a document. If the agent revised it, **Earlier** and
+  **Later** step through each version. While the plan is waiting for your approval, the
+  tab says so.
+- **To-dos**: the agent's list as it stands now: Claude Code's tasks (or its older
+  `TodoWrite` list), Codex's plan, or an ACP agent's plan. Each step shows as not
+  started, in progress or done.
+- **Edits**: every file the agent changed, in the order it first touched them. Each change
+  appears the way the call described it: a Claude `Edit` or `Write`, a Codex or Copilot
+  patch, a Copilot `edit` or `create`. An edit whose call failed is still listed, marked
+  **didn't apply**.
+
+A tool row that carries one of these is a single click: the row names the plan, the list's
+progress or the files and their `+`/`−` counts, and clicking it opens the panel at that
+item. The header's **Work** key (⌘J) appears once the conversation holds any of them. It
+opens the panel on whatever matters now: a plan waiting for you, else a list still in
+progress, else the edits. Escape closes the panel and returns you to where you were.
+
+When the window is too narrow to hold the conversation and the panel side by side, the
+panel covers the conversation until you close it, the same way **Changes** does.
+
+::: tip What the agent said, and what is on disk
+The Edits tab shows what each call *said* it changed. [**Changes**](/guide/worktrees-and-prs)
+(⌘D) is the worktree's own diff, which is the record of what is actually on disk. A Codex
+turn that Cockpit is streaming reports which files it changed but not the lines; reopen
+the session once the turn ends to read the lines from its log.
+:::
+
+Copilot CLI keeps its to-dos in a database of its own rather than in its log, so a
+Copilot session's To-dos tab stays empty. Its plans and edits are shown.
+
 ## Provider quirks
 
 Cockpit smooths over the differences it can, and is honest about the ones it can't:
diff --git a/scripts/ui-tour/tour.mts b/scripts/ui-tour/tour.mts
index b470fb24..4f4d2f54 100644
--- a/scripts/ui-tour/tour.mts
+++ b/scripts/ui-tour/tour.mts
@@ -355,6 +355,39 @@ const STATIC: readonly Shot[] = [
   { view: 'chat', name: 'chat-worktree', go: (w) => open(w, /Add pagination to the sessions list/) },
   // the agent stopped to ask: its options, answerable in place
   { view: 'chat', name: 'chat-asks', go: (w) => open(w, /Split the SDK into a monorepo/) },
+  // the agent's work beside the conversation: a row opens the panel at its own edit
+  {
+    view: 'chat',
+    name: 'chat-work-edits',
+    go: async (w) => {
+      await open(w, /Fix the login flake/)
+      await w.locator('.messages').evaluate((el) => el.scrollTo({ top: 0 }))
+      await w.locator('.tool-run summary').first().click()
+      await w.locator('.tool-open', { hasText: 'src/auth/login.ts' }).first().click()
+      await pause(w, 500)
+    }
+  },
+  // ⌘J opens on what matters now — here the task list still under way
+  {
+    view: 'chat',
+    name: 'chat-work-todos',
+    go: async (w) => {
+      await open(w, /Fix the login flake/)
+      await w.keyboard.press('ControlOrMeta+j')
+      await pause(w, 400)
+    }
+  },
+  // a plan waiting for approval is read in its card, and opens in the panel
+  { view: 'chat', name: 'chat-plan', go: (w) => open(w, /Plan rate limiting for the public API/) },
+  {
+    view: 'chat',
+    name: 'chat-work-plan',
+    go: async (w) => {
+      await open(w, /Plan rate limiting for the public API/)
+      await w.getByRole('button', { name: 'Open in the Work panel' }).click()
+      await pause(w, 500)
+    }
+  },
   { view: 'chat', name: 'chat-codex', go: (w) => open(w, /Add a fallback when the billing API/) },
   { view: 'chat', name: 'chat-copilot', go: (w) => open(w, /Tidy the usage panel spacing/) },
   {
@@ -374,7 +407,7 @@ const STATIC: readonly Shot[] = [
  * serves every narrow pass, so there is no second hand-curated set to drift out of
  * step with this one.
  */
-const AT_FLOOR = new Set(['home', 'sidebar-update', 'palette-empty', 'palette-transcripts', 'settings', 'agents', 'profile', 'cleanup', 'new-session', 'chat-claude', 'chat-asks', 'new-roundtable-seats', 'new-roundtable-signed-out', 'roundtable-consensus'])
+const AT_FLOOR = new Set(['home', 'sidebar-update', 'palette-empty', 'palette-transcripts', 'settings', 'agents', 'profile', 'cleanup', 'new-session', 'chat-claude', 'chat-asks', 'chat-work-edits', 'chat-plan', 'new-roundtable-seats', 'new-roundtable-signed-out', 'roundtable-consensus'])
 
 const LIVE: readonly Shot[] = [
   // a table mid-round: each seat still at it with its time and skip, and a follow-up
diff --git a/scripts/ui-tour/world.mts b/scripts/ui-tour/world.mts
index 70cdfc1f..bc740b4f 100644
--- a/scripts/ui-tour/world.mts
+++ b/scripts/ui-tour/world.mts
@@ -174,11 +174,29 @@ function populate(world: World): void {
       {
         say: 'Let me reproduce it first.',
         tools: [
+          // Claude's task tools: the Work panel's to-do list, numbered by their results
+          ...['Reproduce the flake', 'Fix the login timeout', 'Add a regression test', 'Open the pull request'].map((subject, i) => ({
+            name: 'TaskCreate',
+            input: { subject, description: subject, activeForm: subject },
+            result: `Task #${i + 1} created successfully: ${subject}`
+          })),
+          { name: 'TaskUpdate', input: { taskId: '1', status: 'in_progress' }, result: 'Updated task #1 status' },
           { name: 'Bash', input: { command: 'npm run test:e2e -- --grep login --repeat-each 20' }, result: '14 passed, 6 failed\n  ✘ login › retries on transient failure (TimeoutError: 800ms exceeded)' },
+          { name: 'TaskUpdate', input: { taskId: '1', status: 'completed' }, result: 'Updated task #1 status' },
+          { name: 'TaskUpdate', input: { taskId: '2', status: 'in_progress' }, result: 'Updated task #2 status' },
           { name: 'Read', input: { file_path: `${flake}/src/auth/login.ts` }, result: 'export async function login(creds) {\n  return client.post("/session", creds, { timeout: 800 })\n}' },
           { name: 'Grep', input: { pattern: 'timeout', path: 'src/auth' }, result: 'src/auth/login.ts:2' },
-          { name: 'Edit', input: { file_path: `${flake}/src/auth/login.ts`, old_string: 'timeout: 800', new_string: 'timeout: TIMEOUT' } },
-          { name: 'Bash', input: { command: 'npm run test:e2e -- --grep login --repeat-each 20' }, result: '20 passed' }
+          {
+            name: 'Edit',
+            input: {
+              file_path: `${flake}/src/auth/login.ts`,
+              old_string: 'export async function login(creds) {\n  return client.post("/session", creds, { timeout: 800 })\n}',
+              new_string:
+                'const TIMEOUT = 5_000\n\nexport async function login(creds) {\n  return withRetry(() => client.post("/session", creds, { timeout: TIMEOUT }), { attempts: 3 })\n}'
+            }
+          },
+          { name: 'Bash', input: { command: 'npm run test:e2e -- --grep login --repeat-each 20' }, result: '20 passed' },
+          { name: 'TaskUpdate', input: { taskId: '2', status: 'completed' }, result: 'Updated task #2 status' }
         ]
       },
       { say: RICH_REPLY },
@@ -186,9 +204,17 @@ function populate(world: World): void {
       {
         say: 'Adding a test that stubs a slow DNS resolver.',
         tools: [
-          { name: 'Write', input: { file_path: `${flake}/tests/login-slow-dns.test.ts`, content: 'test("survives a slow first lookup", async () => {})\n' } },
+          { name: 'TaskUpdate', input: { taskId: '3', status: 'in_progress' }, result: 'Updated task #3 status' },
+          {
+            name: 'Write',
+            input: {
+              file_path: `${flake}/tests/login-slow-dns.test.ts`,
+              content: 'import { login } from "../src/auth/login"\n\ntest("survives a slow first lookup", async () => {\n  stubDns({ firstLookupMs: 1_200 })\n  await expect(login(creds)).resolves.toBeDefined()\n})\n'
+            }
+          },
           { name: 'Bash', input: { command: 'npx vitest run tests/login-slow-dns.test.ts' }, result: '✓ survives a slow first lookup (1.3s)' },
-          { name: 'Bash', input: { command: 'git commit -am "fix(auth): retry transient login failures"' }, result: '[cockpit/login-retry-flake 4e1a2c9] fix(auth): retry transient login failures' }
+          { name: 'Bash', input: { command: 'git commit -am "fix(auth): retry transient login failures"' }, result: '[cockpit/login-retry-flake 4e1a2c9] fix(auth): retry transient login failures' },
+          { name: 'TaskUpdate', input: { taskId: '3', status: 'completed' }, result: 'Updated task #3 status' }
         ]
       },
       { say: 'Committed as `4e1a2c9`. The branch is ready for a PR.' }
@@ -216,6 +242,46 @@ function populate(world: World): void {
       }
     ]
   })
+  // a plan waiting for approval, read in its card — old enough that nothing is live
+  claude({
+    cwd: code('atlas'),
+    branch: 'main',
+    title: 'Plan rate limiting for the public API',
+    hoursAgo: 2,
+    turns: [
+      { user: 'Plan how we add rate limiting to the public API. Plan only — no code yet.' },
+      {
+        say: 'I read the gateway and its middleware chain. Here is the plan.',
+        tools: [
+          { name: 'Read', input: { file_path: `${code('atlas')}/src/gateway/middleware.ts` }, result: 'export const chain = [auth, cors, route]' },
+          {
+            name: 'ExitPlanMode',
+            input: {
+              plan: [
+                '# Rate limiting for the public API',
+                '',
+                'A token bucket per API key, enforced in the gateway before routing.',
+                '',
+                '## Steps',
+                '',
+                '1. **Bucket store** — a Redis-backed bucket keyed by `key:route-group`, 100 requests a minute, burst of 20.',
+                '2. **Middleware** — `rateLimit()` between `auth` and `route` in `src/gateway/middleware.ts`; answers `429` with `Retry-After`.',
+                '3. **Headers** — `RateLimit-Limit`, `RateLimit-Remaining` and `RateLimit-Reset` on every response.',
+                '4. **Tests** — a burst test and a refill test against a fake clock.',
+                '',
+                '## Out of scope',
+                '',
+                '- Per-user limits inside an organization',
+                '- A dashboard for usage'
+              ].join('\n'),
+              planFilePath: join(world.home, '.claude', 'plans', 'rate-limiting.md')
+            },
+            pending: true
+          }
+        ]
+      }
+    ]
+  })
   claude({ cwd: wt('rocket', 'dark-mode-tokens'), branch: 'cockpit/dark-mode-tokens', title: 'Extract dark-mode color tokens into a single :root block', hoursAgo: 5, turns: [{ user: 'Pull every hard-coded color into custom properties.' }, { say: 'Found 143 literals across 22 files.' }] })
   claude({ cwd: code('rocket'), branch: 'main', title: 'Why is the bundle 2MB? Audit the imports', hoursAgo: 26, turns: [{ user: 'Why is the production bundle 2MB?' }, { say: 'Moment.js with all locales is 600KB of it.' }] })
   claude({ cwd: wt('atlas', 'billing-webhook-retries'), branch: 'cockpit/billing-webhook-retries', title: 'Retry failed billing webhooks with idempotency keys', hoursAgo: 1.4, turns: [{ user: 'Retry webhooks with idempotency keys.' }, { say: 'Implemented a retry queue keyed by event id.' }] })
diff --git a/src/main/acp-core.ts b/src/main/acp-core.ts
index 39f82510..f6a94dc3 100644
--- a/src/main/acp-core.ts
+++ b/src/main/acp-core.ts
@@ -1,6 +1,7 @@
 import type { AcpPermissionOption, ChatEvent, PermissionMode } from '../shared/types'
 import { ACP_PROTOCOL_VERSION } from '../shared/acp'
 import { shellPreview, truncate } from './parsers/util'
+import { acpDiffArtifact, acpPlanArtifact } from './parsers/artifacts'
 
 /**
  * The IO-free half of the ACP client: everything that turns protocol JSON into Cockpit's
@@ -75,8 +76,13 @@ function blockText(content: unknown): string {
  * an agent introduce a call with either `tool_call` or a first `tool_call_update`, so
  * the id is what decides whether a line is new, not the update kind.
  *
+ * `plan` is the agent's whole to-do list each time, so it becomes a row carrying the
+ * list for the Work panel; a call announced with `diff` content carries the edit the
+ * same way. A diff that only arrives in a later update for a call already on screen
+ * is not carried yet (the row has nowhere to put it) — the session's log still has it.
+ *
  * Deliberately unmapped, because each would need a renderer concept Cockpit does not
- * have yet: `agent_thought_chunk` and `plan` (the Codex parser drops reasoning too),
+ * have yet: `agent_thought_chunk` (the Codex parser drops reasoning too),
  * `usage_update` (a live context-window meter — the one worth building next),
  * `available_commands_update`, `config_option_update`, `current_mode_update`.
  */
@@ -93,6 +99,24 @@ export function acpUpdateToEvents(
     return text ? [{ turnId, type: 'text', text }] : []
   }
 
+  if (kind === 'plan') {
+    const artifact = acpPlanArtifact(u.entries)
+    // an empty plan is the agent's opening state more often than a cleared list — a
+    // "0 steps" row would only be noise
+    if (!artifact || artifact.kind !== 'todos' || artifact.items.length === 0) return []
+    const n = artifact.items.length
+    return [
+      {
+        turnId,
+        type: 'tool',
+        toolName: 'plan',
+        detail: truncate(JSON.stringify(u.entries ?? []), 200),
+        preview: `${n} ${n === 1 ? 'step' : 'steps'}`,
+        artifact
+      }
+    ]
+  }
+
   if (kind === 'tool_call' || kind === 'tool_call_update') {
     const id = typeof u.toolCallId === 'string' ? u.toolCallId : ''
     // an update for a call already on screen carries only its output and status, and
@@ -103,13 +127,15 @@ export function acpUpdateToEvents(
     if (kind === 'tool_call_update' && typeof u.title !== 'string') return []
     seenToolCalls.add(id)
     const preview = previewFor(u.kind, u.title, u.rawInput)
+    const artifact = acpDiffArtifact(u.content)
     return [
       {
         turnId,
         type: 'tool',
         toolName: toolNameFor(u.kind),
         detail: truncate(JSON.stringify(u.rawInput ?? u.title ?? {}), 200),
-        ...(preview ? { preview: truncate(preview, 200) } : {})
+        ...(preview ? { preview: truncate(preview, 200) } : {}),
+        ...(artifact ? { artifact } : {})
       }
     ]
   }
diff --git a/src/main/chat.ts b/src/main/chat.ts
index e6ce1070..02b44cf2 100644
--- a/src/main/chat.ts
+++ b/src/main/chat.ts
@@ -18,6 +18,7 @@ import {
 } from '../shared/endpoints'
 import { parseAsks } from '../shared/asks'
 import { contentToText, shellPreview, toolPreview, truncate } from './parsers/util'
+import { fileChangeArtifact, todoListArtifact, toolArtifact } from './parsers/artifacts'
 import { cliEnv } from './env'
 
 type Emit = (ev: ChatEvent) => void
@@ -152,13 +153,15 @@ export function parseClaudeStreamLine(turnId: string, line: any): ChatEvent[] {
           // a question the CLI can't answer itself rides along with its options, so
           // the chat can offer them as picks rather than a JSON blob
           const asks = parseAsks(b.name ?? '', b.input)
+          const artifact = toolArtifact(b.name ?? '', b.input)
           out.push({
             turnId,
             type: 'tool',
             toolName: b.name ?? 'tool',
             detail: truncate(JSON.stringify(b.input ?? {}), 200),
             ...(preview ? { preview: truncate(preview, 200) } : {}),
-            ...(asks ? { asks } : {})
+            ...(asks ? { asks } : {}),
+            ...(artifact ? { artifact } : {})
           })
         }
       }
@@ -204,14 +207,33 @@ export function parseCodexStreamLine(turnId: string, line: any): ChatEvent[] {
       const paths = Array.isArray(it.changes)
         ? it.changes.map((c: { path?: unknown }) => c?.path).filter((p: unknown): p is string => typeof p === 'string')
         : []
+      // the stream names the files and what happened to each, never the lines. Named
+      // the way the rollout's FileChange row is (`apply_patch`, the files it touches),
+      // so a rejoined turn can tell the streamed row and the logged one are the same
+      const artifact = fileChangeArtifact(it.changes)
       out.push({
         turnId,
         type: 'tool',
-        toolName: 'edit',
+        toolName: 'apply_patch',
         detail: truncate(JSON.stringify(it.changes ?? ''), 200),
-        ...(paths.length > 0 ? { preview: truncate(paths.join(', '), 200) } : {})
+        ...(paths.length > 0 ? { preview: truncate(`apply_patch ${paths.join(', ')}`, 200) } : {}),
+        ...(artifact ? { artifact } : {})
       })
     }
+    if (it.type === 'todo_list') {
+      // the agent's running plan, always the whole list — it replaces the last one
+      const artifact = todoListArtifact(it.items)
+      const items = Array.isArray(it.items) ? it.items.length : 0
+      if (artifact)
+        out.push({
+          turnId,
+          type: 'tool',
+          toolName: 'update_plan',
+          detail: truncate(JSON.stringify(it.items ?? []), 200),
+          preview: `${items} ${items === 1 ? 'step' : 'steps'}`,
+          artifact
+        })
+    }
   } else if (line?.type === 'turn.completed') {
     out.push({ turnId, type: 'done' })
   }
diff --git a/src/main/parsers/artifacts.ts b/src/main/parsers/artifacts.ts
new file mode 100644
index 00000000..94b6afd4
--- /dev/null
+++ b/src/main/parsers/artifacts.ts
@@ -0,0 +1,368 @@
+import { diffLines } from '../../shared/line-diff'
+import type { EditLine, FileEdit, TodoItem, TodoStatus, WorkArtifact } from '../../shared/types'
+import { capText, truncate } from './util'
+
+/**
+ * What a tool call hands the person to look at — a plan, a to-do list, an edit —
+ * read off the call's own input, for every agent and both paths a call arrives by
+ * (the log on disk and the live stream). The Work panel renders these; without them
+ * a plan was 400 characters of JSON behind a collapsed row.
+ *
+ * Tool inputs are provider-internal and drift between releases, so every field is
+ * read defensively and a shape that doesn't match is simply no artifact — never a
+ * broken transcript. Everything is bounded: an artifact rides every transcript read
+ * over IPC, so a 3,000-line Write or a whole-file ACP diff must not ride it whole.
+ * IO-free — the unit tests target this directly.
+ */
+
+/** Files one call may report (a patch can touch many) */
+const MAX_FILES = 24
+/** Lines kept per file across its hunks; the rest is cut and the file marked */
+const MAX_FILE_LINES = 400
+/** One line of code — a minified bundle line must not become the payload */
+const MAX_LINE_CHARS = 400
+/** Lines of unchanged context kept around each change of a before/after pair */
+const CONTEXT = 3
+/** Beyond this many lines a side is not diffed at all: named, marked, no lines */
+const MAX_DIFF_SIDE = 6_000
+const MAX_TODOS = 60
+const MAX_TODO_CHARS = 300
+const MAX_PLAN_CHARS = 20_000
+
+type Rec = Record<string, unknown>
+
+function record(v: unknown): Rec | null {
+  return v && typeof v === 'object' && !Array.isArray(v) ? (v as Rec) : null
+}
+
+function str(v: unknown): string | null {
+  return typeof v === 'string' && v.trim() ? v : null
+}
+
+/** Text → lines as written: a trailing newline ends the last line, it doesn't add one. */
+function lines(text: string): string[] {
+  if (text === '') return []
+  const out = text.replace(/\r\n/g, '\n').split('\n')
+  if (out[out.length - 1] === '') out.pop()
+  return out
+}
+
+/** The words each CLI uses for a step's state, folded onto three. */
+export function todoStatus(v: unknown): TodoStatus {
+  const s = typeof v === 'string' ? v.toLowerCase().replace(/[\s-]/g, '_') : ''
+  if (s === 'completed' || s === 'complete' || s === 'done') return 'completed'
+  if (s === 'in_progress' || s === 'active' || s === 'running') return 'in_progress'
+  return 'pending'
+}
+
+function todos(list: unknown, read: (item: Rec) => { text: unknown; status: unknown }): WorkArtifact | undefined {
+  if (!Array.isArray(list)) return undefined
+  const items: TodoItem[] = []
+  for (const raw of list) {
+    const r = record(raw)
+    if (!r) continue
+    const { text, status } = read(r)
+    const t = str(text)
+    if (t) items.push({ text: truncate(t, MAX_TODO_CHARS), status: todoStatus(status) })
+    if (items.length === MAX_TODOS) break
+  }
+  // an empty list is still a statement — the agent cleared its plan
+  return { kind: 'todos', items }
+}
+
+function plan(text: unknown): WorkArtifact | undefined {
+  const t = str(text)
+  return t ? { kind: 'plan', text: capText(t.trim(), MAX_PLAN_CHARS) } : undefined
+}
+
+/**
+ * Keep a file's lines inside the bound: every line cut to a readable width, and
+ * lines past the file's budget dropped from the end, the file marked.
+ */
+function bounded(file: Omit<FileEdit, 'hunks' | 'truncated'>, hunks: readonly EditLine[][], cut = false): FileEdit {
+  let budget = MAX_FILE_LINES
+  let truncated = cut
+  const kept: EditLine[][] = []
+  for (const h of hunks) {
+    if (h.length === 0) continue
+    if (budget <= 0) {
+      truncated = true
+      break
+    }
+    const part = h.length > budget ? h.slice(0, budget) : h
+    if (part.length < h.length) truncated = true
+    budget -= part.length
+    kept.push(
+      part.map((l) => (l.text.length > MAX_LINE_CHARS ? { op: l.op, text: truncate(l.text, MAX_LINE_CHARS) } : l))
+    )
+  }
+  return { ...file, hunks: kept, ...(truncated ? { truncated: true } : {}) }
+}
+
+/**
+ * A before/after pair as hunks: the line diff, with only `CONTEXT` unchanged lines
+ * kept around each change — an ACP diff carries whole files, and a hunk that is the
+ * whole file would push the change itself off the panel.
+ */
+export function pairHunks(before: string, after: string): { hunks: EditLine[][]; cut: boolean } {
+  const a = lines(before)
+  const b = lines(after)
+  if (a.length > MAX_DIFF_SIDE || b.length > MAX_DIFF_SIDE) return { hunks: [], cut: true }
+  const diff = diffLines(a, b)
+  const keep = diff.map(() => false)
+  diff.forEach((l, i) => {
+    if (l.op === 'same') return
+    for (let k = Math.max(0, i - CONTEXT); k <= Math.min(diff.length - 1, i + CONTEXT); k++) keep[k] = true
+  })
+  const hunks: EditLine[][] = []
+  let cur: EditLine[] | null = null
+  diff.forEach((l, i) => {
+    if (!keep[i]) {
+      cur = null
+      return
+    }
+    if (!cur) {
+      cur = []
+      hunks.push(cur)
+    }
+    cur.push(l)
+  })
+  return { hunks, cut: false }
+}
+
+function replaceEdit(path: unknown, pairs: ReadonlyArray<readonly [unknown, unknown]>): FileEdit | null {
+  const p = str(path)
+  if (!p) return null
+  const hunks: EditLine[][] = []
+  let cut = false
+  for (const [before, after] of pairs) {
+    if (typeof before !== 'string' || typeof after !== 'string') continue
+    const d = pairHunks(before, after)
+    hunks.push(...d.hunks)
+    cut ||= d.cut
+  }
+  return bounded({ path: p, change: 'edit' }, hunks, cut)
+}
+
+/** A file written whole: every line is new, as far as the call can say. */
+function wholeFile(path: unknown, content: unknown, change: 'add' | 'write'): FileEdit | null {
+  const p = str(path)
+  if (!p || typeof content !== 'string') return null
+  return bounded({ path: p, change }, [lines(content).map((text) => ({ op: 'add', text }))])
+}
+
+function edits(files: ReadonlyArray<FileEdit | null>): WorkArtifact | undefined {
+  const kept = files.filter((f): f is FileEdit => f !== null).slice(0, MAX_FILES)
+  return kept.length > 0 ? { kind: 'edits', files: kept } : undefined
+}
+
+/**
+ * The patch format Codex and Copilot both write (`*** Begin Patch` … `*** End Patch`):
+ * per file an Add, Update (optionally `*** Move to:`) or Delete header, `@@` lines
+ * between hunks, and ` `/`-`/`+` lines.
+ */
+export function parsePatch(text: string): FileEdit[] {
+  type Draft = { path: string; change: FileEdit['change']; movedTo?: string; hunks: EditLine[][] }
+  const files: Draft[] = []
+  let cur: Draft | null = null
+  let hunk: EditLine[] | null = null
+  for (const raw of text.replace(/\r\n/g, '\n').split('\n')) {
+    const head = raw.match(/^\*\*\* (Add|Update|Delete) File: (.+)$/)
+    if (head) {
+      const change = head[1] === 'Add' ? 'add' : head[1] === 'Delete' ? 'delete' : 'edit'
+      cur = { path: head[2]!.trim(), change, hunks: [] }
+      files.push(cur)
+      hunk = null
+      continue
+    }
+    if (!cur) continue
+    const move = raw.match(/^\*\*\* Move to: (.+)$/)
+    if (move) {
+      cur.movedTo = move[1]!.trim()
+      continue
+    }
+    if (raw.startsWith('***')) continue
+    if (raw.startsWith('@@')) {
+      hunk = null
+      continue
+    }
+    if (cur.change === 'delete') continue
+    const op = raw[0] === '+' ? 'add' : raw[0] === '-' ? 'del' : raw[0] === ' ' ? 'same' : null
+    // a bare empty line inside an update is a blank context line some writers leave
+    // unprefixed; anywhere else it is the patch's own spacing
+    if (op === null && !(raw === '' && cur.change === 'edit')) continue
+    if (!hunk) {
+      hunk = []
+      cur.hunks.push(hunk)
+    }
+    hunk.push({ op: op ?? 'same', text: op === null ? '' : raw.slice(1) })
+  }
+  return files.map((f) => {
+    // the unprefixed blank a patch ends on is spacing, not context
+    for (const h of f.hunks) while (h.length > 0 && h[h.length - 1]!.op === 'same' && h[h.length - 1]!.text === '') h.pop()
+    const { hunks, ...file } = f
+    return bounded(file, hunks)
+  })
+}
+
+/** A unified diff's hunks (`@@ -a,b +c,d @@`), headers and "no newline" notes skipped. */
+export function parseUnifiedDiff(text: string): EditLine[][] {
+  const hunks: EditLine[][] = []
+  let hunk: EditLine[] | null = null
+  for (const raw of text.replace(/\r\n/g, '\n').split('\n')) {
+    if (raw.startsWith('@@')) {
+      hunk = []
+      hunks.push(hunk)
+      continue
+    }
+    if (!hunk || raw.startsWith('\\')) continue
+    const op = raw[0] === '+' ? 'add' : raw[0] === '-' ? 'del' : raw[0] === ' ' ? 'same' : null
+    if (op) hunk.push({ op, text: raw.slice(1) })
+  }
+  return hunks
+}
+
+/** The patch inside a shell script — Codex once ran apply_patch as a command. */
+function patchIn(text: string): string | null {
+  const start = text.indexOf('*** Begin Patch')
+  if (start < 0) return null
+  const end = text.indexOf('*** End Patch', start)
+  return end < 0 ? text.slice(start) : text.slice(start, end + '*** End Patch'.length)
+}
+
+function patchArtifact(text: unknown): WorkArtifact | undefined {
+  const patch = typeof text === 'string' ? patchIn(text) : null
+  return patch ? edits(parsePatch(patch)) : undefined
+}
+
+/** The tool names each CLI plans, lists and edits with, and what each one's input says. */
+export function toolArtifact(name: string, input: unknown): WorkArtifact | undefined {
+  const i = record(input)
+  switch (name) {
+    // Claude
+    case 'ExitPlanMode':
+      return plan(i?.plan)
+    case 'TodoWrite':
+      return todos(i?.todos, (t) => ({ text: t.content ?? t.activeForm, status: t.status }))
+    case 'TaskCreate': {
+      // one task per call, or a batch under `tasks`
+      const tasks = i?.tasks
+      const batch = Array.isArray(tasks) ? tasks.map((t) => record(t)?.subject) : [i?.subject]
+      const items = batch.flatMap((s) => (str(s) ? [truncate(str(s)!, MAX_TODO_CHARS)] : []))
+      return items.length > 0 ? { kind: 'task-add', items: items.slice(0, MAX_TODOS) } : undefined
+    }
+    case 'TaskUpdate': {
+      const id = i?.taskId
+      if (typeof id !== 'string' && typeof id !== 'number') return undefined
+      const status = i?.status
+      const s = typeof status === 'string' ? status.toLowerCase() : null
+      const text = str(i?.subject)
+      return {
+        kind: 'task-update',
+        id: String(id),
+        ...(s ? { status: s === 'deleted' ? 'deleted' : todoStatus(s) } : {}),
+        ...(text ? { text: truncate(text, MAX_TODO_CHARS) } : {})
+      }
+    }
+    case 'Edit':
+      return edits([replaceEdit(i?.file_path, [[i?.old_string, i?.new_string]])])
+    case 'MultiEdit': {
+      const list = i?.edits
+      const pairs = Array.isArray(list)
+        ? list.map((e): readonly [unknown, unknown] => [record(e)?.old_string, record(e)?.new_string])
+        : []
+      return edits([replaceEdit(i?.file_path, pairs)])
+    }
+    case 'Write':
+      return edits([wholeFile(i?.file_path, i?.content, 'write')])
+    // Codex
+    case 'update_plan':
+      return todos(i?.plan, (t) => ({ text: t.step, status: t.status }))
+    case 'shell':
+    case 'exec_command':
+    case 'local_shell': {
+      const cmd = i?.command ?? i?.cmd
+      return patchArtifact(Array.isArray(cmd) ? cmd.map(String).join('\n') : cmd)
+    }
+    // Codex and Copilot: the input is the patch, bare or under `input`/`patch`
+    case 'apply_patch':
+      return patchArtifact(typeof input === 'string' ? input : (i?.input ?? i?.patch))
+    // Copilot
+    case 'exit_plan_mode':
+      return plan(i?.summary ?? i?.plan)
+    case 'edit':
+    case 'str_replace':
+      return edits([replaceEdit(i?.path, [[i?.old_str, i?.new_str]])])
+    case 'create':
+      return edits([wholeFile(i?.path, i?.file_text, 'add')])
+    case 'str_replace_editor':
+      if (i?.command === 'create') return edits([wholeFile(i?.path, i?.file_text, 'add')])
+      if (i?.command === 'str_replace') return edits([replaceEdit(i?.path, [[i?.old_str, i?.new_str]])])
+      return undefined
+    default:
+      return undefined
+  }
+}
+
+/**
+ * Codex's typed file change — `FileChange.changes` in a rollout, keyed by path with
+ * the content (`add`) or a unified diff (`update`), and `file_change.changes` in the
+ * `exec --json` stream, a list of paths and kinds with no lines at all.
+ */
+export function fileChangeArtifact(changes: unknown): WorkArtifact | undefined {
+  const files: Array<FileEdit | null> = []
+  if (Array.isArray(changes)) {
+    for (const c of changes) {
+      const r = record(c)
+      const path = str(r?.path)
+      if (path) files.push({ path, change: changeKind(r?.kind), hunks: [] })
+    }
+  } else {
+    for (const [path, c] of Object.entries(record(changes) ?? {})) {
+      const r = record(c)
+      const kind = changeKind(r?.type ?? r?.kind)
+      if (kind === 'add') files.push(wholeFile(path, r?.content, 'add') ?? { path, change: 'add', hunks: [] })
+      else if (kind === 'delete') files.push({ path, change: 'delete', hunks: [] })
+      else {
+        const unified = r?.unified_diff
+        const diff = typeof unified === 'string' ? parseUnifiedDiff(unified) : []
+        const moved = str(r?.move_path)
+        files.push(bounded({ path, change: 'edit', ...(moved ? { movedTo: moved } : {}) }, diff))
+      }
+    }
+  }
+  return edits(files)
+}
+
+function changeKind(v: unknown): FileEdit['change'] {
+  return v === 'add' ? 'add' : v === 'delete' ? 'delete' : 'edit'
+}
+
+/** Codex's `todo_list` stream item: `{ items: [{ text, completed }] }`. */
+export function todoListArtifact(items: unknown): WorkArtifact | undefined {
+  return todos(items, (t) => ({ text: t.text, status: t.completed === true ? 'completed' : 'pending' }))
+}
+
+/** ACP's `plan` update: `{ entries: [{ content, status, priority }] }`, always the whole list. */
+export function acpPlanArtifact(entries: unknown): WorkArtifact | undefined {
+  return todos(entries, (t) => ({ text: t.content, status: t.status }))
+}
+
+/** ACP tool-call content blocks of type `diff`: `{ path, oldText, newText }`, whole files. */
+export function acpDiffArtifact(content: unknown): WorkArtifact | undefined {
+  if (!Array.isArray(content)) return undefined
+  const files: Array<FileEdit | null> = []
+  for (const c of content) {
+    const r = record(c)
+    if (r?.type !== 'diff') continue
+    const path = str(r.path)
+    if (!path || typeof r.newText !== 'string') continue
+    if (typeof r.oldText !== 'string') {
+      files.push(wholeFile(path, r.newText, 'add'))
+      continue
+    }
+    const d = pairHunks(r.oldText, r.newText)
+    files.push(bounded({ path, change: 'edit' }, d.hunks, d.cut))
+  }
+  return edits(files)
+}
diff --git a/src/main/parsers/claude.ts b/src/main/parsers/claude.ts
index 3cc3f6eb..f991c83f 100644
--- a/src/main/parsers/claude.ts
+++ b/src/main/parsers/claude.ts
@@ -1,6 +1,7 @@
 import { basename, join, sep } from 'node:path'
 import type { SessionMeta, SessionMessage } from '../../shared/types'
 import { parseAsks } from '../../shared/asks'
+import { toolArtifact } from './artifacts'
 import {
   capText,
   contentToText,
@@ -146,12 +147,29 @@ export function parseClaudeMeta(file: string, sourceLabel: string): SessionMeta
   }
 }
 
+/**
+ * What a call's result says about the call itself: a refused or failed call is marked
+ * (an edit that never landed must not read as one), and a created task learns the
+ * number Claude gave it — `Task #3 created successfully` — which is what later
+ * TaskUpdate calls name it by.
+ */
+function answered(call: SessionMessage, result: string, isError: boolean): SessionMessage {
+  if (isError) return { ...call, failed: true }
+  const a = call.artifact
+  if (a?.kind !== 'task-add') return call
+  const ids = [...result.matchAll(/Task #(\w+)/g)].map((m) => m[1]!)
+  return ids.length === a.items.length ? { ...call, artifact: { ...a, ids } } : call
+}
+
 export function parseClaudeMessages(file: string): SessionMessage[] {
   const { lines, truncated } = readJsonlTail(file)
   const out: SessionMessage[] = []
   if (truncated) {
     out.push({ role: 'system', kind: 'system', text: '(older messages omitted — transcript is very large)' })
   }
+  // where each call's row sits: a result answers its call by id, and parallel calls
+  // put several results after several calls, so adjacency would pair them wrong
+  const callRows = new Map<string, number>()
   for (const l of lines) {
     const ts = toMs(l.timestamp) ?? undefined
     if (l.type === 'user' || l.type === 'assistant') {
@@ -163,6 +181,8 @@ export function parseClaudeMessages(file: string): SessionMessage[] {
           if (b?.type === 'tool_use') {
             const preview = toolPreview(b.name ?? 'tool', b.input)
             const asks = parseAsks(b.name ?? '', b.input)
+            const artifact = toolArtifact(b.name ?? '', b.input)
+            if (typeof b.id === 'string') callRows.set(b.id, out.length)
             out.push({
               role: 'assistant',
               kind: 'tool_call',
@@ -170,16 +190,16 @@ export function parseClaudeMessages(file: string): SessionMessage[] {
               text: truncate(JSON.stringify(b.input ?? {}), 400),
               ...(preview ? { preview: truncate(preview, 200) } : {}),
               ...(asks ? { asks } : {}),
+              ...(artifact ? { artifact } : {}),
               ts
             })
           }
-          if (b?.type === 'tool_result')
-            out.push({
-              role: 'tool',
-              kind: 'tool_result',
-              text: truncate(contentToText(b.content) || '(result)', 400),
-              ts
-            })
+          if (b?.type === 'tool_result') {
+            const text = contentToText(b.content)
+            const at = typeof b.tool_use_id === 'string' ? callRows.get(b.tool_use_id) : undefined
+            if (at !== undefined) out[at] = answered(out[at]!, text, b.is_error === true)
+            out.push({ role: 'tool', kind: 'tool_result', text: truncate(text || '(result)', 400), ts })
+          }
         }
       }
     } else if (l.type === 'system' && typeof l.content === 'string') {
diff --git a/src/main/parsers/codex.ts b/src/main/parsers/codex.ts
index c50d19c7..50284dd8 100644
--- a/src/main/parsers/codex.ts
+++ b/src/main/parsers/codex.ts
@@ -2,6 +2,7 @@ import { basename, dirname, join } from 'node:path'
 import { statSync } from 'node:fs'
 import type { SessionMeta, SessionMessage, SessionSegment } from '../../shared/types'
 import { parseAsks } from '../../shared/asks'
+import { fileChangeArtifact, toolArtifact } from './artifacts'
 import {
   capText,
   contentToText,
@@ -13,6 +14,7 @@ import {
   TRANSCRIPT_TAIL_BYTES,
   toMs,
   toolPreview,
+  patchPreview,
   truncate,
   walkFiles
 } from './util'
@@ -107,6 +109,47 @@ function usesEventEchoes(lines: readonly any[]): boolean {
   return !lines.some(isItemMessage)
 }
 
+/** A patch applied as its own tool call, rather than from inside a code-mode `exec` script. */
+function isPatchCall(l: any): boolean {
+  const p = l?.payload ?? l
+  return (
+    lineKind(l) === 'response_item' &&
+    (p?.type === 'function_call' || p?.type === 'custom_tool_call') &&
+    p?.name === 'apply_patch'
+  )
+}
+
+/**
+ * Newer Codex applies patches from inside a code-mode `exec` script, so the only
+ * record of what a patch changed is the typed `FileChange` item it completes with —
+ * paths, and the content or a unified diff. A rollout that applies patches as calls
+ * of their own renders those instead, so the one change is never shown twice.
+ */
+function usesFileChangeItems(lines: readonly any[]): boolean {
+  return !lines.some(isPatchCall)
+}
+
+/** One `FileChange` item as the tool row a patch call would have been. */
+function fileChangeRow(item: any, ts: number | undefined): SessionMessage | null {
+  const artifact = fileChangeArtifact(item?.changes)
+  if (!artifact || artifact.kind !== 'edits') return null
+  // the headline a patch call gets (`patchPreview`): the files it touches
+  const preview = `apply_patch ${artifact.files.map((f) => f.path).join(', ')}`
+  // a patch that failed or was declined still names the files; it didn't change them
+  const failed = typeof item?.status === 'string' && item.status !== 'completed'
+  const stdout = typeof item?.stdout === 'string' ? item.stdout : ''
+  return {
+    role: 'assistant',
+    kind: 'tool_call',
+    toolName: 'apply_patch',
+    text: truncate(stdout || preview, 400),
+    preview: truncate(preview, 200),
+    artifact,
+    ...(failed ? { failed: true } : {}),
+    ts
+  }
+}
+
 /**
  * A rollout that is a part of another thread rather than a thread of its own.
  * `thread_source` names the kind and has grown new ones (`subagent`, then
@@ -246,6 +289,9 @@ export function parseCodexMessages(file: string, segments: readonly SessionSegme
 function renderLines(lines: readonly any[]): SessionMessage[] {
   const out: SessionMessage[] = []
   const renderEchoes = usesEventEchoes(lines)
+  const renderFileChanges = usesFileChangeItems(lines)
+  // an apply_patch custom call's output is rendered only after the call it answers
+  const patchCalls = new Set<string>()
   for (const l of lines) {
     const ts = toMs(l.timestamp) ?? undefined
     const p = l.payload ?? l
@@ -263,6 +309,7 @@ function renderLines(lines: readonly any[]): SessionMessage[] {
           const args = parseArguments(p.arguments)
           const preview = toolPreview(p.name ?? 'tool', args)
           const asks = parseAsks(p.name ?? '', args)
+          const artifact = toolArtifact(p.name ?? '', args)
           out.push({
             role: 'assistant',
             kind: 'tool_call',
@@ -270,10 +317,38 @@ function renderLines(lines: readonly any[]): SessionMessage[] {
             text: truncate(String(p.arguments ?? ''), 400),
             ...(preview ? { preview: truncate(preview, 200) } : {}),
             ...(asks ? { asks } : {}),
+            ...(artifact ? { artifact } : {}),
+            ts
+          })
+          break
+        }
+        case 'custom_tool_call': {
+          // freeform tools take raw text rather than JSON; the patch tool is the one
+          // whose input is worth a row (code-mode `exec` scripts are not rendered yet)
+          if (p.name !== 'apply_patch' || typeof p.input !== 'string') break
+          const artifact = toolArtifact('apply_patch', p.input)
+          const preview = patchPreview(p.input)
+          if (typeof p.call_id === 'string') patchCalls.add(p.call_id)
+          out.push({
+            role: 'assistant',
+            kind: 'tool_call',
+            toolName: 'apply_patch',
+            text: truncate(p.input, 400),
+            ...(preview ? { preview: truncate(preview, 200) } : {}),
+            ...(artifact ? { artifact } : {}),
             ts
           })
           break
         }
+        case 'custom_tool_call_output':
+          if (typeof p.call_id !== 'string' || !patchCalls.has(p.call_id)) break
+          out.push({
+            role: 'tool',
+            kind: 'tool_result',
+            text: truncate(typeof p.output === 'string' ? p.output : JSON.stringify(p.output ?? ''), 400),
+            ts
+          })
+          break
         case 'function_call_output':
           out.push({
             role: 'tool',
@@ -288,6 +363,11 @@ function renderLines(lines: readonly any[]): SessionMessage[] {
           break
         }
       }
+    } else if (lineKind(l) === 'event_msg' && p?.type === 'item_completed') {
+      if (renderFileChanges && p.item?.type === 'FileChange') {
+        const row = fileChangeRow(p.item, ts)
+        if (row) out.push(row)
+      }
     } else if (lineKind(l) === 'event_msg' && renderEchoes) {
       if (p?.type === 'user_message' && p.message)
         out.push({ role: 'user', kind: 'text', text: capText(String(p.message)), ts })
diff --git a/src/main/parsers/copilot.ts b/src/main/parsers/copilot.ts
index fe5aa6aa..00c270ff 100644
--- a/src/main/parsers/copilot.ts
+++ b/src/main/parsers/copilot.ts
@@ -1,6 +1,7 @@
 import { basename, dirname, join } from 'node:path'
 import { existsSync, readFileSync, readdirSync } from 'node:fs'
 import type { SessionMeta, SessionMessage } from '../../shared/types'
+import { toolArtifact } from './artifacts'
 import {
   capText,
   readJson,
@@ -309,6 +310,8 @@ export function parseCopilotMessages(file: string): SessionMessage[] {
     if (truncated) {
       out.push({ role: 'system', kind: 'system', text: '(older messages omitted — transcript is very large)' })
     }
+    // where each call's row sits, so a failed completion can mark it
+    const callRows = new Map<string, number>()
     for (const ev of lines) {
       const ts = toMs(ev.timestamp) ?? undefined
       if (ev.type === 'user.message' || ev.type === 'assistant.message') {
@@ -321,14 +324,21 @@ export function parseCopilotMessages(file: string): SessionMessage[] {
         const args = ev.data?.arguments ?? ev.data?.input ?? ''
         // the same humanized headline Claude and Codex rows get — raw JSON stays in the detail
         const preview = toolPreview(toolName, args)
+        const artifact = toolArtifact(toolName, args)
+        if (typeof ev.data?.toolCallId === 'string') callRows.set(ev.data.toolCallId, out.length)
         out.push({
           role: 'assistant',
           kind: 'tool_call',
           toolName,
           text: truncate(JSON.stringify(args), 400),
           ...(preview ? { preview: truncate(preview, 200) } : {}),
+          ...(artifact ? { artifact } : {}),
           ts
         })
+      } else if (ev.type === 'tool.execution_complete' && ev.data?.success === false) {
+        // an edit that never landed must not read as one
+        const at = typeof ev.data.toolCallId === 'string' ? callRows.get(ev.data.toolCallId) : undefined
+        if (at !== undefined) out[at] = { ...out[at]!, failed: true }
       } else if (ev.type === 'system.message') {
         const text = typeof ev.data?.content === 'string' ? ev.data.content : ''
         if (text) out.push({ role: 'system', kind: 'system', text: truncate(text, 200), ts })
diff --git a/src/main/parsers/util.ts b/src/main/parsers/util.ts
index 08316bb7..646bed34 100644
--- a/src/main/parsers/util.ts
+++ b/src/main/parsers/util.ts
@@ -257,9 +257,23 @@ export function toolPreview(name: string, input: unknown): string | null {
     case 'Bash':
       return str(i.command)
     case 'Edit':
+    case 'MultiEdit':
     case 'Write':
     case 'Read':
       return str(i.file_path)
+    // the to-do tools: what the list became, not the list as JSON
+    case 'TodoWrite':
+    case 'update_plan': {
+      const list = Array.isArray(i.todos) ? i.todos : Array.isArray(i.plan) ? i.plan : null
+      return list ? `${list.length} ${list.length === 1 ? 'step' : 'steps'}` : null
+    }
+    case 'TaskCreate':
+      return str(i.subject)
+    case 'TaskUpdate': {
+      const id = typeof i.taskId === 'string' || typeof i.taskId === 'number' ? String(i.taskId) : null
+      const status = str(i.status)
+      return id ? `#${id}${status ? ` → ${status.replace(/_/g, ' ')}` : ''}` : null
+    }
     case 'NotebookEdit':
       return str(i.notebook_path)
     case 'Grep': {
@@ -286,6 +300,7 @@ export function toolPreview(name: string, input: unknown): string | null {
       return str(q?.question) ?? str(q?.title) ?? str(q?.header) ?? 'waiting for your answer'
     }
     case 'ExitPlanMode':
+    case 'exit_plan_mode':
       return 'waiting for the plan to be approved'
     // Codex: the command array (or string) it hands a shell, and apply_patch bodies
     case 'shell':
diff --git a/src/renderer/src/App.tsx b/src/renderer/src/App.tsx
index 4804844d..c560377f 100644
--- a/src/renderer/src/App.tsx
+++ b/src/renderer/src/App.tsx
@@ -357,7 +357,9 @@ export function App(): JSX.Element {
           text: ev.detail,
           preview: ev.preview,
           // a question with options reaches the transcript as an answerable card
-          ...(ev.asks ? { asks: ev.asks } : {})
+          ...(ev.asks ? { asks: ev.asks } : {}),
+          // a plan, to-dos or an edit opens in the Work panel as it streams
+          ...(ev.artifact ? { artifact: ev.artifact } : {})
         })
       } else if (ev.type === 'permission') {
         // the prompt is not a transcript row, but it must land after what came before it
diff --git a/src/renderer/src/AskPicker.tsx b/src/renderer/src/AskPicker.tsx
index e03e71f1..cead20e4 100644
--- a/src/renderer/src/AskPicker.tsx
+++ b/src/renderer/src/AskPicker.tsx
@@ -2,6 +2,7 @@ import { useId, useState, type JSX } from 'react'
 import type { AskPrompt, Provider } from '../../shared/types'
 import { formatAskAnswer } from '../../shared/asks'
 import { PROVIDER_LABEL, QuestionIcon } from './logos'
+import { Markdown } from './Markdown'
 
 /**
  * The agent stopped to ask: its questions, with the answers it offered as picks.
@@ -15,13 +16,19 @@ export function AskPicker({
   prompts,
   provider,
   disabled,
-  onAnswer
+  onAnswer,
+  plan,
+  onOpenPlan
 }: {
   prompts: readonly AskPrompt[]
   provider: Provider
   /** A turn is running (or the session takes no input) — the answer can't go yet */
   disabled: boolean
   onAnswer: (text: string) => void
+  /** The plan an approval question is about: read here, before the pick */
+  plan?: string
+  /** Opens the plan in the Work panel, for a long one */
+  onOpenPlan?: () => void
 }): JSX.Element {
   const id = useId()
   // one entry per question, in the order asked; a single-select question holds at most one
@@ -50,6 +57,19 @@ export function AskPicker({
         </span>
         asks you
       </div>
+      {plan && (
+        <div className="ask-plan">
+          {/* the card's own scroller: reachable by keyboard, named for what it holds */}
+          <div className="ask-plan-body markdown" role="region" aria-label="The plan" tabIndex={0}>
+            <Markdown text={plan} />
+          </div>
+          {onOpenPlan && (
+            <button className="btn-ghost small ask-plan-open" onClick={onOpenPlan}>
+              Open in the Work panel
+            </button>
+          )}
+        </div>
+      )}
       {prompts.map((p, qi) => (
         <fieldset className="ask-q" key={`${qi}-${p.question}`}>
           <legend className="ask-legend">
diff --git a/src/renderer/src/ChatView.tsx b/src/renderer/src/ChatView.tsx
index db7e74d3..1f74b101 100644
--- a/src/renderer/src/ChatView.tsx
+++ b/src/renderer/src/ChatView.tsx
@@ -1,4 +1,4 @@
-import { memo, useEffect, useLayoutEffect, useMemo, useRef, useState, type JSX } from 'react'
+import { memo, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, type JSX } from 'react'
 import type { PermissionMode, Provider, PrStatus, SessionMessage } from '../../shared/types'
 import { api } from './api'
 import { AskPicker } from './AskPicker'
@@ -9,11 +9,14 @@ import { announceChat, useChatLog, useChatStatus } from './chat-log'
 import { Markdown } from './Markdown'
 import { MODES } from './NewSession'
 import { cwdLabel } from '../../shared/library'
-import { BranchChip, CockpitLogo, DiffIcon, HandoffIcon, PrBadge, ProviderLogo, PROVIDER_LABEL } from './logos'
+import { BranchChip, CockpitLogo, DiffIcon, HandoffIcon, PrBadge, ProviderLogo, PROVIDER_LABEL, WorkIcon } from './logos'
+import { DiffStat } from './InstructionDiff'
 import { ReviewPanel } from './ReviewPanel'
 import { Select } from './Select'
 import { findAnchor } from './transcript-anchor'
 import { EarlierRow, JumpToLatest, useTranscriptWindow, useUnseenBelow } from './transcript-window'
+import { artifactStat, buildWork, hasWork, planTitle, tabFor, type WorkModel, type WorkTab } from './work'
+import { WorkPanel, type WorkFocus } from './WorkPanel'
 
 /** Big transcripts are already tail-capped in main; this bounds the DOM too — the
  *  newest rows first, and "show earlier" brings the next batch of this size. */
@@ -70,6 +73,10 @@ export function ChatView({
   const [cwdCopied, setCwdCopied] = useState(false)
   /** Review mode: the worktree's changes take the transcript's place */
   const [review, setReview] = useState(false)
+  /** The Work panel beside the transcript: which tab, and the row that opened it */
+  const [work, setWork] = useState<WorkFocus | null>(null)
+  /** What had focus when the panel opened — closing hands it back */
+  const workOpener = useRef<HTMLElement | null>(null)
   const scrollRef = useRef<HTMLDivElement>(null)
   const composerRef = useRef<HTMLTextAreaElement>(null)
   /** Auto-scroll only while the user is pinned to the bottom — never hijack a scroll-up. */
@@ -152,8 +159,34 @@ export function ChatView({
   const reviewable = !!binding?.repoRoot && !binding.readOnly
   useEffect(() => {
     setReview(false)
+    setWork(null)
   }, [binding?.cwd])
 
+  // the Work panel is offered once the transcript holds something to put in it — a
+  // plan, a to-do list, an edit — and built only while it is open
+  const workable = useMemo(() => hasWork(log), [log])
+  const model = useMemo(() => (work && binding ? buildWork(log, binding.cwd) : null), [work !== null, log, binding?.cwd])
+  const openWork = useCallback((key: number | null, tab: WorkTab) => {
+    const active = document.activeElement
+    if (active instanceof HTMLElement && !active.closest('.work-panel')) workOpener.current = active
+    setWork({ tab, key, at: Date.now() })
+  }, [])
+  const closeWork = useCallback(() => {
+    setWork(null)
+    // focus goes back where it came from — unless that row has since left the DOM
+    const back = workOpener.current
+    workOpener.current = null
+    if (back?.isConnected) back.focus()
+  }, [])
+  /** Changes, from the header, ⌘D or the Edits tab. Where the panel covers the
+   *  conversation (a narrow deck), the review would open unseen behind it — so it
+   *  gives way first; beside the conversation it stays, to read the two together. */
+  const toggleReview = useCallback(() => {
+    const panel = document.getElementById('work-panel')
+    if (panel && getComputedStyle(panel).position === 'absolute') closeWork()
+    setReview((v) => !v)
+  }, [closeWork])
+
   // ⌘D flips between the conversation and its changes (the palette owns the
   // keyboard while it is open — a dialog on screen means leave it alone)
   useEffect(() => {
@@ -161,11 +194,29 @@ export function ChatView({
     const onKey = (e: KeyboardEvent): void => {
       if (!(e.metaKey || e.ctrlKey) || e.key !== 'd' || document.querySelector('[role="dialog"]')) return
       e.preventDefault()
-      setReview((v) => !v)
+      toggleReview()
     }
     window.addEventListener('keydown', onKey)
     return () => window.removeEventListener('keydown', onKey)
-  }, [reviewable])
+  }, [reviewable, toggleReview])
+
+  /** The header key and ⌘J: open on the tab that matters most right now, or close. */
+  const toggleWork = (): void => {
+    if (work) closeWork()
+    else if (binding) openWork(null, defaultTab(buildWork(log, binding.cwd), pendingPlanKey))
+  }
+  const toggleWorkRef = useRef(toggleWork)
+  toggleWorkRef.current = toggleWork
+  useEffect(() => {
+    if (!workable && !work) return
+    const onKey = (e: KeyboardEvent): void => {
+      if (!(e.metaKey || e.ctrlKey) || e.key !== 'j' || document.querySelector('[role="dialog"]')) return
+      e.preventDefault()
+      toggleWorkRef.current()
+    }
+    window.addEventListener('keydown', onKey)
+    return () => window.removeEventListener('keydown', onKey)
+  }, [workable, work !== null])
 
   /** Review notes and fix prompts land in the composer, ready to send — the reviewer gets the last word. */
   const compose = (text: string): void => {
@@ -220,6 +271,7 @@ export function ChatView({
   // conversation belongs to its table
   const lastRow = visible[visible.length - 1]
   const pendingAsk = lastRow && isPendingAsk(lastRow) && !binding?.readOnly ? lastRow : undefined
+  const pendingPlanKey = pendingAsk?.m.artifact?.kind === 'plan' ? pendingAsk.key : null
 
   // a long stretch of tool calls is one piece of work, not twenty rows of it: four or
   // more in a row fold into a work-log block that says what happened. The run a turn
@@ -361,12 +413,27 @@ export function ChatView({
                 ? 'Back to the conversation (⌘D)'
                 : "Review the worktree's changes before they ship (⌘D)"
             }
-            onClick={() => setReview((v) => !v)}
+            onClick={toggleReview}
           >
             <DiffIcon />
             <span className="lbl">Changes</span>
           </button>
         )}
+        {/* the agent's plan, to-dos and edits beside the conversation — offered once
+            the transcript holds any of them. Its mark alone at every width: the rows
+            are the way in, and a fourth label took the title's room at 900px */}
+        {(workable || work) && (
+          <button
+            className="btn-review btn-work"
+            aria-label="Work"
+            aria-pressed={work !== null}
+            aria-controls={work ? 'work-panel' : undefined}
+            title={work ? 'Close the Work panel (⌘J)' : "Work — the agent's plan, to-dos and edits, beside the conversation (⌘J)"}
+            onClick={toggleWork}
+          >
+            <WorkIcon />
+          </button>
+        )}
         {/* progressive disclosure: only a started session can be handed off; a
             running turn merely disables it. A roundtable seat session is the
             table's internal, not a conversation to continue — main refuses it
@@ -385,141 +452,176 @@ export function ChatView({
         )}
       </header>
 
-      {review && reviewable ? (
-        <ReviewPanel
-          cwd={binding.cwd}
-          provider={binding.provider}
-          busy={busy}
-          onCompose={compose}
-          pr={branchPr}
-          repoRoot={binding.repoRoot}
-          onOpenUrl={onOpenUrl}
-        />
-      ) : (
-        <div
-          className="messages"
-          ref={scrollRef}
-          onScroll={(e) => {
-            const el = e.currentTarget
-            atBottomRef.current = el.scrollHeight - el.scrollTop - el.clientHeight < 48
-            if (atBottomRef.current) below.settle()
-          }}
-        >
-          {hidden > 0 && (
-            <EarlierRow shown={sliced.length} total={log.length} step={RENDER_LAST} onShow={showEarlier} />
-          )}
-          {blocks.map((b) =>
-            b.kind === 'run' ? (
-              <ToolRun key={b.rows[0].key} rows={b.rows} provider={binding.provider} cwd={binding.cwd} />
-            ) : b.row === pendingAsk && b.row.m.asks ? (
-              // the question takes the tool row's place: its options are the point,
-              // and a collapsed ⚙︎ row hid them behind the raw JSON
-              <AskPicker
-                key={b.row.key}
-                prompts={b.row.m.asks}
-                provider={binding.provider}
-                disabled={sendBlocked}
-                onAnswer={sendAnswer}
-              />
-            ) : (
-              <Message
-                key={b.row.key}
-                m={b.row.m}
-                provider={binding.provider}
-                result={b.row.result}
-                cwd={binding.cwd}
-                logKey={b.row.key}
-                anchored={b.row.key === anchoredKey}
-              />
-            )
-          )}
-          {busy && (
-            <div className="thinking">
-              <span className="pulse" /> {PROVIDER_LABEL[binding.provider]} is working…
-            </div>
-          )}
-          {/* the same annunciator for a turn someone else is running: the log grows
-              under this view (App re-reads it as the index sees each write) */}
-          {!busy && elsewhere && (
-            <div className="thinking" title={elsewhereHint}>
-              <span className="pulse" /> {PROVIDER_LABEL[binding.provider]} is working elsewhere…
+      <div className="chat-deck">
+        <div className="chat-main">
+          {review && reviewable ? (
+            <ReviewPanel
+              cwd={binding.cwd}
+              provider={binding.provider}
+              busy={busy}
+              onCompose={compose}
+              pr={branchPr}
+              repoRoot={binding.repoRoot}
+              onOpenUrl={onOpenUrl}
+            />
+          ) : (
+            <div
+              className="messages"
+              ref={scrollRef}
+              onScroll={(e) => {
+                const el = e.currentTarget
+                atBottomRef.current = el.scrollHeight - el.scrollTop - el.clientHeight < 48
+                if (atBottomRef.current) below.settle()
+              }}
+            >
+              {hidden > 0 && (
+                <EarlierRow shown={sliced.length} total={log.length} step={RENDER_LAST} onShow={showEarlier} />
+              )}
+              {blocks.map((b) =>
+                b.kind === 'run' ? (
+                  <ToolRun
+                    key={b.rows[0].key}
+                    rows={b.rows}
+                    provider={binding.provider}
+                    cwd={binding.cwd}
+                    onOpenWork={openWork}
+                  />
+                ) : b.row === pendingAsk && b.row.m.asks ? (
+                  // the question takes the tool row's place: its options are the point,
+                  // and a collapsed ⚙︎ row hid them behind the raw JSON
+                  <AskPicker
+                    key={b.row.key}
+                    prompts={b.row.m.asks}
+                    provider={binding.provider}
+                    disabled={sendBlocked}
+                    onAnswer={sendAnswer}
+                    // a plan is approved with the plan in view, never on its title alone
+                    plan={b.row.m.artifact?.kind === 'plan' ? b.row.m.artifact.text : undefined}
+                    onOpenPlan={() => openWork(b.row.key, 'plan')}
+                  />
+                ) : (
+                  <Message
+                    key={b.row.key}
+                    m={b.row.m}
+                    provider={binding.provider}
+                    result={b.row.result}
+                    cwd={binding.cwd}
+                    logKey={b.row.key}
+                    anchored={b.row.key === anchoredKey}
+                    onOpenWork={openWork}
+                  />
+                )
+              )}
+              {busy && (
+                <div className="thinking">
+                  <span className="pulse" /> {PROVIDER_LABEL[binding.provider]} is working…
+                </div>
+              )}
+              {/* the same annunciator for a turn someone else is running: the log grows
+                  under this view (App re-reads it as the index sees each write) */}
+              {!busy && elsewhere && (
+                <div className="thinking" title={elsewhereHint}>
+                  <span className="pulse" /> {PROVIDER_LABEL[binding.provider]} is working elsewhere…
+                </div>
+              )}
+              {log.length === 0 && !sendBlocked && (
+                <div className="empty-chat small">Send a prompt to start this session.</div>
+              )}
+              <JumpToLatest on={below.unseen} onJump={below.jump} />
             </div>
           )}
-          {log.length === 0 && !sendBlocked && (
-            <div className="empty-chat small">Send a prompt to start this session.</div>
-          )}
-          <JumpToLatest on={below.unseen} onJump={below.jump} />
-        </div>
-      )}
-      <div className="sr-only" role="status" aria-live="polite">
-        {status}
-      </div>
-
-      {permissions.map((ask) => (
-        <PermissionAsk
-          key={ask.requestId}
-          ask={ask}
-          provider={binding.provider}
-          onAnswer={(optionId) => onAnswerPermission(ask, optionId)}
-        />
-      ))}
-
-      <footer className="composer">
-        {binding.readOnly ? (
-          // roundtable seat-session: the table's round loop owns this conversation
-          <div className="composer-readonly">
-            Seat session of a roundtable — read-only. Talk to it at the table.
+          <div className="sr-only" role="status" aria-live="polite">
+            {status}
           </div>
-        ) : (
-          <>
-            <AttachRow atts={atts} />
-            <textarea
-              ref={composerRef}
-              aria-label={`Message ${PROVIDER_LABEL[binding.provider]}`}
-              placeholder={`Message ${PROVIDER_LABEL[binding.provider]}…  (Enter to send, Shift+Enter for newline)`}
-              value={draft}
-              onChange={(e) => setDraft(e.target.value)}
-              onPaste={atts.onPaste}
-              onKeyDown={(e) => {
-                if (e.key === 'Enter' && !e.shiftKey) {
-                  e.preventDefault()
-                  submit()
-                }
-              }}
-            />
-            {/* the mode governs the next turn, so it sits beside the button that sends
-                it — the same grammar as Home's composer bar, and the header stays identity */}
-            <Select
-              className="mode-select-wrap"
-              value={mode}
-              ariaLabel="Permission mode"
-              options={MODES.map((m) => ({ value: m.v, label: m.label, title: m.hint }))}
-              onChange={(v) => {
-                setMode(v as PermissionMode)
-                window.localStorage.setItem('cockpit:mode', v)
-              }}
+
+          {permissions.map((ask) => (
+            <PermissionAsk
+              key={ask.requestId}
+              ask={ask}
+              provider={binding.provider}
+              onAnswer={(optionId) => onAnswerPermission(ask, optionId)}
             />
-            {busy ? (
-              <button className="btn-danger" onClick={onCancel}>
-                Stop
-              </button>
+          ))}
+
+          <footer className="composer">
+            {binding.readOnly ? (
+              // roundtable seat-session: the table's round loop owns this conversation
+              <div className="composer-readonly">
+                Seat session of a roundtable — read-only. Talk to it at the table.
+              </div>
             ) : (
-              <button
-                className="btn-primary"
-                disabled={elsewhere || (!draft.trim() && atts.attachments.length === 0)}
-                title={elsewhere ? elsewhereHint : undefined}
-                onClick={submit}
-              >
-                Send
-              </button>
+              <>
+                <AttachRow atts={atts} />
+                <textarea
+                  ref={composerRef}
+                  aria-label={`Message ${PROVIDER_LABEL[binding.provider]}`}
+                  placeholder={`Message ${PROVIDER_LABEL[binding.provider]}…  (Enter to send, Shift+Enter for newline)`}
+                  value={draft}
+                  onChange={(e) => setDraft(e.target.value)}
+                  onPaste={atts.onPaste}
+                  onKeyDown={(e) => {
+                    if (e.key === 'Enter' && !e.shiftKey) {
+                      e.preventDefault()
+                      submit()
+                    }
+                  }}
+                />
+                {/* the mode governs the next turn, so it sits beside the button that sends
+                    it — the same grammar as Home's composer bar, and the header stays identity */}
+                <Select
+                  className="mode-select-wrap"
+                  value={mode}
+                  ariaLabel="Permission mode"
+                  options={MODES.map((m) => ({ value: m.v, label: m.label, title: m.hint }))}
+                  onChange={(v) => {
+                    setMode(v as PermissionMode)
+                    window.localStorage.setItem('cockpit:mode', v)
+                  }}
+                />
+                {busy ? (
+                  <button className="btn-danger" onClick={onCancel}>
+                    Stop
+                  </button>
+                ) : (
+                  <button
+                    className="btn-primary"
+                    disabled={elsewhere || (!draft.trim() && atts.attachments.length === 0)}
+                    title={elsewhere ? elsewhereHint : undefined}
+                    onClick={submit}
+                  >
+                    Send
+                  </button>
+                )}
+              </>
             )}
-          </>
+          </footer>
+        </div>
+        {work && model && (
+          <WorkPanel
+            model={model}
+            focus={work}
+            onTab={(tab) => setWork((w) => (w ? { ...w, tab, key: null } : w))}
+            onClose={closeWork}
+            cwd={binding.cwd}
+            provider={binding.provider}
+            pendingPlanKey={pendingPlanKey}
+            onOpenChanges={reviewable ? () => !review && toggleReview() : undefined}
+          />
         )}
-      </footer>
+      </div>
     </main>
   )
 }
 
+/** Where the Work key opens: a plan waiting on you, else the list under way, else the edits. */
+export function defaultTab(model: WorkModel, pendingPlanKey: number | null): WorkTab {
+  if (pendingPlanKey !== null) return 'plan'
+  if (model.todos.some((t) => t.status !== 'completed')) return 'todos'
+  if (model.files.length > 0) return 'edits'
+  if (model.plans.length > 0) return 'plan'
+  return 'todos'
+}
+
 
 /** A transcript row, or a folded run of consecutive tool rows. */
 type Row = { m: SessionMessage; key: number; result?: SessionMessage }
@@ -543,7 +645,9 @@ export function foldToolRuns(rows: readonly Row[], busy: boolean): Block[] {
     run = []
   }
   for (const row of rows) {
-    if ((row.m.kind === 'tool_call' || row.m.kind === 'tool_result') && !isPendingAsk(row)) run.push(row)
+    // a plan is a message of its own, like the agent's prose: it is never folded away
+    const foldable = !isPendingAsk(row) && row.m.artifact?.kind !== 'plan'
+    if ((row.m.kind === 'tool_call' || row.m.kind === 'tool_result') && foldable) run.push(row)
     else {
       flush(false)
       out.push({ kind: 'row', row })
@@ -575,11 +679,13 @@ export function runSummary(rows: readonly Row[]): string {
 function ToolRun({
   rows,
   provider,
-  cwd
+  cwd,
+  onOpenWork
 }: {
   rows: Row[]
   provider: Provider
   cwd: string
+  onOpenWork?: (key: number, tab: WorkTab) => void
 }): JSX.Element {
   return (
     <details className="tool-run">
@@ -592,13 +698,42 @@ function ToolRun({
       </summary>
       <div className="tool-run-rows">
         {rows.map((r) => (
-          <Message key={r.key} m={r.m} provider={provider} result={r.result} cwd={cwd} />
+          <Message
+            key={r.key}
+            m={r.m}
+            provider={provider}
+            result={r.result}
+            cwd={cwd}
+            workKey={r.key}
+            onOpenWork={onOpenWork}
+          />
         ))}
       </div>
     </details>
   )
 }
 
+/** A row's one-liner for what it hands the panel: the plan's title, where the list
+ *  stands, the task it adds, the files an edit touched. */
+function artifactHeadline(m: SessionMessage, cwd: string | undefined): string {
+  const a = m.artifact
+  if (!a) return m.preview ?? m.text
+  switch (a.kind) {
+    case 'plan':
+      return planTitle(a.text)
+    case 'todos': {
+      const done = a.items.filter((t) => t.status === 'completed').length
+      return a.items.length === 0 ? 'cleared the list' : `${done} of ${a.items.length} done`
+    }
+    case 'task-add':
+      return a.items.join(' · ')
+    case 'task-update':
+      return m.preview ?? `#${a.id}`
+    case 'edits':
+      return relative(a.files.map((f) => f.path).join(', '), cwd).slice(0, 120)
+  }
+}
+
 /** Paths inside the session's own directory read relative to it — the header already
  *  names the directory, so repeating it in every tool row only pushes the file off-screen. */
 function relative(text: string, cwd: string | undefined): string {
@@ -617,7 +752,9 @@ export const Message = memo(function Message({
   result,
   cwd,
   logKey,
-  anchored = false
+  anchored = false,
+  workKey,
+  onOpenWork
 }: {
   m: SessionMessage
   provider: Provider
@@ -629,8 +766,38 @@ export const Message = memo(function Message({
   logKey?: number
   /** The message a transcript search landed on — rings for a moment */
   anchored?: boolean
+  /** The row's log offset for the Work panel, where `logKey` is left off (a folded run) */
+  workKey?: number
+  /** Opens the Work panel at this row — a row carrying a plan, to-dos or an edit is
+   *  one click from it. Absent (a roundtable) keeps the ordinary tool row. */
+  onOpenWork?: (key: number, tab: WorkTab) => void
 }): JSX.Element {
   const ring = anchored ? ' anchored' : ''
+  const key = logKey ?? workKey
+  if (m.kind === 'tool_call' && m.artifact && onOpenWork && key !== undefined) {
+    const a = m.artifact
+    const headline = artifactHeadline(m, cwd)
+    return (
+      <button
+        className={`tool-row tool-open${ring}`}
+        data-log-key={logKey}
+        title="Open in the Work panel"
+        onClick={() => onOpenWork(key, tabFor(a))}
+      >
+        <span className="tool-chip">
+          <span aria-hidden="true">⚙︎ </span>
+          {m.toolName ?? 'tool'}
+        </span>
+        <code className="tool-preview">{headline}</code>
+        {a.kind === 'edits' && !m.failed && <DiffStat {...artifactStat(a)} />}
+        {m.failed && <span className="tool-failed">didn't apply</span>}
+        <span className="tool-open-go" aria-hidden="true">
+          <WorkIcon size={11} />
+        </span>
+        <span className="sr-only"> — open in the Work panel</span>
+      </button>
+    )
+  }
   if (m.kind === 'tool_call' || m.kind === 'tool_result') {
     const call = m.kind === 'tool_call'
     const peek = result ? firstLine(result.text) : ''
diff --git a/src/renderer/src/InstructionDiff.tsx b/src/renderer/src/InstructionDiff.tsx
index 7cc53e78..68b2cbda 100644
--- a/src/renderer/src/InstructionDiff.tsx
+++ b/src/renderer/src/InstructionDiff.tsx
@@ -143,7 +143,7 @@ export function InstructionDiff({
         <div className="idiff-body">
           {file.own.above > 0 && <Band n={file.own.above} />}
           <div className="idiff-rail">{START}</div>
-          <Lines lines={change.lines} layout={layout} />
+          <DiffLines lines={change.lines} layout={layout} />
           <div className="idiff-rail">{END}</div>
           {file.duplicates > 0 && <Dropped n={file.duplicates} />}
           {file.own.below > 0 && <Band n={file.own.below} />}
@@ -179,7 +179,8 @@ function Dropped({ n }: { n: number }): JSX.Element {
   )
 }
 
-function Lines({ lines, layout }: { lines: readonly DiffLine[]; layout: DiffLayout }): JSX.Element {
+/** Lines in GitHub's grammar with the quiet stretches folded — shared with the Work panel's edits. */
+export function DiffLines({ lines, layout }: { lines: readonly DiffLine[]; layout: DiffLayout }): JSX.Element {
   const rows = useMemo(() => foldUnchanged(lines), [lines])
   // fold rows are addressed by position: the rows are rebuilt whole whenever the
   // text changes, so an expansion only ever means "this row, in this diff"
diff --git a/src/renderer/src/WorkPanel.tsx b/src/renderer/src/WorkPanel.tsx
new file mode 100644
index 00000000..0f1123e4
--- /dev/null
+++ b/src/renderer/src/WorkPanel.tsx
@@ -0,0 +1,393 @@
+import { Fragment, useEffect, useLayoutEffect, useRef, useState, type JSX, type RefObject } from 'react'
+import type { FileEdit, Provider, TodoStatus } from '../../shared/types'
+import { DiffLines, DiffStat } from './InstructionDiff'
+import { PROVIDER_LABEL, TodoMark, XIcon } from './logos'
+import { Markdown } from './Markdown'
+import { TabList, type TabDef } from './Tabs'
+import { fmtTime, useTimeFormat } from './time'
+import { fileChange, todoSummary, type EditEntry, type FileWork, type WorkModel, type WorkTab } from './work'
+
+/**
+ * The Work panel: what the agent handed you to look at, beside the conversation —
+ * the plan it proposed, where its to-do list stands, and every edit it made, file by
+ * file. Built from the agents' own tool calls (`work.ts`), so it is what the agent
+ * *said*: the edits are each call's own description of its change, and **Changes**
+ * (the worktree's diff, ⌘D) stays the word on what is actually on disk.
+ *
+ * Opened from the header's Work key or from any row that carries one of these; a row
+ * opens the panel at itself — its plan version, or its file with the edit ringed.
+ */
+
+/** How long an edit a row opened the panel at stays ringed */
+const RING_MS = 2_000
+/** Up to this many files open expanded; past it they open on demand */
+const OPEN_FILES = 3
+
+const TODO_WORD: Record<TodoStatus, string> = {
+  pending: 'not started',
+  in_progress: 'in progress',
+  completed: 'done'
+}
+
+const CHANGE_WORD: Record<FileEdit['change'], string | null> = {
+  add: 'added',
+  write: 'written',
+  delete: 'deleted',
+  edit: null
+}
+
+/** A path under the session's directory reads relative to it, like the transcript's rows. */
+function relative(path: string, cwd: string): string {
+  return path.startsWith(`${cwd}/`) ? path.slice(cwd.length + 1) : path
+}
+
+export type WorkFocus = {
+  readonly tab: WorkTab
+  /** The transcript row that opened the panel, if one did */
+  readonly key: number | null
+  /** Bumped on every open, so opening the same row again scrolls to it again */
+  readonly at: number
+}
+
+export function WorkPanel({
+  model,
+  focus,
+  onTab,
+  onClose,
+  cwd,
+  provider,
+  pendingPlanKey,
+  onOpenChanges
+}: {
+  model: WorkModel
+  focus: WorkFocus
+  onTab: (tab: WorkTab) => void
+  onClose: () => void
+  cwd: string
+  provider: Provider
+  /** The plan row still waiting for the person's approval, if one is */
+  pendingPlanKey: number | null
+  /** Swap the transcript for the worktree's diff — absent where there is none */
+  onOpenChanges?: () => void
+}): JSX.Element {
+  const bodyRef = useRef<HTMLDivElement>(null)
+  const tabsRef = useRef<HTMLDivElement>(null)
+
+  // opening moves the reader in: the selected tab takes focus, so the keyboard is
+  // where the eyes went (and Escape is one key away)
+  useEffect(() => {
+    tabsRef.current?.querySelector<HTMLButtonElement>('[role=tab][aria-selected=true]')?.focus()
+  }, [focus.at])
+
+  // a tab is a fresh page: never entered half-scrolled because the one before was long
+  useLayoutEffect(() => {
+    if (bodyRef.current) bodyRef.current.scrollTop = 0
+  }, [focus.tab])
+
+  const openTodos = model.todos.filter((t) => t.status !== 'completed').length
+  const tabs: readonly TabDef<WorkTab>[] = [
+    { id: 'plan', label: 'Plan', dot: pendingPlanKey !== null },
+    { id: 'todos', label: 'To-dos', count: openTodos },
+    { id: 'edits', label: 'Edits', count: model.files.length }
+  ]
+
+  return (
+    <aside
+      id="work-panel"
+      className="work-panel"
+      aria-label="Work"
+      onKeyDown={(e) => {
+        if (e.key !== 'Escape') return
+        e.preventDefault()
+        onClose()
+      }}
+    >
+      <div className="work-head" ref={tabsRef}>
+        <TabList id="work" label="Work" tabs={tabs} selected={focus.tab} onSelect={onTab} />
+        <button className="icon-btn small work-close" aria-label="Close the Work panel" title="Close (Esc)" onClick={onClose}>
+          <XIcon />
+        </button>
+      </div>
+      <div
+        className="work-body"
+        ref={bodyRef}
+        role="tabpanel"
+        id={`work-panel-${focus.tab}`}
+        aria-labelledby={`work-tab-${focus.tab}`}
+        // the panel scrolls on its own: a keyboard reader must be able to reach it
+        tabIndex={0}
+      >
+        {focus.tab === 'plan' ? (
+          <PlanTab model={model} focus={focus} pendingPlanKey={pendingPlanKey} provider={provider} />
+        ) : focus.tab === 'todos' ? (
+          <TodosTab model={model} provider={provider} />
+        ) : (
+          <EditsTab model={model} focus={focus} cwd={cwd} scroller={bodyRef} onOpenChanges={onOpenChanges} />
+        )}
+      </div>
+    </aside>
+  )
+}
+
+function PlanTab({
+  model,
+  focus,
+  pendingPlanKey,
+  provider
+}: {
+  model: WorkModel
+  focus: WorkFocus
+  pendingPlanKey: number | null
+  provider: Provider
+}): JSX.Element {
+  const fmt = useTimeFormat()
+  const { plans } = model
+  // a row opens its own version of the plan; otherwise the latest is the one that counts
+  const [at, setAt] = useState(() => indexFor(plans, focus.key))
+  useEffect(() => setAt(indexFor(plans, focus.key)), [focus.at])
+  if (plans.length === 0) {
+    return (
+      <p className="work-empty">
+        No plan yet. When {PROVIDER_LABEL[provider]} proposes one in plan mode, it opens here to read before you
+        approve it.
+      </p>
+    )
+  }
+  const i = Math.min(at ?? plans.length - 1, plans.length - 1)
+  const plan = plans[i]!
+  const latest = i === plans.length - 1
+  return (
+    <>
+      <div className="work-meta">
+        {plans.length > 1 && (
+          <span className="work-versions" role="group" aria-label="Plan versions">
+            <button className="btn-ghost small" disabled={i === 0} onClick={() => setAt(i - 1)}>
+              Earlier
+            </button>
+            <span className="work-version">
+              version {i + 1} of {plans.length}
+            </span>
+            <button className="btn-ghost small" disabled={latest} onClick={() => setAt(i + 1)}>
+              Later
+            </button>
+          </span>
+        )}
+        {plan.ts && <span>proposed {fmtTime(plan.ts, fmt)}</span>}
+        {plan.key === pendingPlanKey && <span className="work-flag">waiting for your approval</span>}
+        {!latest && <span>a newer version follows</span>}
+      </div>
+      <div className="markdown work-plan">
+        <Markdown text={plan.text} />
+      </div>
+    </>
+  )
+}
+
+/** The plan a row points at, or null for "the latest". */
+function indexFor(plans: WorkModel['plans'], key: number | null): number | null {
+  const i = key === null ? -1 : plans.findIndex((p) => p.key === key)
+  return i < 0 ? null : i
+}
+
+function TodosTab({ model, provider }: { model: WorkModel; provider: Provider }): JSX.Element {
+  if (model.todosKey === null) {
+    return (
+      <p className="work-empty">
+        No to-do list yet. When {PROVIDER_LABEL[provider]} breaks its work into steps, they are kept here as it ticks
+        them off.
+      </p>
+    )
+  }
+  return (
+    <>
+      <div className="work-meta">
+        <span>{todoSummary(model.todos)}</span>
+      </div>
+      {model.todos.length > 0 && (
+        <ol className="work-todos">
+          {model.todos.map((t) => (
+            <li key={t.id} className={`work-todo ${t.status}`}>
+              <span className="work-todo-mark">
+                <TodoMark status={t.status} />
+              </span>
+              <span className="sr-only">{TODO_WORD[t.status]}: </span>
+              <span className="work-todo-text">{t.text}</span>
+            </li>
+          ))}
+        </ol>
+      )}
+    </>
+  )
+}
+
+function EditsTab({
+  model,
+  focus,
+  cwd,
+  scroller,
+  onOpenChanges
+}: {
+  model: WorkModel
+  focus: WorkFocus
+  cwd: string
+  scroller: RefObject<HTMLDivElement | null>
+  onOpenChanges?: () => void
+}): JSX.Element {
+  const { files } = model
+  const focusFile = focus.key === null ? undefined : files.find((f) => f.edits.some((e) => e.key === focus.key))
+  // what the person opened or closed; every other file follows the default — open while
+  // there are few enough to read at once, which holds for files that arrive mid-turn too
+  const [toggled, setToggled] = useState<ReadonlyMap<string, boolean>>(
+    () => new Map(focusFile ? [[focusFile.path, true]] : [])
+  )
+  const isOpen = (path: string): boolean => toggled.get(path) ?? files.length <= OPEN_FILES
+  const [ringed, setRinged] = useState<number | null>(null)
+
+  // a row opened the panel at its edit: open that file, bring the edit into view, ring it
+  useEffect(() => {
+    if (!focusFile || focus.key === null) return
+    setToggled((m) => (m.get(focusFile.path) ? m : new Map([...m, [focusFile.path, true]])))
+    setRinged(focus.key)
+  }, [focus.at])
+  useLayoutEffect(() => {
+    if (ringed === null) return
+    scroller.current?.querySelector(`[data-work-key="${ringed}"]`)?.scrollIntoView({ block: 'nearest' })
+    const t = setTimeout(() => setRinged(null), RING_MS)
+    return () => clearTimeout(t)
+  }, [ringed])
+
+  if (files.length === 0) {
+    return (
+      <p className="work-empty">
+        No edits yet. Each file the agent changes is listed here, with every change as its call described it.
+      </p>
+    )
+  }
+  const landed = files.reduce(
+    (sum, f) => ({ added: sum.added + f.added, removed: sum.removed + f.removed }),
+    { added: 0, removed: 0 }
+  )
+  return (
+    <>
+      <div className="work-meta">
+        <span>
+          {model.editCount === 1 ? '1 edit' : `${model.editCount} edits`} ·{' '}
+          {files.length === 1 ? '1 file' : `${files.length} files`}
+        </span>
+        <DiffStat added={landed.added} removed={landed.removed} />
+      </div>
+      <p className="work-note">
+        As the agent's calls described each change.
+        {onOpenChanges && (
+          <>
+            {' '}
+            <button className="link-btn" onClick={onOpenChanges}>
+              Changes
+            </button>{' '}
+            shows what is on disk.
+          </>
+        )}
+      </p>
+      <div className="idiff-list">
+        {files.map((f) => (
+          <FileBlock
+            key={f.path}
+            file={f}
+            cwd={cwd}
+            open={isOpen(f.path)}
+            ringed={ringed}
+            onToggle={(on) => {
+              // a details element reports its first paint too: only a change is a choice
+              if (on !== isOpen(f.path)) setToggled((m) => new Map([...m, [f.path, on]]))
+            }}
+          />
+        ))}
+      </div>
+    </>
+  )
+}
+
+function FileBlock({
+  file,
+  cwd,
+  open,
+  ringed,
+  onToggle
+}: {
+  file: FileWork
+  cwd: string
+  open: boolean
+  ringed: number | null
+  onToggle: (open: boolean) => void
+}): JSX.Element {
+  const shown = relative(file.path, cwd)
+  const moved = [...file.edits].reverse().find((e) => e.edit.movedTo)?.edit.movedTo
+  const kind = fileChange(file)
+  const failed = file.edits.every((e) => e.failed)
+  return (
+    <details className="idiff review-file work-file" open={open} onToggle={(e) => onToggle(e.currentTarget.open)}>
+      <summary className="idiff-head plain">
+        <span className="idiff-path">{moved ? `${shown} → ${relative(moved, cwd)}` : shown}</span>
+        {CHANGE_WORD[kind] && (
+          <span className={`review-kind ${kind === 'add' ? 'added' : kind === 'delete' ? 'deleted' : ''}`}>
+            {CHANGE_WORD[kind]}
+          </span>
+        )}
+        {failed && <span className="review-kind tone-warn">didn't apply</span>}
+        {file.edits.length > 1 && <span className="work-count">{file.edits.length} edits</span>}
+        <DiffStat added={file.added} removed={file.removed} />
+      </summary>
+      {open && (
+        <div className="idiff-body">
+          {file.edits.map((e, i) => (
+            <EditBlock key={`${e.key}-${i}`} entry={e} ringed={ringed === e.key} />
+          ))}
+        </div>
+      )}
+    </details>
+  )
+}
+
+/** What to say where a call named a file but carried no lines to draw. */
+function noLines(edit: FileEdit): string {
+  if (edit.change === 'delete') return 'the file was deleted'
+  if (edit.truncated) return 'too large to show here'
+  return 'the call named this file but not the lines it changed'
+}
+
+function EditBlock({ entry, ringed }: { entry: EditEntry; ringed: boolean }): JSX.Element {
+  const fmt = useTimeFormat()
+  const { edit } = entry
+  return (
+    <div className={`work-edit${entry.failed ? ' failed' : ''}${ringed ? ' ringed' : ''}`} data-work-key={entry.key}>
+      <div className="idiff-rail">
+        {entry.ts ? `${fmtTime(entry.ts, fmt)} · ` : ''}
+        {entry.toolName}
+        {entry.failed && <span className="work-failed">didn't apply</span>}
+      </div>
+      {edit.hunks.length === 0 ? (
+        <div className="idiff-band">
+          <span aria-hidden="true">⋯</span>
+          {noLines(edit)}
+        </div>
+      ) : (
+        edit.hunks.map((h, i) => (
+          <Fragment key={i}>
+            {i > 0 && (
+              <div className="idiff-band" aria-hidden="true">
+                ⋯
+              </div>
+            )}
+            <DiffLines lines={h} layout="unified" />
+          </Fragment>
+        ))
+      )}
+      {edit.truncated && edit.hunks.length > 0 && (
+        <div className="idiff-band">
+          <span aria-hidden="true">⋯</span>
+          the rest of this change is not shown
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/src/renderer/src/logos.tsx b/src/renderer/src/logos.tsx
index 8ee7cbfd..9ba0d79c 100644
--- a/src/renderer/src/logos.tsx
+++ b/src/renderer/src/logos.tsx
@@ -1,5 +1,5 @@
 import type { JSX } from 'react'
-import type { AttentionPr, Landing, PrChecks, PrReview, PrStatus, Provider } from '../../shared/types'
+import type { AttentionPr, Landing, PrChecks, PrReview, PrStatus, Provider, TodoStatus } from '../../shared/types'
 
 export const PROVIDER_LABEL: Record<Provider, string> = {
   claude: 'Claude',
@@ -286,6 +286,52 @@ export const CheckIcon = ({ size = 12 }: { size?: number }): JSX.Element => (
   <Octicon d={OCTICON_CHECK} size={size} />
 )
 
+/** GitHub's x on its own: closing a panel. */
+export const XIcon = ({ size = 12 }: { size?: number }): JSX.Element => (
+  <Octicon d={OCTICON_X} size={size} />
+)
+
+/** A checklist: the chat header's Work key — the agent's plan, to-dos and edits. */
+export const WorkIcon = ({ size = 12 }: { size?: number }): JSX.Element => (
+  <svg
+    width={size}
+    height={size}
+    viewBox="0 0 16 16"
+    fill="none"
+    stroke="currentColor"
+    strokeWidth="1.5"
+    strokeLinecap="round"
+    strokeLinejoin="round"
+    aria-hidden="true"
+  >
+    <path d="M1.75 3.5 3 4.75 5.25 2.5M1.75 10.5 3 11.75l2.25-2.25M7.75 3.75h6.5M7.75 8h6.5M7.75 12.25h6.5" />
+  </svg>
+)
+
+/**
+ * Where one to-do stands, as a shape, never only a colour: an empty ring (not
+ * started), a ring around a dot (under way), a ring around a check (done).
+ */
+export function TodoMark({ status, size = 12 }: { status: TodoStatus; size?: number }): JSX.Element {
+  return (
+    <svg
+      width={size}
+      height={size}
+      viewBox="0 0 16 16"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="1.5"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      aria-hidden="true"
+    >
+      <circle cx="8" cy="8" r="6.25" />
+      {status === 'in_progress' && <circle cx="8" cy="8" r="2.5" fill="currentColor" stroke="none" />}
+      {status === 'completed' && <path d="M5.25 8.25 7.1 10.1 10.75 6.25" />}
+    </svg>
+  )
+}
+
 /** The same question mark, on its own: the chat's card for a question awaiting a pick. */
 export const QuestionIcon = ({ size = 12 }: { size?: number }): JSX.Element => (
   <Octicon d={OCTICON_QUESTION} size={size} />
diff --git a/src/renderer/src/style.css b/src/renderer/src/style.css
index 4b19f7ed..90439df5 100644
--- a/src/renderer/src/style.css
+++ b/src/renderer/src/style.css
@@ -585,6 +585,8 @@ body.rail-dragging { cursor: col-resize; user-select: none; }
 .btn-handoff:disabled { opacity: 0.5; cursor: default; }
 /* the review toggle: an icon+word key that stays lit while the panel is open */
 .btn-review { display: inline-flex; align-items: center; gap: var(--s2); }
+/* the Work key is its mark at every width — the square the others fold to ≤780px */
+.btn-work { width: 28px; height: 28px; padding: 0; justify-content: center; }
 .btn-review:hover { color: var(--fg); border-color: var(--border-strong); }
 .btn-review[aria-pressed='true'] { color: var(--accent);
   background: rgba(var(--accent-rgb), 0.14); border-color: rgba(var(--accent-rgb), 0.5); }
@@ -1288,6 +1290,70 @@ body.rail-dragging { cursor: col-resize; user-select: none; }
 .review-thread-foot .link-btn { min-height: 24px; display: inline-flex; align-items: center;
   gap: 3px; }
 
+/* ---------- the Work panel: the agent's plan, to-dos and edits, beside the chat ----------
+   The deck under the header is a row: the conversation (`.chat-main`, everything that
+   used to stack in `.chat`) and, when open, the panel. It is a container, because what
+   decides whether the two fit side by side is the deck — the window less a dragged
+   rail — never the window; where they don't, the panel covers the conversation (the
+   `@container chat-deck` rule at the end of the file). */
+.chat-deck { flex: 1; min-height: 0; display: flex; position: relative;
+  container: chat-deck / inline-size; }
+.chat-main { flex: 1; min-width: 0; min-height: 0; display: flex; flex-direction: column; }
+.work-panel { flex: 0 0 clamp(300px, 38%, 460px); min-width: 0; min-height: 0;
+  display: flex; flex-direction: column; border-left: 1px solid var(--border);
+  background: var(--pane); }
+.work-head { display: flex; align-items: center; gap: var(--s2);
+  padding: var(--s3) var(--s3) var(--s3) var(--s4); border-bottom: 1px solid var(--border); }
+/* the card tabs' row, without the card's own rule under it — the head draws that */
+.work-head .pnl-tabs { flex: 1; min-width: 0; border-bottom: none; padding-bottom: 0; }
+.work-close { flex-shrink: 0; }
+.work-body { flex: 1; min-height: 0; overflow-y: auto; display: flex; flex-direction: column;
+  gap: var(--s4); padding: var(--s4); scrollbar-gutter: stable; }
+.work-body > * { flex-shrink: 0; }
+/* the readout over each tab: counts and times in the mono voice, the one state that
+   asks for the person in warn */
+.work-meta { display: flex; align-items: center; gap: var(--s3); flex-wrap: wrap;
+  min-height: 24px; color: var(--fg-dim); font-size: var(--fs-xs); font-family: var(--mono);
+  font-variant-numeric: tabular-nums; }
+.work-flag { color: var(--warn); }
+.work-versions { display: inline-flex; align-items: center; gap: var(--s2); }
+.work-note, .work-empty { margin: 0; color: var(--fg-dim); font-size: var(--fs-base);
+  line-height: 1.5; }
+.work-note .link-btn { font-size: inherit; }
+/* where the list stands: the mark's shape carries the state, the colour only repeats it */
+.work-todos { list-style: none; margin: 0; display: flex; flex-direction: column; gap: 2px; }
+.work-todo { display: flex; align-items: flex-start; gap: var(--s3); padding: var(--s2) var(--s3);
+  border-radius: var(--radius-sm); font-size: var(--fs-base); line-height: 1.45; }
+.work-todo-mark { display: inline-flex; flex-shrink: 0; margin-top: 2px; color: var(--fg-dim); }
+.work-todo-text { min-width: 0; overflow-wrap: anywhere; }
+.work-todo.in_progress { background: rgba(var(--accent-rgb), 0.12); }
+.work-todo.in_progress .work-todo-mark { color: var(--accent); }
+.work-todo.completed .work-todo-mark { color: var(--ok); }
+.work-todo.completed .work-todo-text { color: var(--fg-dim); }
+/* edits: the review's file blocks, one per file, each edit under its own rail */
+.work-count { color: var(--fg-dim); font-size: var(--fs-xs); white-space: nowrap; }
+.work-edit { transition: box-shadow var(--dur) var(--ease); }
+.work-edit + .work-edit { margin-top: var(--s3); }
+.work-edit.ringed { box-shadow: inset 0 0 0 2px rgba(var(--accent-rgb), 0.55); }
+.work-failed { margin-left: var(--s2); color: var(--warn); }
+
+/* a transcript row that opens the Work panel: the tool row's grammar as one button —
+   the blank lead keeps its chip in line with the ▸ of the rows around it */
+.tool-row.tool-open { display: flex; gap: var(--s2); align-items: baseline; min-height: 24px;
+  padding: 3px var(--s3); text-align: left; }
+.tool-open::before { content: ''; width: 10px; flex-shrink: 0; }
+.tool-open:hover { background: var(--bg3); }
+.tool-open .idiff-stat { flex-shrink: 0; }
+.tool-open-go { display: inline-flex; flex-shrink: 0; align-self: center; color: var(--fg-dim); }
+.tool-open:hover .tool-open-go { color: var(--accent); }
+.tool-failed { flex-shrink: 0; color: var(--warn); white-space: nowrap; }
+
+/* a plan waiting for approval is read in the card, above its two answers */
+.ask-plan { display: flex; flex-direction: column; align-items: flex-start; gap: var(--s2); }
+.ask-plan-body { align-self: stretch; max-height: 320px; overflow-y: auto;
+  padding: var(--s3) var(--s4); background: var(--bg-deep); border: 1px solid var(--border);
+  border-radius: var(--radius-sm); }
+
 .empty-chat { flex: 1; display: flex; flex-direction: column; align-items: center;
   justify-content: center; color: var(--fg-dim); gap: var(--s3); padding: var(--s5);
   text-align: center; }
@@ -2470,3 +2536,14 @@ button.pnl-flag:hover { text-decoration: underline; }
 @container chat-sub (max-width: 382px) {
   .parent-chip { display: none; }
 }
+
+/* ---------- the Work panel's room: asked of the deck ----------
+   Beside the conversation the panel takes its 300px floor, and the conversation needs
+   about 420px to stay a conversation — below that an assistant reply wraps every few
+   words and the composer's controls leave its row. So under 720px of deck (the 900px
+   window with the default rail is already under it) the panel covers the conversation
+   instead, the way Changes takes the transcript's place, and closing it gives it back. */
+@container chat-deck (max-width: 719px) {
+  .work-panel { position: absolute; inset: 0; z-index: 2; border-left: none;
+    background: var(--bg); }
+}
diff --git a/src/renderer/src/work.ts b/src/renderer/src/work.ts
new file mode 100644
index 00000000..7b3573d2
--- /dev/null
+++ b/src/renderer/src/work.ts
@@ -0,0 +1,208 @@
+import type { EditLine, FileEdit, SessionMessage, TodoStatus, WorkArtifact } from '../../shared/types'
+
+/**
+ * The Work panel's model: what the agent's own tool calls say about its work, folded
+ * over the whole transcript — the plan it last proposed, where its to-do list stands
+ * now, and every edit it made, file by file. Pure: ChatView builds it from the log
+ * on every render the panel is open, which is cheap (a pass over rows that already
+ * carry parsed artifacts; no diffing happens here — main did that).
+ *
+ * A row's `key` is its offset in the log, the same key the transcript renders it
+ * under, so a row can open the panel at itself.
+ */
+
+export type WorkTab = 'plan' | 'todos' | 'edits'
+
+export type PlanEntry = { readonly key: number; readonly text: string; readonly ts?: number }
+
+export type TodoEntry = { readonly id: string; readonly text: string; readonly status: TodoStatus }
+
+export type EditEntry = {
+  readonly key: number
+  readonly ts?: number
+  readonly toolName: string
+  readonly edit: FileEdit
+  /** The call's result was an error — the change never landed */
+  readonly failed: boolean
+  readonly added: number
+  readonly removed: number
+}
+
+export type FileWork = {
+  /** Absolute when the session's directory is known, so `a.ts` and `/repo/a.ts` are one file */
+  readonly path: string
+  readonly edits: readonly EditEntry[]
+  readonly added: number
+  readonly removed: number
+}
+
+export type WorkModel = {
+  /** Oldest first; the last is the plan that counts */
+  readonly plans: readonly PlanEntry[]
+  readonly todos: readonly TodoEntry[]
+  /** The row that last changed the list, null when nothing has */
+  readonly todosKey: number | null
+  /** In the order the agent first touched them */
+  readonly files: readonly FileWork[]
+  readonly editCount: number
+}
+
+export function lineStat(lines: readonly EditLine[]): { added: number; removed: number } {
+  let added = 0
+  let removed = 0
+  for (const l of lines) {
+    if (l.op === 'add') added++
+    else if (l.op === 'del') removed++
+  }
+  return { added, removed }
+}
+
+export function editStat(edit: FileEdit): { added: number; removed: number } {
+  let added = 0
+  let removed = 0
+  for (const h of edit.hunks) {
+    const s = lineStat(h)
+    added += s.added
+    removed += s.removed
+  }
+  return { added, removed }
+}
+
+/** Every file an edits artifact touched, summed — the row's `+3 −1`. */
+export function artifactStat(a: Extract<WorkArtifact, { kind: 'edits' }>): { added: number; removed: number } {
+  return a.files.reduce(
+    (sum, f) => {
+      const s = editStat(f)
+      return { added: sum.added + s.added, removed: sum.removed + s.removed }
+    },
+    { added: 0, removed: 0 }
+  )
+}
+
+/** A plan's headline: its first heading, else its first line, markdown marks stripped. */
+export function planTitle(text: string): string {
+  const lines = text.split('\n').map((l) => l.trim()).filter(Boolean)
+  const line = lines.find((l) => /^#{1,6}\s/.test(l)) ?? lines[0] ?? ''
+  return line.replace(/^#{1,6}\s+/, '').replace(/[*_`]/g, '').trim() || 'Plan'
+}
+
+/** `/repo` + `src/a.ts` → `/repo/src/a.ts`; an absolute path stays as it is. */
+export function absolutePath(path: string, cwd?: string): string {
+  if (!cwd || path.startsWith('/')) return path
+  return `${cwd.replace(/\/$/, '')}/${path.replace(/^\.\//, '')}`
+}
+
+/** Does any row carry something the panel shows? The header's Work key asks this. */
+export function hasWork(log: readonly SessionMessage[]): boolean {
+  return log.some((m) => m.kind === 'tool_call' && m.artifact !== undefined)
+}
+
+/** Which tab a row's artifact belongs on. */
+export function tabFor(a: WorkArtifact): WorkTab {
+  return a.kind === 'plan' ? 'plan' : a.kind === 'edits' ? 'edits' : 'todos'
+}
+
+export function buildWork(log: readonly SessionMessage[], cwd?: string): WorkModel {
+  const plans: PlanEntry[] = []
+  let todos: TodoEntry[] = []
+  let todosKey: number | null = null
+  const files = new Map<string, EditEntry[]>()
+  let editCount = 0
+  // Claude numbers tasks 1, 2, 3… — a create whose result was never read (the live
+  // stream carries no results) takes the next number after the highest seen
+  let nextTask = 1
+  const taskNo = (id: string): void => {
+    const n = Number(id)
+    if (Number.isInteger(n) && n >= nextTask) nextTask = n + 1
+  }
+
+  log.forEach((m, key) => {
+    const a = m.kind === 'tool_call' ? m.artifact : undefined
+    if (!a) return
+    switch (a.kind) {
+      case 'plan':
+        plans.push({ key, text: a.text, ...(m.ts ? { ts: m.ts } : {}) })
+        break
+      case 'todos':
+        todos = a.items.map((t, i) => ({ id: `step-${i + 1}`, text: t.text, status: t.status }))
+        todosKey = key
+        break
+      case 'task-add': {
+        if (m.failed) break
+        const ids = a.ids?.length === a.items.length ? a.ids : a.items.map(() => String(nextTask++))
+        a.items.forEach((text, i) => {
+          const id = ids[i]!
+          taskNo(id)
+          todos = [...todos.filter((t) => t.id !== id), { id, text, status: 'pending' }]
+        })
+        todosKey = key
+        break
+      }
+      case 'task-update': {
+        if (m.failed) break
+        const at = todos.findIndex((t) => t.id === a.id)
+        const { status, text } = a
+        if (status === 'deleted') {
+          if (at >= 0) todos = todos.filter((t) => t.id !== a.id)
+        } else if (at >= 0) {
+          todos = todos.map((t, i) =>
+            i === at ? { ...t, ...(status ? { status } : {}), ...(text ? { text } : {}) } : t
+          )
+        } else if (text) {
+          // created before the part of the log that was read — known by its update alone
+          taskNo(a.id)
+          todos = [...todos, { id: a.id, text, status: status ?? 'pending' }]
+        } else break
+        todosKey = key
+        break
+      }
+      case 'edits':
+        for (const edit of a.files) {
+          const path = absolutePath(edit.path, cwd)
+          const s = editStat(edit)
+          const entry: EditEntry = {
+            key,
+            ...(m.ts ? { ts: m.ts } : {}),
+            toolName: m.toolName ?? 'edit',
+            edit,
+            failed: m.failed === true,
+            ...s
+          }
+          files.set(path, [...(files.get(path) ?? []), entry])
+          editCount++
+        }
+        break
+    }
+  })
+
+  return {
+    plans,
+    todos,
+    todosKey,
+    files: [...files].map(([path, edits]) => {
+      const landed = edits.filter((e) => !e.failed)
+      return {
+        path,
+        edits,
+        added: landed.reduce((n, e) => n + e.added, 0),
+        removed: landed.reduce((n, e) => n + e.removed, 0)
+      }
+    }),
+    editCount
+  }
+}
+
+/** "3 of 7 done" — the list's state in the words the tab and the row both use. */
+export function todoSummary(todos: readonly TodoEntry[]): string {
+  const done = todos.filter((t) => t.status === 'completed').length
+  return todos.length === 0 ? 'no steps' : `${done} of ${todos.length} done`
+}
+
+/** What happened to a file across its edits: added, deleted, rewritten whole, or edited. */
+export function fileChange(file: FileWork): FileEdit['change'] {
+  const landed = file.edits.filter((e) => !e.failed)
+  const last = landed[landed.length - 1]?.edit.change
+  if (last === 'delete') return 'delete'
+  const first = landed[0]?.edit.change
+  return first === 'add' || first === 'write' ? first : 'edit'
+}
diff --git a/src/shared/types.ts b/src/shared/types.ts
index 1d4b6e0b..7e6df754 100644
--- a/src/shared/types.ts
+++ b/src/shared/types.ts
@@ -119,6 +119,55 @@ export type AskPrompt = {
   readonly options: readonly AskOption[]
 }
 
+/* ---------- work an agent reports: its plan, its to-dos, its edits ---------- */
+
+/** Where one step of an agent's to-do list stands, in the three words every CLI uses. */
+export type TodoStatus = 'pending' | 'in_progress' | 'completed'
+
+export type TodoItem = { readonly text: string; readonly status: TodoStatus }
+
+/** One line of an edit, GitHub's grammar: kept, added or removed. */
+export type EditLine = { readonly op: 'same' | 'add' | 'del'; readonly text: string }
+
+/** One file a tool call said it changed, as the call itself described the change. */
+export type FileEdit = {
+  readonly path: string
+  /** `write` replaced the whole file (Claude's Write — new or overwritten, the call can't say) */
+  readonly change: 'add' | 'edit' | 'write' | 'delete'
+  /** A patch that also renamed the file: where it went */
+  readonly movedTo?: string
+  /** One run of lines per place the call touched — an Edit's one replacement, a
+   *  patch's `@@` hunks. Empty when the call named the file but not the lines. */
+  readonly hunks: readonly (readonly EditLine[])[]
+  /** Lines were left out to keep the transcript bounded */
+  readonly truncated?: boolean
+}
+
+/**
+ * What a tool call hands the person to look at rather than a result to read: a plan
+ * to approve, a to-do list, an edit. Read off the call's input in main
+ * (`src/main/parsers/artifacts.ts`) so the chat can open it in the Work panel instead
+ * of showing 400 characters of JSON. `todos` is a whole list that replaces the last
+ * one; `task-add`/`task-update` are Claude's one-step-at-a-time task tools, which the
+ * renderer folds into the same list.
+ */
+export type WorkArtifact =
+  | { readonly kind: 'plan'; readonly text: string }
+  | { readonly kind: 'todos'; readonly items: readonly TodoItem[] }
+  | {
+      readonly kind: 'task-add'
+      readonly items: readonly string[]
+      /** The numbers the CLI gave them, once its result is read; absent mid-stream */
+      readonly ids?: readonly string[]
+    }
+  | {
+      readonly kind: 'task-update'
+      readonly id: string
+      readonly status?: TodoStatus | 'deleted'
+      readonly text?: string
+    }
+  | { readonly kind: 'edits'; readonly files: readonly FileEdit[] }
+
 export type SessionMessage = {
   readonly role: 'user' | 'assistant' | 'system' | 'tool'
   readonly kind: MessageKind
@@ -133,6 +182,11 @@ export type SessionMessage = {
    *  Unanswered (no tool_result folded onto the row) and last in the transcript,
    *  the chat renders it as an answerable card. */
   readonly asks?: readonly AskPrompt[]
+  /** A tool_call's plan, to-dos or edit, structured — see WorkArtifact */
+  readonly artifact?: WorkArtifact
+  /** A tool_call that did not do what it asked — its result was an error, or a patch
+   *  didn't apply. Set on the call's own row, matched to its result by id in main. */
+  readonly failed?: boolean
 }
 
 export type SourceDir = {
@@ -1099,6 +1153,8 @@ export type ChatEvent =
       readonly preview?: string
       /** The tool is a question waiting on the user — its options (see AskPrompt) */
       readonly asks?: readonly AskPrompt[]
+      /** The call's plan, to-dos or edit (see WorkArtifact) */
+      readonly artifact?: WorkArtifact
     }
   | { readonly turnId: string; readonly type: 'done'; readonly costUsd?: number }
   | { readonly turnId: string; readonly type: 'error'; readonly message: string }
diff --git a/tests/acp-core.test.ts b/tests/acp-core.test.ts
index 13078f5e..0dbdb58c 100644
--- a/tests/acp-core.test.ts
+++ b/tests/acp-core.test.ts
@@ -203,6 +203,60 @@ describe('acpUpdateToEvents', () => {
     ).toEqual([])
   })
 
+  it('turns a plan update into a row carrying the whole list', () => {
+    const [ev] = acpUpdateToEvents(
+      't1',
+      {
+        sessionUpdate: 'plan',
+        entries: [
+          { content: 'Read the parser', status: 'completed', priority: 'high' },
+          { content: 'Fix it', status: 'in_progress', priority: 'high' }
+        ]
+      },
+      seen()
+    ) as [Extract<ChatEvent, { type: 'tool' }>]
+    expect(ev).toMatchObject({
+      toolName: 'plan',
+      preview: '2 steps',
+      artifact: {
+        kind: 'todos',
+        items: [
+          { text: 'Read the parser', status: 'completed' },
+          { text: 'Fix it', status: 'in_progress' }
+        ]
+      }
+    })
+  })
+
+  it('carries the diff a call is announced with', () => {
+    const [ev] = acpUpdateToEvents(
+      't1',
+      {
+        sessionUpdate: 'tool_call',
+        toolCallId: 'c1',
+        title: 'Edit src/a.ts',
+        kind: 'edit',
+        content: [{ type: 'diff', path: '/r/src/a.ts', oldText: 'a\n', newText: 'b\n' }]
+      },
+      seen()
+    ) as [Extract<ChatEvent, { type: 'tool' }>]
+    expect(ev.artifact).toEqual({
+      kind: 'edits',
+      files: [
+        {
+          path: '/r/src/a.ts',
+          change: 'edit',
+          hunks: [
+            [
+              { op: 'del', text: 'a' },
+              { op: 'add', text: 'b' }
+            ]
+          ]
+        }
+      ]
+    })
+  })
+
   it('ignores the updates Cockpit has nowhere to put, and anything unrecognised', () => {
     for (const u of [
       { sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: 'hmm' } },
diff --git a/tests/artifacts.test.ts b/tests/artifacts.test.ts
new file mode 100644
index 00000000..ac79b519
--- /dev/null
+++ b/tests/artifacts.test.ts
@@ -0,0 +1,399 @@
+import { describe, expect, it } from 'vitest'
+import {
+  acpDiffArtifact,
+  acpPlanArtifact,
+  fileChangeArtifact,
+  pairHunks,
+  parsePatch,
+  parseUnifiedDiff,
+  todoListArtifact,
+  todoStatus,
+  toolArtifact
+} from '../src/main/parsers/artifacts'
+import type { FileEdit, WorkArtifact } from '../src/shared/types'
+
+/** The one file an edits artifact carries — every case below touches exactly one. */
+function only(a: WorkArtifact | undefined): FileEdit {
+  expect(a?.kind).toBe('edits')
+  const files = (a as Extract<WorkArtifact, { kind: 'edits' }>).files
+  expect(files).toHaveLength(1)
+  return files[0]!
+}
+
+describe('toolArtifact: plans', () => {
+  it("reads Claude's plan and Copilot's summary as the plan", () => {
+    expect(toolArtifact('ExitPlanMode', { plan: '# Add rate limiting\n\n1. token bucket', planFilePath: '/p.md' })).toEqual({
+      kind: 'plan',
+      text: '# Add rate limiting\n\n1. token bucket'
+    })
+    expect(toolArtifact('exit_plan_mode', { summary: '**Approach:** one layer', recommendedAction: 'autopilot' })).toEqual({
+      kind: 'plan',
+      text: '**Approach:** one layer'
+    })
+  })
+
+  it('a plan call with no words is no plan', () => {
+    expect(toolArtifact('ExitPlanMode', {})).toBeUndefined()
+    expect(toolArtifact('ExitPlanMode', { plan: '   ' })).toBeUndefined()
+    expect(toolArtifact('exit_plan_mode', null)).toBeUndefined()
+  })
+})
+
+describe('toolArtifact: to-do lists', () => {
+  it("reads Claude's TodoWrite and Codex's update_plan as whole lists", () => {
+    expect(
+      toolArtifact('TodoWrite', {
+        todos: [
+          { content: 'Read the parser', status: 'completed', activeForm: 'Reading the parser' },
+          { content: 'Write the test', status: 'in_progress', activeForm: 'Writing the test' },
+          { content: 'Ship it', status: 'pending', activeForm: 'Shipping it' }
+        ]
+      })
+    ).toEqual({
+      kind: 'todos',
+      items: [
+        { text: 'Read the parser', status: 'completed' },
+        { text: 'Write the test', status: 'in_progress' },
+        { text: 'Ship it', status: 'pending' }
+      ]
+    })
+    expect(
+      toolArtifact('update_plan', {
+        explanation: 'narrowing down',
+        plan: [
+          { step: 'Reproduce', status: 'completed' },
+          { step: 'Fix', status: 'in_progress' }
+        ]
+      })
+    ).toEqual({
+      kind: 'todos',
+      items: [
+        { text: 'Reproduce', status: 'completed' },
+        { text: 'Fix', status: 'in_progress' }
+      ]
+    })
+  })
+
+  it("reads Claude's task tools one step at a time", () => {
+    expect(toolArtifact('TaskCreate', { subject: 'Wire the panel', description: 'd', activeForm: 'Wiring' })).toEqual({
+      kind: 'task-add',
+      items: ['Wire the panel']
+    })
+    expect(toolArtifact('TaskCreate', { tasks: [{ subject: 'One' }, { subject: 'Two' }, {}] })).toEqual({
+      kind: 'task-add',
+      items: ['One', 'Two']
+    })
+    expect(toolArtifact('TaskUpdate', { taskId: '3', status: 'in_progress' })).toEqual({
+      kind: 'task-update',
+      id: '3',
+      status: 'in_progress'
+    })
+    expect(toolArtifact('TaskUpdate', { taskId: 4, status: 'deleted' })).toEqual({
+      kind: 'task-update',
+      id: '4',
+      status: 'deleted'
+    })
+    expect(toolArtifact('TaskUpdate', { status: 'completed' })).toBeUndefined()
+  })
+
+  it('folds every CLI’s status words onto three, and anything unknown to not started', () => {
+    expect(todoStatus('completed')).toBe('completed')
+    expect(todoStatus('done')).toBe('completed')
+    expect(todoStatus('in-progress')).toBe('in_progress')
+    expect(todoStatus('IN_PROGRESS')).toBe('in_progress')
+    expect(todoStatus('blocked')).toBe('pending')
+    expect(todoStatus(undefined)).toBe('pending')
+  })
+
+  it('skips steps with no words and keeps a list bounded', () => {
+    const a = toolArtifact('update_plan', {
+      plan: [{ step: '' }, { step: 'Real' }, 'not a step', ...Array.from({ length: 100 }, (_, i) => ({ step: `s${i}` }))]
+    })
+    expect(a?.kind).toBe('todos')
+    const items = (a as Extract<WorkArtifact, { kind: 'todos' }>).items
+    expect(items[0]).toEqual({ text: 'Real', status: 'pending' })
+    expect(items).toHaveLength(60)
+  })
+
+  it("reads Codex's todo_list stream item and ACP's plan entries", () => {
+    expect(todoListArtifact([{ text: 'a', completed: true }, { text: 'b', completed: false }])).toEqual({
+      kind: 'todos',
+      items: [
+        { text: 'a', status: 'completed' },
+        { text: 'b', status: 'pending' }
+      ]
+    })
+    expect(acpPlanArtifact([{ content: 'Plan it', status: 'in_progress', priority: 'high' }])).toEqual({
+      kind: 'todos',
+      items: [{ text: 'Plan it', status: 'in_progress' }]
+    })
+    expect(acpPlanArtifact('nope')).toBeUndefined()
+  })
+})
+
+describe('toolArtifact: edits', () => {
+  it("a Claude Edit is its replacement, diffed, with the lines it didn't change as context", () => {
+    const f = only(
+      toolArtifact('Edit', {
+        file_path: '/repo/src/a.ts',
+        old_string: 'const a = 1\nconst b = 2\n',
+        new_string: 'const a = 1\nconst b = 3\n',
+        replace_all: false
+      })
+    )
+    expect(f).toEqual({
+      path: '/repo/src/a.ts',
+      change: 'edit',
+      hunks: [
+        [
+          { op: 'same', text: 'const a = 1' },
+          { op: 'del', text: 'const b = 2' },
+          { op: 'add', text: 'const b = 3' }
+        ]
+      ]
+    })
+  })
+
+  it('keeps the indentation a trimmed split would lose', () => {
+    const f = only(toolArtifact('Edit', { file_path: 'a.py', old_string: '    return 1', new_string: '    return 2' }))
+    expect(f.hunks[0]).toEqual([
+      { op: 'del', text: '    return 1' },
+      { op: 'add', text: '    return 2' }
+    ])
+  })
+
+  it('a MultiEdit is one file with a hunk per replacement', () => {
+    const f = only(
+      toolArtifact('MultiEdit', {
+        file_path: '/r/a.ts',
+        edits: [
+          { old_string: 'x', new_string: 'y' },
+          { old_string: 'p', new_string: 'q' },
+          { old_string: 7, new_string: 'ignored' }
+        ]
+      })
+    )
+    expect(f.hunks).toHaveLength(2)
+  })
+
+  it("a Write is the whole file, added — the call can't say whether it existed", () => {
+    const f = only(toolArtifact('Write', { file_path: '/r/new.md', content: '# Title\n\nbody\n' }))
+    expect(f.change).toBe('write')
+    expect(f.hunks).toEqual([
+      [
+        { op: 'add', text: '# Title' },
+        { op: 'add', text: '' },
+        { op: 'add', text: 'body' }
+      ]
+    ])
+  })
+
+  it("reads Copilot's edit and create", () => {
+    expect(only(toolArtifact('edit', { path: '/r/a.ts', old_str: 'a', new_str: 'b' })).hunks).toEqual([
+      [
+        { op: 'del', text: 'a' },
+        { op: 'add', text: 'b' }
+      ]
+    ])
+    expect(only(toolArtifact('create', { path: '/r/b.ts', file_text: 'x\n' })).change).toBe('add')
+    // an edit that names no file is nothing the panel can place
+    expect(toolArtifact('edit', { old_str: 'a', new_str: 'b' })).toBeUndefined()
+  })
+
+  it('cuts a huge write to the file budget and says so', () => {
+    const content = Array.from({ length: 1000 }, (_, i) => `line ${i}`).join('\n')
+    const f = only(toolArtifact('Write', { file_path: '/r/big.txt', content }))
+    expect(f.hunks.flat()).toHaveLength(400)
+    expect(f.truncated).toBe(true)
+  })
+
+  it('cuts a minified line to a readable width', () => {
+    const f = only(toolArtifact('Write', { file_path: '/r/min.js', content: 'x'.repeat(5000) }))
+    expect(f.hunks[0]![0]!.text.length).toBeLessThanOrEqual(400)
+  })
+
+  it('ordinary tools and unknown names carry nothing', () => {
+    expect(toolArtifact('Bash', { command: 'ls' })).toBeUndefined()
+    expect(toolArtifact('Read', { file_path: '/r/a' })).toBeUndefined()
+    expect(toolArtifact('whatever', { plan: 'x' })).toBeUndefined()
+  })
+})
+
+const PATCH = [
+  '*** Begin Patch',
+  '*** Add File: docs/new.md',
+  '+# New',
+  '+',
+  '+text',
+  '*** Update File: src/a.ts',
+  '*** Move to: src/b.ts',
+  '@@ function f() {',
+  ' const a = 1',
+  '-const b = 2',
+  '+const b = 3',
+  '@@',
+  '-old tail',
+  '+new tail',
+  '*** Delete File: src/gone.ts',
+  '*** End Patch',
+  ''
+].join('\n')
+
+describe('parsePatch', () => {
+  it('reads every file of a patch, its hunks, a rename and a deletion', () => {
+    expect(parsePatch(PATCH)).toEqual([
+      {
+        path: 'docs/new.md',
+        change: 'add',
+        hunks: [
+          [
+            { op: 'add', text: '# New' },
+            { op: 'add', text: '' },
+            { op: 'add', text: 'text' }
+          ]
+        ]
+      },
+      {
+        path: 'src/a.ts',
+        change: 'edit',
+        movedTo: 'src/b.ts',
+        hunks: [
+          [
+            { op: 'same', text: 'const a = 1' },
+            { op: 'del', text: 'const b = 2' },
+            { op: 'add', text: 'const b = 3' }
+          ],
+          [
+            { op: 'del', text: 'old tail' },
+            { op: 'add', text: 'new tail' }
+          ]
+        ]
+      },
+      { path: 'src/gone.ts', change: 'delete', hunks: [] }
+    ])
+  })
+
+  it('is what apply_patch carries, bare (Copilot, Codex freeform) or under input (Codex function)', () => {
+    const bare = toolArtifact('apply_patch', PATCH)
+    const wrapped = toolArtifact('apply_patch', { input: PATCH })
+    expect(bare).toEqual(wrapped)
+    expect(bare?.kind === 'edits' && bare.files.map((f) => f.path)).toEqual(['docs/new.md', 'src/a.ts', 'src/gone.ts'])
+  })
+
+  it('finds a patch run as a shell command, as older Codex did', () => {
+    const a = toolArtifact('shell', { command: ['apply_patch', PATCH] })
+    expect(a?.kind).toBe('edits')
+    const heredoc = toolArtifact('exec_command', { cmd: `apply_patch <<'EOF'\n${PATCH}EOF` })
+    expect(heredoc?.kind).toBe('edits')
+    expect(toolArtifact('shell', { command: ['bash', '-lc', 'npm test'] })).toBeUndefined()
+  })
+
+  it('text that is not a patch is no edit', () => {
+    expect(toolArtifact('apply_patch', 'just words')).toBeUndefined()
+    expect(parsePatch('*** Begin Patch\n*** End Patch')).toEqual([])
+  })
+})
+
+describe('parseUnifiedDiff', () => {
+  it('reads the hunks and skips the headers and no-newline notes', () => {
+    expect(
+      parseUnifiedDiff(
+        ['--- a/x', '+++ b/x', '@@ -1,2 +1,2 @@', ' keep', '-old', '+new', '\\ No newline at end of file', '@@ -9 +9 @@', '-z'].join(
+          '\n'
+        )
+      )
+    ).toEqual([
+      [
+        { op: 'same', text: 'keep' },
+        { op: 'del', text: 'old' },
+        { op: 'add', text: 'new' }
+      ],
+      [{ op: 'del', text: 'z' }]
+    ])
+  })
+})
+
+describe('fileChangeArtifact', () => {
+  it("reads a rollout's FileChange map: content for an add, a unified diff for an update", () => {
+    const a = fileChangeArtifact({
+      '/r/new.ts': { type: 'add', content: 'export {}\n' },
+      '/r/old.ts': { type: 'update', unified_diff: '@@ -1 +1 @@\n-a\n+b\n', move_path: '/r/moved.ts' },
+      '/r/gone.ts': { type: 'delete' }
+    })
+    expect(a).toEqual({
+      kind: 'edits',
+      files: [
+        { path: '/r/new.ts', change: 'add', hunks: [[{ op: 'add', text: 'export {}' }]] },
+        {
+          path: '/r/old.ts',
+          change: 'edit',
+          movedTo: '/r/moved.ts',
+          hunks: [
+            [
+              { op: 'del', text: 'a' },
+              { op: 'add', text: 'b' }
+            ]
+          ]
+        },
+        { path: '/r/gone.ts', change: 'delete', hunks: [] }
+      ]
+    })
+  })
+
+  it("reads the exec stream's list, which names files but never lines", () => {
+    expect(
+      fileChangeArtifact([
+        { path: 'a.ts', kind: 'update' },
+        { path: 'b.ts', kind: 'add' },
+        { kind: 'add' }
+      ])
+    ).toEqual({
+      kind: 'edits',
+      files: [
+        { path: 'a.ts', change: 'edit', hunks: [] },
+        { path: 'b.ts', change: 'add', hunks: [] }
+      ]
+    })
+    expect(fileChangeArtifact(null)).toBeUndefined()
+  })
+})
+
+describe('pairHunks and ACP diffs', () => {
+  it('keeps three lines of context around each change and drops the rest of a whole file', () => {
+    const before = Array.from({ length: 40 }, (_, i) => `line ${i}`)
+    const after = [...before]
+    after[5] = 'changed 5'
+    after[30] = 'changed 30'
+    const { hunks, cut } = pairHunks(before.join('\n'), after.join('\n'))
+    expect(cut).toBe(false)
+    expect(hunks).toHaveLength(2)
+    expect(hunks[0]!.filter((l) => l.op === 'same')).toHaveLength(6)
+    expect(hunks[0]![0]).toEqual({ op: 'same', text: 'line 2' })
+  })
+
+  it('reads ACP diff content blocks; no old text is a new file', () => {
+    const a = acpDiffArtifact([
+      { type: 'content', content: { type: 'text', text: 'hi' } },
+      { type: 'diff', path: '/r/a.ts', oldText: 'x\ny\n', newText: 'x\nz\n' },
+      { type: 'diff', path: '/r/b.ts', oldText: null, newText: 'new\n' }
+    ])
+    expect(a).toEqual({
+      kind: 'edits',
+      files: [
+        {
+          path: '/r/a.ts',
+          change: 'edit',
+          hunks: [
+            [
+              { op: 'same', text: 'x' },
+              { op: 'del', text: 'y' },
+              { op: 'add', text: 'z' }
+            ]
+          ]
+        },
+        { path: '/r/b.ts', change: 'add', hunks: [[{ op: 'add', text: 'new' }]] }
+      ]
+    })
+    expect(acpDiffArtifact([{ type: 'content' }])).toBeUndefined()
+  })
+})
diff --git a/tests/chat.test.ts b/tests/chat.test.ts
index 65031249..3a03f373 100644
--- a/tests/chat.test.ts
+++ b/tests/chat.test.ts
@@ -178,6 +178,20 @@ describe('parseClaudeStreamLine', () => {
     })
     expect(mcp.type === 'tool' && mcp.preview).toBeFalsy()
   })
+  it('carries a plan or an edit whole, where the detail is cut to 200 characters', () => {
+    const plan = '# Plan\n\n' + 'step. '.repeat(100)
+    const [ev] = parseClaudeStreamLine('t', {
+      type: 'assistant',
+      message: { content: [{ type: 'tool_use', name: 'ExitPlanMode', input: { plan } }] }
+    })
+    expect(ev).toMatchObject({ type: 'tool', artifact: { kind: 'plan', text: plan.trim() } })
+    if (ev.type === 'tool') expect(ev.asks?.length).toBe(1)
+    const [edit] = parseClaudeStreamLine('t', {
+      type: 'assistant',
+      message: { content: [{ type: 'tool_use', name: 'Edit', input: { file_path: '/r/a.ts', old_string: 'x', new_string: 'y' } }] }
+    })
+    expect(edit).toMatchObject({ type: 'tool', artifact: { kind: 'edits', files: [{ path: '/r/a.ts' }] } })
+  })
   it('result emits done with cost', () => {
     const ev = parseClaudeStreamLine('t', { type: 'result', session_id: 's1', total_cost_usd: 0.12 })
     expect(ev.find((e) => e.type === 'done')).toMatchObject({ costUsd: 0.12 })
@@ -232,10 +246,31 @@ describe('parseCodexStreamLine', () => {
       type: 'item.completed',
       item: { type: 'file_change', changes: [{ path: 'src/a.ts', kind: 'update' }, { path: 'src/b.ts', kind: 'add' }] }
     })
-    expect(edit).toMatchObject({ type: 'tool', toolName: 'edit', preview: 'src/a.ts, src/b.ts' })
+    // named as the rollout's FileChange row is, so a rejoined turn matches the two
+    expect(edit).toMatchObject({ type: 'tool', toolName: 'apply_patch', preview: 'apply_patch src/a.ts, src/b.ts' })
     const [old] = parseCodexStreamLine('t', { msg: { type: 'exec_command_begin', command: ['bash', '-lc', 'npm test'] } })
     expect(old).toMatchObject({ type: 'tool', preview: 'npm test' })
   })
+  it('carries what the Work panel shows: a file change names its files, a todo list is the plan', () => {
+    const [edit] = parseCodexStreamLine('t', {
+      type: 'item.completed',
+      item: { type: 'file_change', changes: [{ path: 'src/a.ts', kind: 'update' }] }
+    })
+    expect(edit).toMatchObject({
+      type: 'tool',
+      artifact: { kind: 'edits', files: [{ path: 'src/a.ts', change: 'edit', hunks: [] }] }
+    })
+    const [plan] = parseCodexStreamLine('t', {
+      type: 'item.completed',
+      item: { type: 'todo_list', items: [{ text: 'Read', completed: true }, { text: 'Write', completed: false }] }
+    })
+    expect(plan).toMatchObject({
+      type: 'tool',
+      toolName: 'update_plan',
+      preview: '2 steps',
+      artifact: { kind: 'todos', items: [{ text: 'Read', status: 'completed' }, { text: 'Write', status: 'pending' }] }
+    })
+  })
 })
 
 describe('thinking level, speed and context', () => {
diff --git a/tests/component/work-panel.test.tsx b/tests/component/work-panel.test.tsx
new file mode 100644
index 00000000..a184f068
--- /dev/null
+++ b/tests/component/work-panel.test.tsx
@@ -0,0 +1,187 @@
+import { describe, it, expect, vi } from 'vitest'
+import { fireEvent, render, screen, within } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { ChatView, foldToolRuns } from '../../src/renderer/src/ChatView'
+import { setChatLog } from '../../src/renderer/src/chat-log'
+import type { ChatBinding } from '../../src/renderer/src/chat-binding'
+import type { SessionMessage, WorkArtifact } from '../../src/shared/types'
+import { parseAsks } from '../../src/shared/asks'
+
+const binding: ChatBinding = {
+  provider: 'claude',
+  cwd: '/tmp/wt',
+  nativeSessionId: 'abc',
+  title: 'fix the flake',
+  branch: 'cockpit/fix',
+  repoRoot: '/tmp/repo'
+}
+
+const say = (text: string): SessionMessage => ({ role: 'assistant', kind: 'text', text })
+const user = (text: string): SessionMessage => ({ role: 'user', kind: 'text', text })
+const call = (toolName: string, artifact: WorkArtifact, extra: Partial<SessionMessage> = {}): SessionMessage => ({
+  role: 'assistant',
+  kind: 'tool_call',
+  toolName,
+  text: '{}',
+  artifact,
+  ...extra
+})
+const edit = (path: string): WorkArtifact => ({
+  kind: 'edits',
+  files: [
+    {
+      path,
+      change: 'edit',
+      hunks: [
+        [
+          { op: 'same', text: 'const a = 1' },
+          { op: 'del', text: 'const b = 2' },
+          { op: 'add', text: 'const b = 3' }
+        ]
+      ]
+    }
+  ]
+})
+const PLAN = '# Add rate limiting\n\n1. A token bucket per key'
+
+function renderChat(log: SessionMessage[], over: Partial<ChatBinding> = {}): void {
+  setChatLog(log)
+  render(
+    <ChatView
+      binding={{ ...binding, ...over }}
+      prs={[]}
+      busy={false}
+      elsewhere={false}
+      prBusy={false}
+      onSend={vi.fn()}
+      onCancel={vi.fn()}
+      onCreatePr={vi.fn()}
+      onOpenUrl={vi.fn()}
+      onOpenHandoff={vi.fn()}
+      onOpenLineage={vi.fn()}
+      permissions={[]}
+      onAnswerPermission={vi.fn()}
+    />
+  )
+}
+
+const panel = (): HTMLElement => screen.getByRole('complementary', { name: 'Work' })
+
+describe('the Work key', () => {
+  it('is offered only once the transcript holds a plan, a to-do list or an edit', () => {
+    renderChat([user('hi'), say('hello'), { role: 'assistant', kind: 'tool_call', toolName: 'Bash', text: 'ls' }])
+    expect(screen.queryByRole('button', { name: 'Work' })).not.toBeInTheDocument()
+    fireEvent.keyDown(window, { key: 'j', metaKey: true })
+    expect(screen.queryByRole('complementary', { name: 'Work' })).not.toBeInTheDocument()
+  })
+
+  it('opens beside the transcript on the list under way, and closes by key, ⌘J and Escape', async () => {
+    renderChat([
+      user('fix it'),
+      call('TodoWrite', {
+        kind: 'todos',
+        items: [
+          { text: 'Reproduce', status: 'completed' },
+          { text: 'Fix the parser', status: 'in_progress' }
+        ]
+      }),
+      call('Edit', edit('/tmp/wt/src/a.ts'))
+    ])
+    await userEvent.click(screen.getByRole('button', { name: 'Work' }))
+    expect(screen.getByRole('button', { name: 'Work' })).toHaveAttribute('aria-pressed', 'true')
+    expect(within(panel()).getByRole('tab', { name: /To-dos/ })).toHaveAttribute('aria-selected', 'true')
+    expect(within(panel()).getByText('1 of 2 done')).toBeInTheDocument()
+    // the state rides a word, never the mark's colour alone
+    expect(within(panel()).getByText('in progress:')).toBeInTheDocument()
+    // the transcript stays: the panel is beside it, not instead of it
+    expect(screen.getByText('fix it')).toBeInTheDocument()
+
+    fireEvent.keyDown(window, { key: 'j', metaKey: true })
+    expect(screen.queryByRole('complementary', { name: 'Work' })).not.toBeInTheDocument()
+    fireEvent.keyDown(window, { key: 'j', metaKey: true })
+    fireEvent.keyDown(panel(), { key: 'Escape' })
+    expect(screen.queryByRole('complementary', { name: 'Work' })).not.toBeInTheDocument()
+  })
+})
+
+describe('a row that carries work', () => {
+  it('is one click from its edit: the panel opens on Edits with that file open', async () => {
+    renderChat([user('fix it'), call('Edit', edit('/tmp/wt/src/a.ts'), { preview: '/tmp/wt/src/a.ts' })])
+    const row = screen.getByRole('button', { name: /src\/a\.ts.*open in the Work panel/ })
+    // the row says what changed before it is opened
+    expect(within(row).getByText('+1')).toBeInTheDocument()
+    await userEvent.click(row)
+    expect(within(panel()).getByRole('tab', { name: /Edits/ })).toHaveAttribute('aria-selected', 'true')
+    expect(within(panel()).getByText('src/a.ts')).toBeInTheDocument()
+    expect(within(panel()).getByText('const b = 3')).toBeInTheDocument()
+
+    fireEvent.keyDown(panel(), { key: 'Escape' })
+    // closing hands focus back to the row that opened it
+    expect(screen.getByRole('button', { name: /src\/a\.ts.*open in the Work panel/ })).toHaveFocus()
+  })
+
+  it('says when an edit never landed', async () => {
+    renderChat([user('fix it'), call('Edit', edit('/tmp/wt/src/a.ts'), { failed: true })])
+    const row = screen.getByRole('button', { name: /open in the Work panel/ })
+    expect(within(row).getByText("didn't apply")).toBeInTheDocument()
+    await userEvent.click(row)
+    expect(within(panel()).getAllByText("didn't apply").length).toBeGreaterThan(0)
+  })
+
+  it('keeps an ordinary tool row for everything else', () => {
+    renderChat([user('go'), { role: 'assistant', kind: 'tool_call', toolName: 'Bash', text: 'ls', preview: 'ls' }])
+    expect(screen.queryByRole('button', { name: /open in the Work panel/ })).not.toBeInTheDocument()
+    // the collapsed ⚙︎ row: headline in the summary, raw input behind it
+    expect(document.querySelector('details.tool-row')).toBeInTheDocument()
+  })
+
+  it('never folds a plan into a run of tool rows', () => {
+    const tool = (i: number): SessionMessage => ({ role: 'assistant', kind: 'tool_call', toolName: 'Bash', text: `s${i}` })
+    const rows = [tool(0), tool(1), call('ExitPlanMode', { kind: 'plan', text: PLAN }), tool(2), tool(3)].map((m, key) => ({ m, key }))
+    expect(foldToolRuns(rows, false).map((b) => b.kind)).toEqual(['row', 'row', 'row', 'row', 'row'])
+  })
+})
+
+describe('a plan waiting for approval', () => {
+  const pending = (): SessionMessage[] => [
+    user('plan it'),
+    call('ExitPlanMode', { kind: 'plan', text: PLAN }, { asks: parseAsks('ExitPlanMode', { plan: PLAN }) })
+  ]
+
+  it('is read in the approval card, above its two answers', async () => {
+    renderChat(pending())
+    const card = screen.getByRole('region', { name: 'Claude is asking you' })
+    const plan = within(card).getByRole('region', { name: 'The plan' })
+    expect(await within(plan).findByText(/A token bucket per key/)).toBeInTheDocument()
+    expect(within(card).getByRole('radio', { name: /Approve the plan/ })).toBeInTheDocument()
+  })
+
+  it('opens in the panel, which says it is waiting on you', async () => {
+    renderChat(pending())
+    await userEvent.click(screen.getByRole('button', { name: 'Open in the Work panel' }))
+    expect(within(panel()).getByRole('tab', { name: /Plan/ })).toHaveAttribute('aria-selected', 'true')
+    expect(within(panel()).getByText('waiting for your approval')).toBeInTheDocument()
+    expect(await within(panel()).findByText(/A token bucket per key/)).toBeInTheDocument()
+  })
+
+  it('the Work key opens on the plan while one waits', async () => {
+    renderChat([call('Edit', edit('/tmp/wt/a.ts')), ...pending()])
+    await userEvent.click(screen.getByRole('button', { name: 'Work' }))
+    expect(within(panel()).getByRole('tab', { name: /Plan/ })).toHaveAttribute('aria-selected', 'true')
+  })
+})
+
+describe('the Edits tab', () => {
+  it('points at Changes for what is on disk, where there is a worktree to diff', async () => {
+    renderChat([call('Edit', edit('/tmp/wt/a.ts'))])
+    await userEvent.click(screen.getByRole('button', { name: /open in the Work panel/ }))
+    await userEvent.click(within(panel()).getByRole('button', { name: 'Changes' }))
+    expect(screen.getByRole('region', { name: 'Changes to review' })).toBeInTheDocument()
+  })
+
+  it('has no Changes link outside a repository', async () => {
+    renderChat([call('Edit', edit('/tmp/wt/a.ts'))], { repoRoot: null })
+    await userEvent.click(screen.getByRole('button', { name: /open in the Work panel/ }))
+    expect(within(panel()).queryByRole('button', { name: 'Changes' })).not.toBeInTheDocument()
+  })
+})
diff --git a/tests/parsers.test.ts b/tests/parsers.test.ts
index 77124d81..c4668749 100644
--- a/tests/parsers.test.ts
+++ b/tests/parsers.test.ts
@@ -772,4 +772,160 @@ describe('robustness', () => {
   })
 })
 
+// What a tool call hands the person to look at — a plan, a to-do list, an edit — rides
+// the call's row as a structured artifact (the Work panel's input), read from the real
+// log shapes each CLI writes.
+describe('work artifacts on tool rows', () => {
+  const dir = join(root, 'work')
+
+  it('claude: an edit, its failed retry, and tasks numbered by their results', () => {
+    mkdirSync(dir, { recursive: true })
+    const file = join(dir, 'claude-work.jsonl')
+    const at = (s: number): string => `2026-09-01T10:00:${String(s).padStart(2, '0')}Z`
+    writeFileSync(
+      file,
+      jsonl([
+        { type: 'user', message: { role: 'user', content: 'fix it' }, timestamp: at(0) },
+        {
+          type: 'assistant',
+          message: {
+            role: 'assistant',
+            content: [
+              // parallel calls: their results arrive together, after both
+              { type: 'tool_use', id: 'tu1', name: 'TaskCreate', input: { subject: 'Reproduce', description: 'd', activeForm: 'x' } },
+              { type: 'tool_use', id: 'tu2', name: 'Edit', input: { file_path: '/r/a.ts', old_string: 'a', new_string: 'b' } }
+            ]
+          },
+          timestamp: at(1)
+        },
+        {
+          type: 'user',
+          message: {
+            role: 'user',
+            content: [
+              { type: 'tool_result', tool_use_id: 'tu1', content: 'Task #7 created successfully: Reproduce' },
+              { type: 'tool_result', tool_use_id: 'tu2', content: 'String to replace not found in file.', is_error: true }
+            ]
+          },
+          timestamp: at(2)
+        },
+        {
+          type: 'assistant',
+          message: { role: 'assistant', content: [{ type: 'tool_use', id: 'tu3', name: 'TaskUpdate', input: { taskId: '7', status: 'completed' } }] },
+          timestamp: at(3)
+        }
+      ])
+    )
+    const msgs = parseClaudeMessages(file)
+    const calls = msgs.filter((m) => m.kind === 'tool_call')
+    expect(calls[0]).toMatchObject({ toolName: 'TaskCreate', preview: 'Reproduce', artifact: { kind: 'task-add', items: ['Reproduce'], ids: ['7'] } })
+    expect(calls[0].failed).toBeUndefined()
+    // the error answered the Edit, not the call next to it
+    expect(calls[1]).toMatchObject({ toolName: 'Edit', failed: true, artifact: { kind: 'edits' } })
+    expect(calls[2]).toMatchObject({ preview: '#7 → completed', artifact: { kind: 'task-update', id: '7', status: 'completed' } })
+    // the result rows stay as they were — the verdict is the call's
+    expect(msgs.filter((m) => m.kind === 'tool_result').every((m) => m.failed === undefined)).toBe(true)
+  })
+
+  it('codex: a FileChange item is the patch row when the patch ran inside a code-mode script', () => {
+    mkdirSync(dir, { recursive: true })
+    const file = join(dir, 'rollout-work.jsonl')
+    writeFileSync(
+      file,
+      jsonl([
+        { timestamp: '2026-09-01T10:00:00Z', type: 'session_meta', payload: { id: 'work-1', cwd: '/r' } },
+        { timestamp: '2026-09-01T10:00:01Z', type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'go' }] } },
+        {
+          timestamp: '2026-09-01T10:00:02Z',
+          type: 'response_item',
+          payload: { type: 'function_call', name: 'update_plan', arguments: JSON.stringify({ plan: [{ step: 'Patch it', status: 'in_progress' }] }), call_id: 'c0' }
+        },
+        {
+          timestamp: '2026-09-01T10:00:03Z',
+          type: 'response_item',
+          payload: { type: 'custom_tool_call', name: 'exec', input: 'text(await tools.apply_patch("..."))', call_id: 'c1' }
+        },
+        {
+          timestamp: '2026-09-01T10:00:04Z',
+          type: 'event_msg',
+          payload: {
+            type: 'item_completed',
+            item: {
+              type: 'FileChange',
+              id: 'fc1',
+              status: 'completed',
+              stdout: 'Success. Updated the following files:\nM /r/a.ts\n',
+              changes: { '/r/a.ts': { type: 'update', unified_diff: '@@ -1 +1 @@\n-a\n+b\n', move_path: null } }
+            }
+          }
+        }
+      ])
+    )
+    const calls = parseCodexMessages(file).filter((m) => m.kind === 'tool_call')
+    expect(calls).toHaveLength(2)
+    expect(calls[0]).toMatchObject({
+      toolName: 'update_plan',
+      preview: '1 step',
+      artifact: { kind: 'todos', items: [{ text: 'Patch it', status: 'in_progress' }] }
+    })
+    expect(calls[1]).toMatchObject({ toolName: 'apply_patch', preview: 'apply_patch /r/a.ts', artifact: { kind: 'edits' } })
+  })
+
+  it('codex: an apply_patch call is the row, and its FileChange item is not shown twice', () => {
+    mkdirSync(dir, { recursive: true })
+    const file = join(dir, 'rollout-patch.jsonl')
+    const patch = '*** Begin Patch\n*** Update File: /r/a.ts\n@@\n-a\n+b\n*** End Patch'
+    writeFileSync(
+      file,
+      jsonl([
+        { timestamp: '2026-09-01T10:00:00Z', type: 'session_meta', payload: { id: 'work-2', cwd: '/r' } },
+        { timestamp: '2026-09-01T10:00:01Z', type: 'response_item', payload: { type: 'custom_tool_call', name: 'apply_patch', input: patch, call_id: 'p1' } },
+        {
+          timestamp: '2026-09-01T10:00:02Z',
+          type: 'event_msg',
+          payload: { type: 'item_completed', item: { type: 'FileChange', status: 'completed', changes: { '/r/a.ts': { type: 'update', unified_diff: '@@\n-a\n+b\n' } } } }
+        },
+        { timestamp: '2026-09-01T10:00:03Z', type: 'response_item', payload: { type: 'custom_tool_call_output', call_id: 'p1', output: 'Done!' } }
+      ])
+    )
+    const msgs = parseCodexMessages(file)
+    expect(msgs.map((m) => m.kind)).toEqual(['tool_call', 'tool_result'])
+    expect(msgs[0]).toMatchObject({ toolName: 'apply_patch', preview: 'apply_patch /r/a.ts', artifact: { kind: 'edits' } })
+  })
+
+  it('copilot: a plan, an edit, and an edit whose execution failed', () => {
+    const sdir = join(dir, 'copilot', 'session-state', 'work-3')
+    mkdirSync(sdir, { recursive: true })
+    const file = join(sdir, 'events.jsonl')
+    writeFileSync(
+      file,
+      jsonl([
+        { type: 'user.message', data: { content: 'plan it' }, timestamp: '2026-09-01T10:00:00Z' },
+        {
+          type: 'tool.execution_start',
+          data: { toolCallId: 'k1', toolName: 'exit_plan_mode', arguments: { summary: '## Plan\n- one', recommendedAction: 'autopilot' } },
+          timestamp: '2026-09-01T10:00:01Z'
+        },
+        {
+          type: 'tool.execution_start',
+          data: { toolCallId: 'k2', toolName: 'edit', arguments: { path: '/r/a.ts', old_str: 'a', new_str: 'b' } },
+          timestamp: '2026-09-01T10:00:02Z'
+        },
+        { type: 'tool.execution_complete', data: { toolCallId: 'k2', success: false, result: { content: 'no match' } }, timestamp: '2026-09-01T10:00:03Z' },
+        {
+          type: 'tool.execution_start',
+          data: { toolCallId: 'k3', toolName: 'create', arguments: { path: '/r/b.ts', file_text: 'x' } },
+          timestamp: '2026-09-01T10:00:04Z'
+        },
+        { type: 'tool.execution_complete', data: { toolCallId: 'k3', success: true, result: { content: 'ok' } }, timestamp: '2026-09-01T10:00:05Z' }
+      ])
+    )
+    const calls = parseCopilotMessages(file).filter((m) => m.kind === 'tool_call')
+    expect(calls[0]).toMatchObject({ toolName: 'exit_plan_mode', artifact: { kind: 'plan', text: '## Plan\n- one' } })
+    expect(calls[1]).toMatchObject({ toolName: 'edit', failed: true, artifact: { kind: 'edits' } })
+    expect(calls[2]).toMatchObject({ toolName: 'create', artifact: { kind: 'edits' } })
+    expect(calls[2].failed).toBeUndefined()
+  })
+})
+
 afterAll(() => rmSync(root, { recursive: true, force: true }))
diff --git a/tests/work.test.ts b/tests/work.test.ts
new file mode 100644
index 00000000..1b7ebbc1
--- /dev/null
+++ b/tests/work.test.ts
@@ -0,0 +1,156 @@
+import { describe, expect, it } from 'vitest'
+import { absolutePath, buildWork, fileChange, hasWork, planTitle, todoSummary } from '../src/renderer/src/work'
+import type { FileEdit, SessionMessage, WorkArtifact } from '../src/shared/types'
+
+const call = (toolName: string, artifact: WorkArtifact, extra: Partial<SessionMessage> = {}): SessionMessage => ({
+  role: 'assistant',
+  kind: 'tool_call',
+  toolName,
+  text: '{}',
+  artifact,
+  ...extra
+})
+const say = (text: string): SessionMessage => ({ role: 'assistant', kind: 'text', text })
+const edit = (path: string, from: string, to: string, change: FileEdit['change'] = 'edit'): WorkArtifact => ({
+  kind: 'edits',
+  files: [
+    {
+      path,
+      change,
+      hunks: [
+        [
+          { op: 'del', text: from },
+          { op: 'add', text: to }
+        ]
+      ]
+    }
+  ]
+})
+
+describe('buildWork: plans', () => {
+  it('keeps every plan, oldest first, each under its row', () => {
+    const log = [say('thinking'), call('ExitPlanMode', { kind: 'plan', text: '# One' }), say('revised'), call('ExitPlanMode', { kind: 'plan', text: '# Two' }, { ts: 5 })]
+    expect(buildWork(log).plans).toEqual([
+      { key: 1, text: '# One' },
+      { key: 3, text: '# Two', ts: 5 }
+    ])
+  })
+
+  it('titles a plan by its first heading, else its first line', () => {
+    expect(planTitle('Intro line\n\n## Add **rate** limiting\n- a')).toBe('Add rate limiting')
+    expect(planTitle('**Approach:** one layer\n- b')).toBe('Approach: one layer')
+    expect(planTitle('   ')).toBe('Plan')
+  })
+})
+
+describe('buildWork: the to-do list', () => {
+  it('a whole list replaces the one before it', () => {
+    const log = [
+      call('TodoWrite', { kind: 'todos', items: [{ text: 'a', status: 'pending' }] }),
+      call('TodoWrite', {
+        kind: 'todos',
+        items: [
+          { text: 'a', status: 'completed' },
+          { text: 'b', status: 'in_progress' }
+        ]
+      })
+    ]
+    const w = buildWork(log)
+    expect(w.todos.map((t) => [t.text, t.status])).toEqual([
+      ['a', 'completed'],
+      ['b', 'in_progress']
+    ])
+    expect(w.todosKey).toBe(1)
+    expect(todoSummary(w.todos)).toBe('1 of 2 done')
+  })
+
+  it("folds Claude's tasks by the numbers their results gave them", () => {
+    const log = [
+      call('TaskCreate', { kind: 'task-add', items: ['Reproduce'], ids: ['4'] }),
+      call('TaskCreate', { kind: 'task-add', items: ['Fix'], ids: ['5'] }),
+      call('TaskUpdate', { kind: 'task-update', id: '4', status: 'completed' }),
+      call('TaskUpdate', { kind: 'task-update', id: '5', status: 'in_progress', text: 'Fix the parser' })
+    ]
+    expect(buildWork(log).todos).toEqual([
+      { id: '4', text: 'Reproduce', status: 'completed' },
+      { id: '5', text: 'Fix the parser', status: 'in_progress' }
+    ])
+  })
+
+  it('numbers a streamed create — no result read yet — after the highest number seen', () => {
+    const log = [
+      call('TaskCreate', { kind: 'task-add', items: ['First'], ids: ['2'] }),
+      call('TaskCreate', { kind: 'task-add', items: ['Streamed'] }),
+      call('TaskUpdate', { kind: 'task-update', id: '3', status: 'in_progress' })
+    ]
+    expect(buildWork(log).todos.map((t) => [t.id, t.status])).toEqual([
+      ['2', 'pending'],
+      ['3', 'in_progress']
+    ])
+  })
+
+  it('a deleted task leaves the list; a failed call changes nothing', () => {
+    const log = [
+      call('TaskCreate', { kind: 'task-add', items: ['a', 'b'], ids: ['1', '2'] }),
+      call('TaskUpdate', { kind: 'task-update', id: '1', status: 'deleted' }),
+      call('TaskUpdate', { kind: 'task-update', id: '2', status: 'completed' }, { failed: true })
+    ]
+    expect(buildWork(log).todos).toEqual([{ id: '2', text: 'b', status: 'pending' }])
+  })
+
+  it('an update for a task created before the log starts is kept when it names the task', () => {
+    const log = [
+      call('TaskUpdate', { kind: 'task-update', id: '9', status: 'in_progress', text: 'Older task' }),
+      call('TaskUpdate', { kind: 'task-update', id: '10', status: 'completed' })
+    ]
+    const w = buildWork(log)
+    expect(w.todos).toEqual([{ id: '9', text: 'Older task', status: 'in_progress' }])
+    expect(w.todosKey).toBe(0)
+  })
+})
+
+describe('buildWork: edits', () => {
+  it('groups edits by file in first-touched order, one path however it was written', () => {
+    const log = [
+      call('Edit', edit('/repo/src/a.ts', 'x', 'y'), { ts: 1 }),
+      call('apply_patch', edit('src/b.ts', 'p', 'q')),
+      call('apply_patch', edit('./src/a.ts', 'y', 'z'))
+    ]
+    const w = buildWork(log, '/repo')
+    expect(w.files.map((f) => [f.path, f.edits.map((e) => e.key)])).toEqual([
+      ['/repo/src/a.ts', [0, 2]],
+      ['/repo/src/b.ts', [1]]
+    ])
+    expect(w.editCount).toBe(3)
+    expect(w.files[0]).toMatchObject({ added: 2, removed: 2 })
+  })
+
+  it("a failed edit is listed but counts nothing, and doesn't decide what happened to the file", () => {
+    const log = [
+      call('Write', edit('/r/new.ts', '', 'a', 'write'), { failed: true }),
+      call('Edit', edit('/r/new.ts', 'a', 'b'))
+    ]
+    const [f] = buildWork(log).files
+    expect(f!.edits.map((e) => e.failed)).toEqual([true, false])
+    expect(f).toMatchObject({ added: 1, removed: 1 })
+    expect(fileChange(f!)).toBe('edit')
+  })
+
+  it('a file added then deleted reads as deleted', () => {
+    const log = [call('create', edit('/r/t.ts', '', 'a', 'add')), call('apply_patch', { kind: 'edits', files: [{ path: '/r/t.ts', change: 'delete', hunks: [] }] })]
+    expect(fileChange(buildWork(log).files[0]!)).toBe('delete')
+  })
+
+  it('makes a relative path absolute only when the directory is known', () => {
+    expect(absolutePath('a.ts', '/r/')).toBe('/r/a.ts')
+    expect(absolutePath('/abs/a.ts', '/r')).toBe('/abs/a.ts')
+    expect(absolutePath('a.ts')).toBe('a.ts')
+  })
+})
+
+describe('hasWork', () => {
+  it('asks whether any call carries something for the panel', () => {
+    expect(hasWork([say('hi'), { role: 'assistant', kind: 'tool_call', toolName: 'Bash', text: 'ls' }])).toBe(false)
+    expect(hasWork([call('TodoWrite', { kind: 'todos', items: [] })])).toBe(true)
+  })
+})