From db574ae83acd9b17d348f69d0fd371ffa9c603ef Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Mon, 12 Oct 2026 15:56:55 -0700
Subject: [PATCH] feat(native-chat): one current-work projection for every host
 reader; record death first

The host decides what work is current in one place
(structured-agent-session-current-work.ts) from the lease, the exit this host
saw, the runtimes it replaced, its live child and each item's provenance.
Every host reader (queue, Stop, prompt answers, commands, status feed, idle
sweep, teardown snapshot, history pages and frames, orchestration mailbox)
reads it, so a dead agent's leftovers stop reading Working or holding the queue
even when their cleanup write failed. The journal's activeTurnId()/liveTurnScope()
become the raw runningTurn().

On exit the host records the child's end first and signals generationEnded,
which republishes frames, the status feed and settlement waits and wakes the
queue drain with no journal row. Pages and frames carry optional working and
actionablePromptIds fields.
---
 .../scripts/vitest-sqlite-runtime-files.mjs   |   2 +
 .../first-work-branch-rename.test.ts          |  14 +-
 .../claude-background-stop-records.test.ts    |   9 +-
 .../claude-background-wake-retention.test.ts  |   7 +-
 ...claude-subagent-permission-request.test.ts |   6 +-
 ...tructured-journal-exit-convergence.test.ts |  22 +-
 ...journal-atomic-terminal-settlement.test.ts |   8 +-
 .../journal-store.test.ts                     |   2 +-
 .../agent-session-journal/journal-store.ts    |  24 +-
 ...nal-terminal-settlement-validation.test.ts |   6 +-
 .../agent-session-history-page.ts             |  82 ++++--
 .../agent-session-stop-note-refresh.test.ts   |  97 +++++++
 .../agent-session-stop-note-refresh.ts        |  12 +-
 .../agent-session-subscriber-catch-up.ts      |  43 ++-
 ...structured-agent-session-attach-context.ts |   1 +
 ...structured-agent-session-attach-failure.ts |   2 +
 .../structured-agent-session-attach-flow.ts   |   8 +-
 ...d-agent-session-background-task-channel.ts |  17 +-
 .../structured-agent-session-chat-stop.ts     |   2 +
 .../structured-agent-session-child-exit.ts    |  52 ++--
 ...red-agent-session-claude-root-exit.test.ts |   2 +-
 ...tructured-agent-session-client-delivery.ts |  62 +++-
 .../structured-agent-session-command-turn.ts  |  14 +-
 ...red-agent-session-conversation-lifetime.ts |   4 +
 ...uctured-agent-session-current-work.test.ts | 274 ++++++++++++++++++
 .../structured-agent-session-current-work.ts  | 268 +++++++++++++++++
 .../structured-agent-session-delivery-loop.ts |   6 +-
 ...structured-agent-session-event-recovery.ts |   5 +-
 ...structured-agent-session-history-result.ts |  13 +-
 ...uctured-agent-session-host-current-work.ts |  57 ++++
 .../structured-agent-session-host-delivery.ts |   9 +-
 .../structured-agent-session-host-lifetime.ts |   2 +
 ...ructured-agent-session-host-status-feed.ts |   5 +-
 ...tructured-agent-session-host-stop-event.ts |  39 ++-
 .../structured-agent-session-host-types.ts    |   3 +
 .../structured-agent-session-host.ts          |  22 +-
 ...tructured-agent-session-idle-sweep.test.ts |   3 +-
 .../structured-agent-session-idle-sweep.ts    |  50 ++--
 ...ession-leftover-settlement.test-fixture.ts | 145 +++++++++
 ...red-agent-session-live-turn-window.test.ts |   2 +-
 ...ctured-agent-session-mutation-admission.ts |   3 +
 ...ructured-agent-session-mutation-context.ts |   6 +
 ...red-agent-session-mutation-turn-context.ts |   6 +-
 .../structured-agent-session-prompt-cancel.ts |   7 +-
 ...structured-agent-session-provider-child.ts |  16 +-
 ...ed-agent-session-queued-card-holds.test.ts |  36 ++-
 ...ructured-agent-session-queued-edit.test.ts |   8 +-
 ...ructured-agent-session-queued-gate.test.ts |  10 +-
 ...session-queued-message-rig.test-fixture.ts |  11 +-
 ...tructured-agent-session-queued-messages.ts | 101 +++----
 ...ructured-agent-session-queued-mutations.ts |   6 +-
 ...ctured-agent-session-queued-publication.ts |  30 +-
 .../structured-agent-session-queued-stop.ts   |  11 +-
 .../structured-agent-session-queued-wiring.ts |  10 +-
 ...ent-session-restart-resume-test-harness.ts |   7 +-
 ...ed-agent-session-rewind-provenance.test.ts | 154 ++++++++++
 .../structured-agent-session-rewind.ts        |   3 +
 ...ured-agent-session-send-settlement.test.ts |  21 +-
 ...tructured-agent-session-send-settlement.ts |   8 +-
 .../structured-agent-session-shown-work.ts    |  13 +-
 ...red-agent-session-signed-out-child.test.ts |   7 +-
 ...ructured-agent-session-signed-out-child.ts |   7 +-
 ...agent-session-startup-failure-exit.test.ts |   2 +-
 ...ructured-agent-session-status-feed.test.ts |   8 +-
 .../structured-agent-session-status-feed.ts   |  22 +-
 ...agent-session-status-journal-projection.ts |  73 ++++-
 ...d-agent-session-stop-event-binding.test.ts |   8 +-
 ...d-agent-session-stop-event-entries.test.ts |   2 +-
 ...d-agent-session-stop-event-restart.test.ts |   2 +-
 ...tructured-agent-session-stop-event.test.ts |   2 +-
 ...red-agent-session-stop-never-waits.test.ts |   2 +-
 ...-agent-session-stop-settle-binding.test.ts |   8 +-
 ...structured-agent-session-stop-wind-down.ts |  12 +-
 .../structured-agent-session-stopping.test.ts |   8 +-
 .../structured-agent-session-stopping.ts      |  16 +-
 .../structured-agent-session-subscribers.ts   |  47 ++-
 .../structured-agent-session-thread-goal.ts   |   3 +-
 ...tructured-agent-session-turn-stop-notes.ts |   7 +-
 .../structured-agent-session-turns-cancel.ts  |  39 +--
 .../structured-agent-session-turns-prompt.ts  |   8 +-
 .../structured-agent-session-turns.ts         |  12 +-
 ...ured-agent-session-unexpected-exit.test.ts |  17 +-
 ...tured-agent-session-working-at-teardown.ts |  37 ++-
 ...red-conversation-command-admission.test.ts |  13 +-
 ...ructured-conversation-command-admission.ts |  27 +-
 .../structured-conversation-command.ts        |   3 +
 ...structured-conversation-compaction.test.ts |   9 +-
 .../structured-mailbox-pointer-host.test.ts   |   5 +-
 .../structured-mailbox-pointer-host.ts        |   7 +-
 .../structured-session-pointer-delivery.ts    |  13 +-
 ...structured-worker-group-addressing.test.ts |   3 +-
 ...ructured-agent-session-rpc.test-fixture.ts |  12 +-
 .../structured-worker-cleared-session.test.ts |   2 +
 src/shared/agent-session-wire.ts              |  22 +-
 .../structured-agent-session-live-turn.ts     |  33 ++-
 ...ctured-agent-session-main-agent-working.ts |  22 +-
 .../structured-agent-session-owed-work.ts     |  16 +-
 .../structured-agent-session-projection.ts    |  34 ++-
 98 files changed, 1993 insertions(+), 445 deletions(-)
 create mode 100644 src/main/native-chat/agent-session-wire/agent-session-stop-note-refresh.test.ts
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-current-work.test.ts
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-current-work.ts
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-host-current-work.ts
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-leftover-settlement.test-fixture.ts
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-rewind-provenance.test.ts

diff --git a/config/scripts/vitest-sqlite-runtime-files.mjs b/config/scripts/vitest-sqlite-runtime-files.mjs
index 3c9d738d8ba..22cc03d9be3 100644
--- a/config/scripts/vitest-sqlite-runtime-files.mjs
+++ b/config/scripts/vitest-sqlite-runtime-files.mjs
@@ -100,6 +100,7 @@ export const SQLITE_RUNTIME_INCLUDE = [
   'src/main/native-chat/agent-session-wire/structured-agent-session-event-sink.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-owner-verdict.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts',
+  'src/main/native-chat/agent-session-wire/structured-agent-session-current-work.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-grouped-prompt.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-held-child-lease-renewal.test.ts',
@@ -153,6 +154,7 @@ export const SQLITE_RUNTIME_INCLUDE = [
   'src/main/native-chat/agent-session-wire/structured-agent-session-restart-stream-duration.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-rewind-at-rest.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-rewind-live-send.test.ts',
+  'src/main/native-chat/agent-session-wire/structured-agent-session-rewind-provenance.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-rewind.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-clear-rewind.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-send-idempotency.test.ts',
diff --git a/src/main/agent-hooks/first-work-branch-rename.test.ts b/src/main/agent-hooks/first-work-branch-rename.test.ts
index 1a761fda810..767092e491c 100644
--- a/src/main/agent-hooks/first-work-branch-rename.test.ts
+++ b/src/main/agent-hooks/first-work-branch-rename.test.ts
@@ -102,12 +102,15 @@ describe('maybeAutoRenameBranchOnFirstWork', () => {
       // A real journal's sequence only ever advances, so the feed's projection
       // cache must miss on every publish here: this test is about the rename.
       let sequence = 0
-      // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the status feed reads only cursor(), lastActivityAt(), stopMarks and snapshot() of a journal.
+      // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the status feed reads only cursor(), lastActivityAt(), stopMarks, snapshot(), the provenance reads and runningTurn() of a journal.
       const journal = {
         snapshot: () => ({ items, submissions: [] }),
         stopMarks: { latest: () => null, revision: () => 0 },
         lastActivityAt: () => 1,
-        cursor: () => ({ epoch: 1, sequence: (sequence += 1) })
+        cursor: () => ({ epoch: 1, sequence: (sequence += 1) }),
+        itemFence: () => undefined,
+        wroteBeforeOpen: () => false,
+        runningTurn: () => null
       } as unknown as AgentSessionJournal
       const pending: Promise<void>[] = []
       const observe = vi.fn((summary, options) => {
@@ -191,7 +194,7 @@ describe('maybeAutoRenameBranchOnFirstWork', () => {
     const { deps, setDisplayName, setRenameError } = makeDeps({
       getRepo: () => ({ id: REPO_ID, kind: 'folder', path: '/workspace/platform' }) as Repo
     })
-    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the status feed reads only cursor(), lastActivityAt(), stopMarks and snapshot() of a journal.
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the status feed reads only cursor(), lastActivityAt(), stopMarks, snapshot(), the provenance reads and runningTurn() of a journal.
     const journal = {
       lastActivityAt: () => 1,
       stopMarks: { latest: () => null, revision: () => 0 },
@@ -208,7 +211,10 @@ describe('maybeAutoRenameBranchOnFirstWork', () => {
           }
         ],
         submissions: []
-      })
+      }),
+      itemFence: () => undefined,
+      wroteBeforeOpen: () => false,
+      runningTurn: () => null
     } as unknown as AgentSessionJournal
     const location = {
       executionHostId: 'local' as const,
diff --git a/src/main/claude/claude-background-stop-records.test.ts b/src/main/claude/claude-background-stop-records.test.ts
index 0092d9e2f29..59da2979507 100644
--- a/src/main/claude/claude-background-stop-records.test.ts
+++ b/src/main/claude/claude-background-stop-records.test.ts
@@ -33,7 +33,14 @@ async function droppedFromRoster() {
       {
         sessionId: 'session-1',
         fence: 7,
-        journal: { snapshot: () => ({ items: [] }), submissions: () => [] },
+        journal: {
+          snapshot: () => ({ items: [] }),
+          submissions: () => [],
+          runningTurn: () => null,
+          itemFence: () => undefined,
+          visitItems: () => undefined,
+          wroteBeforeOpen: () => false
+        },
         adapter: run.adapter
       },
       RECORD,
diff --git a/src/main/claude/claude-background-wake-retention.test.ts b/src/main/claude/claude-background-wake-retention.test.ts
index 427e24e8960..d65d4a9a445 100644
--- a/src/main/claude/claude-background-wake-retention.test.ts
+++ b/src/main/claude/claude-background-wake-retention.test.ts
@@ -40,6 +40,11 @@ async function wiredSession() {
     },
     // No Stop was ever pressed here.
     stopMarks: { latest: () => null, revision: () => 0 },
+    // One generation produced everything here, and every send was accepted by this process.
+    itemFence: () => undefined,
+    wroteBeforeOpen: () => false,
+    // The live generation's own turns are never a died turn, so this is never consulted for one.
+    runningTurn: () => null,
     snapshot: () => ({
       items: [...run.journalItems.values()]
         .sort((a, b) => a.sequence - b.sequence)
@@ -53,7 +58,7 @@ async function wiredSession() {
       [
         parent.sessionId,
         {
-          // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the fixture supplies the feed's cursor, clock, Stop marks, snapshot, submissions and item reads.
+          // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the fixture supplies the feed's cursor, clock, Stop marks, snapshot, submissions, item and provenance reads.
           journal: journal as unknown as Journal,
           params: {
             location: {
diff --git a/src/main/claude/claude-subagent-permission-request.test.ts b/src/main/claude/claude-subagent-permission-request.test.ts
index c3db6a4011b..95bfb84cb2b 100644
--- a/src/main/claude/claude-subagent-permission-request.test.ts
+++ b/src/main/claude/claude-subagent-permission-request.test.ts
@@ -24,6 +24,7 @@ import { AgentHookServer } from '../agent-hooks/server'
 import type { AgentSessionJournal } from '../native-chat/agent-session-journal/journal-store'
 import { createTrackedJournalOpener } from '../native-chat/agent-session-journal/journal-host-database-test-support'
 import { settleStructuredAgentSessionDeadGeneration } from '../native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement'
+import { StructuredAgentSessionCurrentWork } from '../native-chat/agent-session-wire/structured-agent-session-current-work'
 import { createDeferredStructuredAgentSessionEventSink } from '../native-chat/agent-session-wire/structured-agent-session-event-sink'
 import { testEventSinkLogging } from '../native-chat/agent-session-wire/structured-agent-session-logger-test-support'
 import { createStructuredAgentSessionLogger } from '../native-chat/agent-session-wire/structured-agent-session-logger'
@@ -243,7 +244,10 @@ async function pipeline() {
       await journal.appendItem(
         identity,
         { ...card.body, resolution: { ...resolution, resolvedBy: 'client-1', resolvedAt: now() } },
-        { fence: FENCE, turnScope: journal.liveTurnScope() }
+        {
+          fence: FENCE,
+          turnScope: new StructuredAgentSessionCurrentWork(journal, FENCE).turnScope()
+        }
       )
     }
   const cardId = (): string => {
diff --git a/src/main/codex/codex-structured-journal-exit-convergence.test.ts b/src/main/codex/codex-structured-journal-exit-convergence.test.ts
index c9f56af8304..187d130e464 100644
--- a/src/main/codex/codex-structured-journal-exit-convergence.test.ts
+++ b/src/main/codex/codex-structured-journal-exit-convergence.test.ts
@@ -5,7 +5,6 @@ import { afterEach, expect, it, vi } from 'vitest'
 import { AGENT_JOURNAL_THREAD_SCOPE } from '../../shared/agent-session-journal-types'
 import { codexProviderHandle } from '../../shared/agent-session-provider-handle-encoding'
 import { readAgentJournalTurn } from '../../shared/agent-session-turn-record'
-import { isStructuredAgentSessionMainAgentWorking } from '../../shared/structured-agent-session-main-agent-working'
 import type { AgentSessionRecord } from '../../shared/agent-session-record'
 import {
   agentSessionLeaseFixture,
@@ -23,7 +22,7 @@ import {
   type StructuredAgentSessionChildExitSession
 } from '../native-chat/agent-session-wire/structured-agent-session-child-exit'
 import type { StructuredAgentSessionEndedEvent } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
-import { pendingPromptExists } from '../native-chat/agent-session-wire/structured-agent-session-queued-messages'
+import { StructuredAgentSessionCurrentWork } from '../native-chat/agent-session-wire/structured-agent-session-current-work'
 import { createCodexJournalTranslator } from './codex-structured-journal-translation'
 import { handleCodexSessionExit } from './codex-structured-session-close'
 import type { CodexSession, CodexStructuredSessionEvent } from './codex-structured-session-state'
@@ -46,15 +45,14 @@ afterEach(async () => {
   }
 })
 
-function userVisible(journal: AgentSessionJournal) {
+/** What the chat shows with the live generation at `liveFence`: 7 while the child runs, none once
+ *  its exit released it (`structuredAgentSessionCurrentWork`). */
+function userVisible(journal: AgentSessionJournal, liveFence: number | null) {
   const items = journal.snapshot().items
+  const work = new StructuredAgentSessionCurrentWork(journal, liveFence)
   return {
-    working: isStructuredAgentSessionMainAgentWorking(
-      journal.activeTurnId(),
-      journal.submissions(),
-      8
-    ),
-    prompt: pendingPromptExists(journal),
+    working: work.working(),
+    prompt: work.hasActionablePrompt(),
     turnStates: items.flatMap((item) => readAgentJournalTurn(item.body)?.state ?? []),
     runningCalls: items.filter(
       (item) => item.body.kind === 'tool-call' && item.body.state === 'running'
@@ -149,7 +147,7 @@ it('settles a refused Codex exit through the host in one commit, then permits a
   ).toEqual({ accepted: true })
   await expect(deferred.drained()).resolves.toEqual({ ok: true })
   expect(deferred.state().queuedBytes).toBe(0)
-  expect(userVisible(journal)).toEqual({
+  expect(userVisible(journal, 7)).toEqual({
     working: true,
     prompt: true,
     turnStates: ['running'],
@@ -234,13 +232,13 @@ it('settles a refused Codex exit through the host in one commit, then permits a
       },
       sessions: new Map([[SESSION, hostSession]]),
       flushLifecycle: () => deferred.lifecycleBarrier(),
-      publishFence: vi.fn(),
+      generationEnded: vi.fn(),
       serialize: async (_sessionId, task) => task(),
       now: () => 5_000
     },
     event
   )
-  expect(userVisible(journal)).toEqual({
+  expect(userVisible(journal, null)).toEqual({
     working: false,
     prompt: false,
     turnStates: ['interrupted'],
diff --git a/src/main/native-chat/agent-session-journal/journal-atomic-terminal-settlement.test.ts b/src/main/native-chat/agent-session-journal/journal-atomic-terminal-settlement.test.ts
index ca622c5b2f7..7fa7e873d4b 100644
--- a/src/main/native-chat/agent-session-journal/journal-atomic-terminal-settlement.test.ts
+++ b/src/main/native-chat/agent-session-journal/journal-atomic-terminal-settlement.test.ts
@@ -191,7 +191,7 @@ describe('atomic terminal settlement', () => {
           return result
         })
       )
-      expect(await settle()).toEqual({ ok: true })
+      expect(await settle()).toMatchObject({ ok: true })
       vi.restoreAllMocks()
       const settled = journal.snapshot()
       expect(published).toEqual([settled])
@@ -209,7 +209,7 @@ describe('atomic terminal settlement', () => {
       expect(frames.at(-1)).toMatchObject({ type: 'batch', batch: { cursor: settled.cursor } })
       const frameCount = frames.length
       expect(settled.submissions[0]).toMatchObject({ dispatchState: 'unknown', recovered: true })
-      expect(journal.activeTurnId()).toBeNull()
+      expect(journal.runningTurn()?.turnId ?? null).toBeNull()
       const calls = settled.items.filter((item) => item.body.kind === 'tool-call')
       expect(calls).toHaveLength(201)
       expect(
@@ -230,7 +230,7 @@ describe('atomic terminal settlement', () => {
         'lifecycle-batch'
       ])
       expect(committed.every((row) => row.recovered)).toBe(true)
-      expect(await settle()).toEqual({ ok: true })
+      expect(await settle()).toMatchObject({ ok: true })
       expect(journal.snapshot()).toEqual(settled)
       expect(rows().slice(diskBefore.length)).toEqual(committed)
       expect(published).toEqual([settled])
@@ -238,7 +238,7 @@ describe('atomic terminal settlement', () => {
       await journal.close()
       journal = await open()
       expect(journal.snapshot()).toEqual(settled)
-      expect(await settle()).toEqual({ ok: true })
+      expect(await settle()).toMatchObject({ ok: true })
       expect(journal.snapshot()).toEqual(settled)
     }
   )
diff --git a/src/main/native-chat/agent-session-journal/journal-store.test.ts b/src/main/native-chat/agent-session-journal/journal-store.test.ts
index 5c5637de2df..6b2488c259a 100644
--- a/src/main/native-chat/agent-session-journal/journal-store.test.ts
+++ b/src/main/native-chat/agent-session-journal/journal-store.test.ts
@@ -141,7 +141,7 @@ describe('sequences', () => {
     const rendered = (): string | null =>
       activeStructuredAgentSessionTurnId(journal.snapshot().items)
     const bothAgreeOn = async (turnId: string | null): Promise<void> => {
-      expect(journal.activeTurnId()).toBe(turnId)
+      expect(journal.runningTurn()?.turnId ?? null).toBe(turnId)
       expect(rendered()).toBe(turnId)
     }
 
diff --git a/src/main/native-chat/agent-session-journal/journal-store.ts b/src/main/native-chat/agent-session-journal/journal-store.ts
index 8fe8c970b0a..67f26ee31c4 100644
--- a/src/main/native-chat/agent-session-journal/journal-store.ts
+++ b/src/main/native-chat/agent-session-journal/journal-store.ts
@@ -13,7 +13,6 @@ import type {
   AgentJournalSubmission,
   AgentJournalThreadGoal,
   AgentJournalTurnLifecycle,
-  AgentJournalTurnScope,
   AgentSessionJournalIdentity
 } from '../../../shared/agent-session-journal-types'
 import { agentJournalItemKey } from '../../../shared/agent-session-journal-item-key'
@@ -21,9 +20,8 @@ import { currentAgentSessionThreadGoalBySequence } from '../../../shared/agent-s
 import type { AgentSessionContextUsage } from '../../../shared/agent-session-context-usage'
 import { latestStructuredAgentContextFacts } from '../../../shared/structured-agent-session-context-usage'
 import {
-  activeStructuredAgentSessionTurnIdBySequence,
-  liveStructuredAgentSessionTurnScope,
-  newestStructuredAgentSessionTurnBySequence
+  newestStructuredAgentSessionTurnBySequence,
+  runningStructuredAgentSessionTurnItemBySequence
 } from '../../../shared/structured-agent-session-live-turn'
 import type { JournalReplacementItem } from './journal-epoch-replacement'
 import { readJournalSince } from './journal-cursor'
@@ -223,14 +221,11 @@ export class AgentSessionJournal {
     }
   }
 
-  /** The turn this journal has published as running — the same read a client's snapshot gives,
-   *  without materialising one. */
-  activeTurnId = (): string | null =>
-    activeStructuredAgentSessionTurnIdBySequence(this.state.items.values())
-
-  /** Where a row written now belongs: the running turn, or the conversation. */
-  liveTurnScope = (): AgentJournalTurnScope =>
-    liveStructuredAgentSessionTurnScope(this.state.items.values())
+  /** The turn this journal records as running, with its record's item, whichever generation
+   *  opened it — the same read a client's snapshot gives, without materialising one. Whether it is
+   *  current work is the host projection's to say (`structuredAgentSessionCurrentWork`). */
+  runningTurn = (): { item: AgentJournalRenderItem; turnId: string } | null =>
+    runningStructuredAgentSessionTurnItemBySequence(this.state.items.values())
 
   /** The newest turn record whatever state it settled in, for readers that need the outcome. */
   newestTurn = (): AgentJournalTurnLifecycle | null =>
@@ -247,12 +242,11 @@ export class AgentSessionJournal {
   /** Includes revisions and completion tombstones, whose timestamps disappear from render items. */
   lastActivityAt = (): number => this.state.lastActivityAt
 
-  /** Fence of the writer that created the item, while it is in the timeline. */
+  /** The item's execution provenance (`JournalItemRow.ownerFence`), while it is in the timeline. */
   itemFence = (itemId: string): number | undefined => this.state.itemFences.get(itemId)
 
   /** Latest saved output at this fence, excluding client actions and recovery bookkeeping. */
-  lastProviderActivityAt = (fence: number): number | undefined =>
-    this.state.providerActivityAt.get(fence)
+  lastProviderActivityAt = (fence: number) => this.state.providerActivityAt.get(fence)
 
   submissions = (): AgentJournalSubmission[] => [...this.state.submissions.values()]
 
diff --git a/src/main/native-chat/agent-session-journal/journal-terminal-settlement-validation.test.ts b/src/main/native-chat/agent-session-journal/journal-terminal-settlement-validation.test.ts
index dba12dc49d3..3d9f3b0ce85 100644
--- a/src/main/native-chat/agent-session-journal/journal-terminal-settlement-validation.test.ts
+++ b/src/main/native-chat/agent-session-journal/journal-terminal-settlement-validation.test.ts
@@ -117,7 +117,7 @@ it.each([
       turnId: 'old',
       state: 'interrupted'
     })
-    expect(journal.activeTurnId()).toBeNull()
+    expect(journal.runningTurn()?.turnId ?? null).toBeNull()
     const ended = journal.snapshot()
     await settle(observedAt, lastProvenAliveAt)
     expect(journal.snapshot()).toEqual(ended)
@@ -145,7 +145,7 @@ it.each([{ kind: 'tool-call' }, { providerTurnId: '' }])(
       state: 'interrupted',
       completedAt: 1_000
     })
-    expect(journal.activeTurnId()).toBeNull()
+    expect(journal.runningTurn()?.turnId ?? null).toBeNull()
     await expectSendStillWritable()
   }
 )
@@ -329,7 +329,7 @@ it.each([
     }
     expect(journal.itemBody('orca:extension-7')).toHaveProperty('laterField', { kind: 'tool-call' })
     expect(journal.itemBody('orca:extension-6')).toHaveProperty('contextUsage', laterContextUsage)
-    expect(journal.activeTurnId()).toBeNull()
+    expect(journal.runningTurn()?.turnId ?? null).toBeNull()
     expect(journal.snapshot().items).toHaveLength(inputs.length + 1)
     const ended = journal.snapshot()
     await settle(observedAt, lastProvenAliveAt)
diff --git a/src/main/native-chat/agent-session-wire/agent-session-history-page.ts b/src/main/native-chat/agent-session-wire/agent-session-history-page.ts
index b1667daa512..d2714ff3cbf 100644
--- a/src/main/native-chat/agent-session-wire/agent-session-history-page.ts
+++ b/src/main/native-chat/agent-session-wire/agent-session-history-page.ts
@@ -36,6 +36,15 @@ import {
   submissionBytesByItemId
 } from './agent-session-history-page-bounds'
 import { offPageSubagentRoster } from './agent-session-history-subagent-roster'
+import type { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
+
+/** What a page publishes of the host's current-work projection (`structuredAgentSessionCurrentWork`):
+ *  the newest turn record as clients are told it, and the prompts still waiting on the person.
+ *  Absent, a page states the raw record and no prompt ids, as an older host did. */
+export type AgentSessionPublishedWork = Pick<
+  StructuredAgentSessionCurrentWork,
+  'publishedLatestTurn' | 'actionablePromptIds' | 'working'
+>
 
 export { AGENT_SESSION_HISTORY_MAX_PAGE_BYTES } from './agent-session-history-page-bounds'
 
@@ -80,19 +89,20 @@ export function readAgentSessionHistory(
   /** Reduced state to read against. A synchronous multi-page catch-up passes one
    *  snapshot for the whole run so each page costs its own rows, not the timeline. */
   snapshot: AgentJournalSnapshot = journal.snapshot(),
-  scope: AgentSessionHistoryScope = 'every-agent'
+  scope: AgentSessionHistoryScope = 'every-agent',
+  work?: AgentSessionPublishedWork
 ): AgentSessionHistoryResult {
   const limit = resolveHistoryLimit(request.limit)
   if (request.direction === 'after') {
-    return readForward(journal, snapshot, request.cursor, limit)
+    return readForward(journal, snapshot, request.cursor, limit, work)
   }
   const cursor = request.direction === 'before' ? request.cursor : undefined
   if (cursor) {
     if (cursor.epoch !== snapshot.cursor.epoch) {
-      return historyReset(snapshot, 'epoch_changed')
+      return historyReset(snapshot, 'epoch_changed', work)
     }
     if (cursor.sequence > snapshot.cursor.sequence) {
-      return historyReset(snapshot, 'cursor_ahead')
+      return historyReset(snapshot, 'cursor_ahead', work)
     }
   }
   const scoped =
@@ -117,7 +127,8 @@ export function readAgentSessionHistory(
       nextCursor: items[0]
         ? { epoch: snapshot.cursor.epoch, sequence: items[0].sequence }
         : undefined,
-      subagentRoster: offPageSubagentRoster(scoped, items)
+      subagentRoster: offPageSubagentRoster(scoped, items),
+      work
     })
   }
 }
@@ -128,7 +139,8 @@ export function readAgentSessionHistory(
  * check re-reduces if anything did advance the journal between pages.
  */
 export function createAgentSessionCatchUpReader(
-  journal: AgentSessionJournal
+  journal: AgentSessionJournal,
+  work?: AgentSessionPublishedWork
 ): (request: AgentSessionHistoryRequest) => AgentSessionHistoryResult {
   let snapshot = journal.snapshot()
   return (request) => {
@@ -136,20 +148,34 @@ export function createAgentSessionCatchUpReader(
     if (live.epoch !== snapshot.cursor.epoch || live.sequence !== snapshot.cursor.sequence) {
       snapshot = journal.snapshot()
     }
-    return readAgentSessionHistory(journal, request, snapshot)
+    return readAgentSessionHistory(journal, request, snapshot, 'every-agent', work)
   }
 }
 
 export function readAgentSessionHydrationPage(
   journal: AgentSessionJournal,
-  fence?: number
+  fence?: number,
+  work?: AgentSessionPublishedWork
 ): AgentSessionHistoryPage {
-  return buildHydrationPage(journal.snapshot(), fence)
+  return buildHydrationPage(journal.snapshot(), fence, work)
+}
+
+/** The current-work fields a page carries, for a frame that carries no page. */
+export function agentSessionPublishedWorkFields(
+  journal: AgentSessionJournal,
+  work: AgentSessionPublishedWork
+): Pick<AgentSessionHistoryPage, 'latestTurn' | 'actionablePromptIds' | 'working'> {
+  return {
+    latestTurn: work.publishedLatestTurn(snapshotLatestTurn(journal.snapshot())),
+    actionablePromptIds: work.actionablePromptIds(),
+    working: work.working()
+  }
 }
 
 function buildHydrationPage(
   snapshot: AgentJournalSnapshot,
-  fence?: number
+  fence?: number,
+  work?: AgentSessionPublishedWork
 ): AgentSessionHistoryPage {
   const items = conversationWindow(snapshot.items, AGENT_SESSION_HISTORY_MAX_LIMIT)
   const bounded = boundHistoryItemsByBytes(
@@ -169,18 +195,20 @@ function buildHydrationPage(
       ? { epoch: snapshot.cursor.epoch, sequence: bounded.items[0].sequence }
       : undefined,
     fence,
-    subagentRoster: offPageSubagentRoster(snapshot.items, bounded.items)
+    subagentRoster: offPageSubagentRoster(snapshot.items, bounded.items),
+    work
   })
 }
 
 function historyReset(
   snapshot: AgentJournalSnapshot,
-  reset: Extract<AgentSessionHistoryResult, { ok: false }>['reset']
+  reset: Extract<AgentSessionHistoryResult, { ok: false }>['reset'],
+  work: AgentSessionPublishedWork | undefined
 ): AgentSessionHistoryResult {
   return {
     ok: false,
     reset,
-    page: buildHydrationPage(snapshot)
+    page: buildHydrationPage(snapshot, undefined, work)
   }
 }
 
@@ -188,18 +216,19 @@ function readForward(
   journal: AgentSessionJournal,
   snapshot: AgentJournalSnapshot,
   cursor: AgentJournalCursor | undefined,
-  limit: number
+  limit: number,
+  work: AgentSessionPublishedWork | undefined
 ): AgentSessionHistoryResult {
   if (!cursor) {
     // Why: forward paging replays rows after a position; without one there is
     // nothing to be after, and silently serving the tail would hand the client
     // a page it cannot place.
-    return historyReset(snapshot, 'cursor_ahead')
+    return historyReset(snapshot, 'cursor_ahead', work)
   }
   // One lookahead preserves hasNewer without rereading the entire remaining journal per page.
   const since = journal.readSince(cursor, limit + 1)
   if (!since.ok) {
-    return historyReset(snapshot, since.reset)
+    return historyReset(snapshot, since.reset, work)
   }
   const submissionBytes = submissionBytesByItemId(snapshot.submissions)
   // The page cost is EVERYTHING variable it carries: items with their
@@ -225,7 +254,7 @@ function readForward(
     canonicalItemId: (itemId) => journal.canonicalItemId(itemId)
   })
   if (!projected.ok) {
-    return historyReset(snapshot, projected.reset)
+    return historyReset(snapshot, projected.reset, work)
   }
   let contentBytes = pageContentBytes(projected.batch.items, projected.batch.removedItemIds)
   while (rows.length > 1 && contentBytes > HISTORY_PAGE_CONTENT_BUDGET_BYTES) {
@@ -237,7 +266,7 @@ function readForward(
       canonicalItemId: (itemId) => journal.canonicalItemId(itemId)
     })
     if (!shrunk.ok) {
-      return historyReset(snapshot, shrunk.reset)
+      return historyReset(snapshot, shrunk.reset, work)
     }
     projected = shrunk
     contentBytes = pageContentBytes(projected.batch.items, projected.batch.removedItemIds)
@@ -257,7 +286,7 @@ function readForward(
     // break the client's keying. A bounded tail replaces the client's state
     // wholesale, which applies the removal without carrying the id, and the
     // client resumes from the live cursor past this row.
-    return historyReset(snapshot, 'cursor_compacted')
+    return historyReset(snapshot, 'cursor_compacted', work)
   }
   const lastSequence = rows.at(-1)?.seq ?? cursor.sequence
   return {
@@ -271,7 +300,8 @@ function readForward(
       hasOlder: cursor.sequence > 0,
       hasNewer: since.rows.length > rows.length,
       fallbackCursor: cursor,
-      nextCursor: { epoch: cursor.epoch, sequence: lastSequence }
+      nextCursor: { epoch: cursor.epoch, sequence: lastSequence },
+      work
     })
   }
 }
@@ -287,6 +317,7 @@ function buildPage(input: {
   nextCursor: AgentJournalCursor | undefined
   fence?: number
   subagentRoster?: AgentSessionSubagentRosterEntry[]
+  work?: AgentSessionPublishedWork
 }): AgentSessionHistoryPage {
   const epoch = input.snapshot.cursor.epoch
   const pageItemIds = new Set(input.items.map((item) => item.itemId))
@@ -311,8 +342,15 @@ function buildPage(input: {
     hasOlder: input.hasOlder,
     hasNewer: input.hasNewer,
     ...(input.subagentRoster === undefined ? {} : { subagentRoster: input.subagentRoster }),
-    // From the whole timeline, never the page: a long turn's record sits below any window.
-    latestTurn: snapshotLatestTurn(input.snapshot)
+    // From the whole timeline, never the page: a long turn's record sits below any window. Scoped
+    // by the host's projection where the reader has one: an ended generation's turn runs nowhere.
+    ...(input.work
+      ? {
+          latestTurn: input.work.publishedLatestTurn(snapshotLatestTurn(input.snapshot)),
+          actionablePromptIds: input.work.actionablePromptIds(),
+          working: input.work.working()
+        }
+      : { latestTurn: snapshotLatestTurn(input.snapshot) })
   }
 }
 
diff --git a/src/main/native-chat/agent-session-wire/agent-session-stop-note-refresh.test.ts b/src/main/native-chat/agent-session-wire/agent-session-stop-note-refresh.test.ts
new file mode 100644
index 00000000000..7a3e6864096
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/agent-session-stop-note-refresh.test.ts
@@ -0,0 +1,97 @@
+// The stop-note refresh frame carries rows, so it restates the host's current work as every rows
+// frame does: a client reads a rows frame without it as an older host's.
+
+import { describe, expect, it } from 'vitest'
+import { agentJournalItemKey } from '../../../shared/agent-session-journal-item-key'
+import type { AgentJournalRenderItem } from '../../../shared/agent-session-journal-types'
+import type { AgentSessionSubscribeEvent } from '../../../shared/agent-session-wire'
+import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
+import { refreshDerivedStopNotes } from './agent-session-stop-note-refresh'
+import { structuredAgentSessionStopNoteIdentity } from './structured-agent-session-command-turn'
+import { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
+import type { Subscriber } from './structured-agent-session-subscribers'
+
+const staleTurn: AgentJournalRenderItem = {
+  itemId: 'turn-old',
+  revision: 1,
+  sequence: 1,
+  observedAt: 1,
+  body: { kind: 'turn', turnId: 't-old', state: 'running', startedAt: 1 }
+}
+const stalePrompt: AgentJournalRenderItem = {
+  itemId: 'prompt-old',
+  revision: 1,
+  sequence: 2,
+  observedAt: 2,
+  body: {
+    kind: 'approval',
+    title: 'Run ls',
+    detail: null,
+    options: [{ id: 'allow', label: 'Allow' }],
+    resolution: { state: 'pending', selectedOptionId: null, resolvedBy: null, resolvedAt: null }
+  }
+}
+const noteId = agentJournalItemKey(structuredAgentSessionStopNoteIdentity('t-old'))
+const unconfirmed = {
+  kind: 'status' as const,
+  text: 'x',
+  failure: { kind: 'cancelUnconfirmed' as const }
+}
+const projectedNote: AgentJournalRenderItem = {
+  itemId: noteId,
+  revision: 2,
+  sequence: 3,
+  observedAt: 3,
+  body: { kind: 'status', text: 'Stopped.' }
+}
+const items = [staleTurn, stalePrompt, projectedNote]
+
+describe('the stop-note refresh frame', () => {
+  it("restates the host's current work", () => {
+    const emitted: AgentSessionSubscribeEvent[] = []
+    const journal = {
+      visitItems: (visit: (itemId: string, sequence: number, body: unknown) => void) =>
+        visit(noteId, 3, unconfirmed),
+      snapshot: () => ({
+        sessionId: 's',
+        cursor: { epoch: 'e', sequence: 3 },
+        items,
+        submissions: []
+      }),
+      itemBody: (itemId: string) => (itemId === noteId ? unconfirmed : null)
+    }
+    // The generation live now is fence 2; both stale items came from fence 1.
+    const work = new StructuredAgentSessionCurrentWork(
+      {
+        runningTurn: () => ({ item: staleTurn, turnId: 't-old' }),
+        itemFence: () => 1,
+        visitItems: (visit) => {
+          for (const item of items) {
+            visit(item.itemId, item.sequence, item.body)
+          }
+        },
+        submissions: () => [],
+        wroteBeforeOpen: () => false
+      },
+      2
+    )
+    const subscriber = { sessionId: 's', cursor: { epoch: 'e', sequence: 3 }, fence: 2 }
+    refreshDerivedStopNotes(
+      { emit: (_subscriber, event) => emitted.push(event), isActive: () => true },
+      // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the refresh reads only the subscriber's session, cursor and fence.
+      subscriber as unknown as Subscriber,
+      // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the refresh reads only visitItems, snapshot and itemBody, all supplied.
+      journal as unknown as AgentSessionJournal,
+      10,
+      work
+    )
+
+    expect(emitted).toHaveLength(1)
+    const frame = emitted[0]
+    if (frame?.type !== 'batch') {
+      throw new Error('expected a batch')
+    }
+    expect(frame.batch.items.length).toBeGreaterThan(0)
+    expect(frame).toMatchObject({ working: false, actionablePromptIds: [], latestTurn: null })
+  })
+})
diff --git a/src/main/native-chat/agent-session-wire/agent-session-stop-note-refresh.ts b/src/main/native-chat/agent-session-wire/agent-session-stop-note-refresh.ts
index 5f86048af0c..83ce92fc7cf 100644
--- a/src/main/native-chat/agent-session-wire/agent-session-stop-note-refresh.ts
+++ b/src/main/native-chat/agent-session-wire/agent-session-stop-note-refresh.ts
@@ -6,16 +6,23 @@ import {
   oversizedHistoryItem
 } from './agent-session-history-page-bounds'
 import { emptyAgentSessionBatch } from './agent-session-empty-batch'
+import {
+  agentSessionPublishedWorkFields,
+  type AgentSessionPublishedWork
+} from './agent-session-history-page'
 import type { SubscriberDeliveryPort } from './agent-session-subscriber-catch-up'
 import type { Subscriber } from './structured-agent-session-subscribers'
 import { isStructuredAgentSessionStopNote } from './structured-agent-session-command-turn'
 
-/** A stale in-flight history page can land after its note's live correction was out of window. */
+/** A stale in-flight history page can land after its note's live correction was out of window.
+ *  `work`: the host's current work, which a frame carrying rows restates, as every such frame does
+ *  (a client reads a rows frame without it as an older host's). */
 export function refreshDerivedStopNotes(
   port: Pick<SubscriberDeliveryPort, 'emit' | 'isActive'>,
   subscriber: Subscriber,
   journal: AgentSessionJournal,
-  hostNow: number
+  hostNow: number,
+  work?: AgentSessionPublishedWork
 ): void {
   let hasUnconfirmedStop = false
   journal.visitItems((itemId, _sequence, body) => {
@@ -39,6 +46,7 @@ export function refreshDerivedStopNotes(
       sessionId: subscriber.sessionId,
       batch: { ...emptyAgentSessionBatch(subscriber.cursor), items: pending },
       fence: subscriber.fence,
+      ...(work ? agentSessionPublishedWorkFields(journal, work) : {}),
       hostNow
     })
     pending = []
diff --git a/src/main/native-chat/agent-session-wire/agent-session-subscriber-catch-up.ts b/src/main/native-chat/agent-session-wire/agent-session-subscriber-catch-up.ts
index df98d8ba902..668c433de9e 100644
--- a/src/main/native-chat/agent-session-wire/agent-session-subscriber-catch-up.ts
+++ b/src/main/native-chat/agent-session-wire/agent-session-subscriber-catch-up.ts
@@ -12,7 +12,11 @@ import {
 import { sameJournalCursor } from '../agent-session-journal/journal-cursor'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
 import { emptyAgentSessionBatch } from './agent-session-empty-batch'
-import { createAgentSessionCatchUpReader } from './agent-session-history-page'
+import {
+  agentSessionPublishedWorkFields,
+  createAgentSessionCatchUpReader
+} from './agent-session-history-page'
+import type { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 import {
   subscriberQueuedMessagesChanged,
   type SubscriberFieldHooks
@@ -22,6 +26,11 @@ import type { Subscriber } from './structured-agent-session-subscribers'
 export type SubscriberDeliveryPort = {
   hooks: SubscriberFieldHooks & {
     readCommands?: (sessionId: string) => AgentSessionSlashCommand[] | undefined
+    /** The host's projection of current work, which every frame's turn and prompt fields state. */
+    readCurrentWork?: (
+      sessionId: string,
+      journal: AgentSessionJournal
+    ) => StructuredAgentSessionCurrentWork | undefined
   }
   emit: (
     subscriber: Subscriber,
@@ -49,12 +58,13 @@ export function deliverToSubscriber(
     hostNow,
     ...(publishedActivity !== undefined ? { activity: publishedActivity } : {})
   }
+  const work = port.hooks.readCurrentWork?.(subscriber.sessionId, journal)
   // Caught up, so there are no rows to read: every publish behind a commit's own delivery.
   if (sameJournalCursor(subscriber.cursor, journal.cursor())) {
-    emitCaughtUp(port, subscriber, emitCheckpoint, shared)
+    emitCaughtUp(port, subscriber, emitCheckpoint, shared, { journal, work })
     return
   }
-  const readPage = createAgentSessionCatchUpReader(journal)
+  const readPage = createAgentSessionCatchUpReader(journal, work)
   while (true) {
     const result = readPage({
       sessionId: subscriber.sessionId,
@@ -73,12 +83,13 @@ export function deliverToSubscriber(
         ...shared
       })
       subscriber.cursor = page.liveCursor ?? page.window.nextCursor
+      subscriber.workView = work?.viewKey()
       return
     }
     const page = result.page
     const advanced = page.window.nextCursor.sequence > subscriber.cursor.sequence
     if (!advanced) {
-      emitCaughtUp(port, subscriber, emitCheckpoint, shared)
+      emitCaughtUp(port, subscriber, emitCheckpoint, shared, { journal, work })
       return
     }
     port.emit(
@@ -94,6 +105,10 @@ export function deliverToSubscriber(
         },
         fence: subscriber.fence,
         ...(page.latestTurn !== undefined ? { latestTurn: page.latestTurn } : {}),
+        ...(page.actionablePromptIds !== undefined
+          ? { actionablePromptIds: page.actionablePromptIds }
+          : {}),
+        ...(page.working !== undefined ? { working: page.working } : {}),
         ...shared
       },
       // On a multi-page catch-up the draft list rides only the final page, or a
@@ -101,6 +116,7 @@ export function deliverToSubscriber(
       { withholdQueued: page.hasNewer }
     )
     subscriber.cursor = page.window.nextCursor
+    subscriber.workView = work?.viewKey()
     if (!page.hasNewer || !port.isActive(subscriber)) {
       return
     }
@@ -114,19 +130,34 @@ function emitCaughtUp(
   shared: {
     hostNow: number
     activity?: AgentSessionTurnActivity | null
-  }
+  },
+  current: { journal: AgentSessionJournal; work: StructuredAgentSessionCurrentWork | undefined }
 ): void {
   const commandsChanged =
     port.hooks.readCommands !== undefined &&
     (port.hooks.readCommands(subscriber.sessionId) ?? null) !== subscriber.commands
   const queuedChanged = subscriberQueuedMessagesChanged(port.hooks, subscriber)
-  if (emitCheckpoint || shared.activity !== undefined || commandsChanged || queuedChanged) {
+  // A generation that ended (or began) with no row, or an exit this host saw with no lease write,
+  // changes what is current: the caught-up frame restates the view.
+  const { work } = current
+  const workChanged = work !== undefined && work.viewKey() !== subscriber.workView
+  if (
+    emitCheckpoint ||
+    shared.activity !== undefined ||
+    commandsChanged ||
+    queuedChanged ||
+    workChanged
+  ) {
     port.emit(subscriber, {
       type: 'batch',
       sessionId: subscriber.sessionId,
       batch: emptyAgentSessionBatch(subscriber.cursor),
       fence: subscriber.fence,
+      ...(workChanged ? agentSessionPublishedWorkFields(current.journal, work) : {}),
       ...shared
     })
+    if (workChanged) {
+      subscriber.workView = work.viewKey()
+    }
   }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-context.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-context.ts
index 12c2f54a179..96681b63f3b 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-context.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-context.ts
@@ -34,6 +34,7 @@ export type StructuredAgentSessionAttachContext = {
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
   now: () => number
   publishStatus: (sessionId: string) => void
+  generationEnded?: StructuredAgentSessionLifetimeContext['generationEnded']
   /** Joining a stop's close ends the child's record through the one exit handler. */
   endExitedChild: StructuredAgentSessionLifetimeContext['endExitedChild']
   wakeDelivery?: StructuredAgentSessionLifetimeContext['wakeDelivery']
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-failure.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-failure.ts
index 06e325fefd3..a8368d06789 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-failure.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-failure.ts
@@ -84,4 +84,6 @@ export function endStructuredAgentSessionReleasedChild(
   context.runtimeState.currentEventSink(sessionId)?.close()
   context.runtimeState.discardEventSink(sessionId)
   context.publishStatus?.(sessionId)
+  // The released acquisition was the live generation: readers and the queued-card drain re-derive.
+  context.generationEnded?.(sessionId)
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
index c3271ff3d47..a437a1db496 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
@@ -36,6 +36,7 @@ import type { StructuredAgentRegistry } from './structured-agent-registry'
 import type { StructuredAgentSessionEventSink } from './structured-agent-session-event-sink'
 import { resolveAgentSessionReplayOutcome } from './structured-agent-session-replay-outcome'
 import { readAgentSessionHydrationPage } from './agent-session-history-page'
+import { heldStructuredAgentSessionCurrentWork } from './structured-agent-session-host-current-work'
 import { acquireOwner } from './structured-agent-session-acquisition'
 import {
   importAdoptedTranscript,
@@ -284,7 +285,12 @@ export async function performAttach(
     value: {
       sessionId,
       fence,
-      page: readAgentSessionHydrationPage(attached.journal, fence),
+      // The lease this attach just took is the live generation.
+      page: readAgentSessionHydrationPage(
+        attached.journal,
+        fence,
+        heldStructuredAgentSessionCurrentWork(store, sessionId, attached.journal, undefined)
+      ),
       unconfirmedClientMessageIds: attached.unconfirmedClientMessageIds,
       ...(tabId ? { tabId } : {})
     }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-background-task-channel.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-background-task-channel.ts
index cf44fc3d66b..0f87c416449 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-background-task-channel.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-background-task-channel.ts
@@ -7,10 +7,7 @@ import type { AgentChildWorkView } from '../../../shared/agent-status-child-work
 import { structuredChildWorkLegacyTasks } from '../../../shared/structured-agent-session-child-work-legacy'
 import { structuredRunningChildWork } from '../../../shared/agent-child-work-listing'
 import { readStructuredAgentSessionHistoryResult } from './structured-agent-session-history-result'
-import {
-  structuredQueueSendGate,
-  tryReadQueuePublication
-} from './structured-agent-session-queued-publication'
+import { hostStructuredAgentSessionCurrentWork } from './structured-agent-session-host-current-work'
 import type { AgentSessionHistoryScope } from './agent-session-history-page'
 import type {
   AgentSessionSubscribers,
@@ -45,17 +42,19 @@ export class StructuredAgentSessionBackgroundTaskChannel {
     scope?: AgentSessionHistoryScope
   ): Promise<AgentSessionHistoryResult> {
     const journal = (await this.conversation(request.sessionId)).journal
+    const work = hostStructuredAgentSessionCurrentWork(
+      { store: this.deps.store, sessions: this.sessions },
+      request.sessionId
+    )
     const result = readStructuredAgentSessionHistoryResult({
       journal,
       record: this.deps.store.getRecord(request.sessionId),
       request,
-      scope
+      scope,
+      ...(work ? { work } : {})
     })
     const backgroundTasks = this.read(request.sessionId)
-    const queue = tryReadQueuePublication(
-      journal,
-      structuredQueueSendGate(this.deps.store, request.sessionId)
-    )
+    const queue = this.subscribers.readQueuePublication(request.sessionId)
     const hostNow = this.deps.now?.() ?? Date.now()
     return {
       ...result,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-chat-stop.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-chat-stop.ts
index b6cd948fa4d..1e508636ebf 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-chat-stop.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-chat-stop.ts
@@ -156,6 +156,8 @@ export function mutateWithChatStop<TValue>(
                 windDown = { owed, ctx }
               },
               withdrewQueued: withdrew,
+              noteFence: () =>
+                context.deps.store.getRecord(sessionId)?.lease.runtimeFence ?? ctx.fence,
               ...(ownsLatestStop ? { opensSettle: true as const } : {})
             }
           )
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-child-exit.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-child-exit.ts
index 694268a1f8b..e9fcdf06309 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-child-exit.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-child-exit.ts
@@ -15,7 +15,7 @@ import type {
   StructuredAgentSessionHostSession,
   StructuredAgentSessionProviderChild
 } from './structured-agent-session-host-types'
-import { endProviderChild } from './structured-agent-session-provider-child'
+import { recordProviderChildEnd } from './structured-agent-session-provider-child'
 import {
   releaseStoredStructuredAgentSessionOwnerAfterExit,
   type StructuredAgentSessionLeaseStore
@@ -49,14 +49,23 @@ export type StructuredAgentSessionChildExitSession = Pick<
   'child' | 'lastEndedChild'
 > & { journal: DeadGenerationJournal & Pick<AgentSessionJournal, 'cursor' | 'itemBody'> }
 
+/** The one edge every way a generation ends goes through
+ *  (`StructuredAgentSessionClientDelivery.publishGenerationEnded`). */
+export type StructuredAgentSessionGenerationEnded = (
+  sessionId: string,
+  options?: { restate?: boolean }
+) => void
+
 export type StructuredAgentSessionChildExitContext<
   TSession extends StructuredAgentSessionChildExitSession = StructuredAgentSessionHostSession
 > = {
   store: StructuredAgentSessionLeaseStore
   sessions: Map<string, TSession>
   flushLifecycle: (sessionId: string) => Promise<StructuredAgentSessionSinkBarrier>
-  publishFence: (sessionId: string, session: TSession) => void
   publishStatus?: (sessionId: string) => void
+  /** A generation ended: every reader re-derives current work and the queued-card drain is
+   *  scheduled, with no journal write needed. `restate`: each chat re-baselines at the moved fence. */
+  generationEnded: StructuredAgentSessionGenerationEnded
   /** The delivery loop hands over whatever is queued once the child is off the record. */
   wakeDelivery?: (sessionId: string) => void
   /** An ended child's start, if still open, has nothing left to time. */
@@ -145,20 +154,27 @@ export async function endExitedStructuredAgentSessionChildUnderSerialize<
         ? ('hostRestarted' as const)
         : ('chatClosed' as const)
       : undefined
+  // Death first: before the tail, the settlement or the release writes anything, every reader
+  // projects this generation as ended, so no frame they publish reads it Working and no prompt it
+  // raised is answerable. The child stays on record (its sink drains the tail) until `endChild`.
+  recordProviderChildEnd(session, {
+    generation: child.generation,
+    fence: child.fence,
+    // A close keeps the cause of the stop that asked for it, and ends where it was asked.
+    cause: expected ? (close?.cause ?? 'evict') : 'exit',
+    reason: expected ? (close?.reason ?? null) : exit.reason,
+    ...(!expected && exit.failure ? { failure: exit.failure } : {}),
+    duringStartup: exitedDuringStartup,
+    // The adapter publishes an exit only once it saw the root go, first-hand or proven.
+    rootGone: true,
+    ...(expected && close ? { endedAt: close.requestedAt } : {})
+  })
+  context.generationEnded(sessionId)
   const endChild = (): void => {
     context.startupAttempts?.childEnded(sessionId, child)
-    endProviderChild(session, {
-      generation: child.generation,
-      fence: child.fence,
-      // A close keeps the cause of the stop that asked for it, and ends where it was asked.
-      cause: expected ? (close?.cause ?? 'evict') : 'exit',
-      reason: expected ? (close?.reason ?? null) : exit.reason,
-      ...(!expected && exit.failure ? { failure: exit.failure } : {}),
-      duringStartup: exitedDuringStartup,
-      // The adapter publishes an exit only once it saw the root go, first-hand or proven.
-      rootGone: true,
-      ...(expected && close ? { endedAt: close.requestedAt } : {})
-    })
+    if (session.child === child) {
+      session.child = null
+    }
     context.publishStatus?.(sessionId)
   }
   const record = context.store.getRecord(sessionId)
@@ -256,10 +272,10 @@ export async function endExitedStructuredAgentSessionChildUnderSerialize<
     }
     endChild()
     // A reader re-baselines on a death of the child's own; a close Orca asked for moves no fence a
-    // reader holds, as a client resends a message when its fence moves.
-    if (released && !expected) {
-      context.publishFence(sessionId, session)
-    }
+    // reader holds, as a client resends a message when its fence moves, and discards a reply (the
+    // Stop's own) issued at the fence before. Either way every reader learns the generation ended
+    // and the queued-card drain runs, whether or not the release or the settlement was written.
+    context.generationEnded(sessionId, { restate: released && !expected })
     context.wakeDelivery?.(sessionId)
   }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-claude-root-exit.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-claude-root-exit.test.ts
index 2ea3a16024b..35763ea56a3 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-claude-root-exit.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-claude-root-exit.test.ts
@@ -145,7 +145,7 @@ describe('Claude root-exit stop', () => {
                 store,
                 sessions,
                 flushLifecycle: (id) => runtimeState.lifecycleBarrier(id),
-                publishFence: () => undefined,
+                generationEnded: () => undefined,
                 publishStatus,
                 serialize: (_sessionId, task) => task(),
                 now: () => NOW + 30 * 60_000,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-client-delivery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-client-delivery.ts
index c369ce1a560..634b501be00 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-client-delivery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-client-delivery.ts
@@ -15,6 +15,8 @@ import type {
 } from './structured-agent-session-host-types'
 import { AGENT_SESSION_NOT_ATTACHED } from './structured-agent-session-mutation-admission'
 import { StructuredAgentSessionSendSettlement } from './structured-agent-session-send-settlement'
+import { heldStructuredAgentSessionCurrentWork } from './structured-agent-session-host-current-work'
+import { structuredAgentSessionConversationFence } from './structured-agent-session-provider-child'
 import type { StructuredAgentSessionStatusSubscriber } from './structured-agent-session-status-feed'
 import { createStructuredAgentSessionHostStatusFeed } from './structured-agent-session-host-status-feed'
 import {
@@ -35,7 +37,11 @@ export class StructuredAgentSessionClientDelivery {
     private readonly sessions: Map<string, StructuredAgentSessionHostSession>,
     now: () => number,
     private readonly deps: () => StructuredAgentSessionHostDeps,
-    private readonly onJournalActivity: (sessionId: string) => void,
+    /** The queued-card drain: every publish wakes it (`activity`: a journal write, which renews the
+     *  idle clock; a generation's end is not one). */
+    private readonly queue: {
+      onJournalActivity: (sessionId: string, activity?: boolean) => void
+    },
     onAgentStarted: (sessionId: string) => void,
     /** A session's child records changed; the chat strip republishes from them. */
     onChildWorkChanged: (sessionId: string) => void,
@@ -56,7 +62,7 @@ export class StructuredAgentSessionClientDelivery {
         this.statusFeed.journalProjection(sessionId, journal)?.state ?? null
     })
     this.sendSettlement = new StructuredAgentSessionSendSettlement((sessionId) =>
-      this.requireJournal(sessionId)
+      this.settlementReading(sessionId, this.requireJournal(sessionId))
     )
     this.waitForSendSettlement = this.sendSettlement.wait
     this.subscribers = new AgentSessionSubscribers({
@@ -64,10 +70,11 @@ export class StructuredAgentSessionClientDelivery {
       readQueuePublication: (sessionId) =>
         tryReadQueuePublication(
           sessions.get(sessionId)?.journal,
-          structuredQueueSendGate(this.deps().store, sessionId)
+          structuredQueueSendGate({ store: this.deps().store, sessions }, sessionId)
         ),
       readBackgroundTasks,
-      onJournalPublished: (sessionId, journal) => this.publishJournal(sessionId, journal)
+      onJournalPublished: (sessionId, journal) => this.publishJournal(sessionId, journal),
+      readCurrentWork: (sessionId, journal) => this.currentWork(sessionId, journal)
     })
   }
 
@@ -110,10 +117,35 @@ export class StructuredAgentSessionClientDelivery {
     this.statusFeed.publish(sessionId)
     const journal = this.sessions.get(sessionId)?.journal
     if (journal) {
-      this.sendSettlement.publish(sessionId, journal)
+      this.sendSettlement.publish(sessionId, this.settlementReading(sessionId, journal))
     }
   }
 
+  /** A generation ended — an exit, a release — which can change what is current with no journal
+   *  row. The one edge for every way a generation ends: every reader re-derives current work (the
+   *  status feed, settlement waits, each chat's frames) and the queued-card drain is scheduled,
+   *  whatever became of the cleanup's own write. An end is no activity: it renews no idle clock.
+   *  `restate`: each chat re-baselines at the fence, as a death of the child's own does. */
+  publishGenerationEnded = (sessionId: string, options: { restate?: boolean } = {}): void => {
+    const journal = this.sessions.get(sessionId)?.journal
+    if (!journal) {
+      return
+    }
+    if (options.restate) {
+      const fence = structuredAgentSessionConversationFence(this.deps().store, sessionId)
+      this.subscribers.snapshot(sessionId, journal, fence)
+      return
+    }
+    this.subscribers.deliverFrames(sessionId, journal)
+    this.publishJournal(sessionId, journal, false)
+  }
+
+  /** A held chat's current work (`structuredAgentSessionCurrentWork`); null when none is held. */
+  readCurrentWork = (sessionId: string) => {
+    const journal = this.sessions.get(sessionId)?.journal
+    return journal ? this.currentWork(sessionId, journal) : null
+  }
+
   publishRestored = (sessionId: string): void => {
     this.statusFeed.publish(sessionId, undefined, { replay: true })
     this.turnCompletionFeed.observe(sessionId, undefined, { historical: true })
@@ -148,14 +180,28 @@ export class StructuredAgentSessionClientDelivery {
     this.sendSettlement.closeAll()
   }
 
-  private publishJournal(sessionId: string, journal: AgentSessionJournal): void {
+  private publishJournal(sessionId: string, journal: AgentSessionJournal, activity = true): void {
     this.statusFeed.publish(sessionId, journal)
-    this.sendSettlement.publish(sessionId, journal)
+    this.sendSettlement.publish(sessionId, this.settlementReading(sessionId, journal))
     // Derived here rather than per-subscriber: this edge runs whether or not anyone is
     // subscribed, which is the whole reason a backgrounded chat can complete at all. After the
     // status publish, so it reads the projection that publish cached.
     this.turnCompletionFeed.observe(sessionId, journal)
-    this.onJournalActivity(sessionId)
+    this.queue.onJournalActivity(sessionId, activity)
+  }
+
+  /** The current-work projection over this journal (`structuredAgentSessionCurrentWork`). */
+  private currentWork(sessionId: string, journal: AgentSessionJournal) {
+    const session = this.sessions.get(sessionId)
+    return heldStructuredAgentSessionCurrentWork(this.deps().store, sessionId, journal, session)
+  }
+
+  private settlementReading(sessionId: string, journal: AgentSessionJournal) {
+    return {
+      submissions: () => journal.submissions(),
+      cursor: () => journal.cursor(),
+      activeTurnId: () => this.currentWork(sessionId, journal).activeTurnId()
+    }
   }
 
   private requireJournal(sessionId: string): AgentSessionJournal {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-command-turn.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-command-turn.ts
index 30810b9b9f3..302bc99646a 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-command-turn.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-command-turn.ts
@@ -44,6 +44,10 @@ import type { StructuredAgentRegistry } from './structured-agent-registry'
 import { conversationCommandBlocked } from './structured-conversation-command-admission'
 import { structuredAgentSessionCommandTurn } from '../../../shared/structured-agent-session-command-turn-identity'
 import { refuseQueuedCommand } from './structured-agent-session-queued-command-refusal'
+import {
+  contextStructuredAgentSessionCurrentWork,
+  type StructuredAgentSessionCurrentWork
+} from './structured-agent-session-current-work'
 
 export { structuredAgentSessionCommandTurn } from '../../../shared/structured-agent-session-command-turn-identity'
 
@@ -90,11 +94,12 @@ export function structuredAgentSessionAwaitedCommand(
     : undefined
 }
 
-/** Whether the journal's running turn is a command's, which takes no input while it runs. */
+/** Whether the live generation's running turn is a command's, which takes no input while it runs
+ *  (`structuredAgentSessionCurrentWork`). */
 export function structuredAgentSessionCommandRunning(
-  journal: Pick<AgentSessionJournal, 'activeTurnId'>
+  work: Pick<StructuredAgentSessionCurrentWork, 'activeTurnId'>
 ): boolean {
-  const turnId = journal.activeTurnId()
+  const turnId = work.activeTurnId()
   return turnId !== null && isStructuredAgentSessionCommandTurnId(turnId)
 }
 
@@ -220,7 +225,8 @@ async function openCommandTurn(
     clientMessageId,
     state: 'pending',
     fence: ctx.fence,
-    turnScope: ctx.journal.liveTurnScope()
+    // The child it goes to is live at `fence`: an ended generation's turn is not joined.
+    turnScope: contextStructuredAgentSessionCurrentWork(ctx).turnScope()
   })
   const startedAt = ctx.now()
   const running = agentJournalTurnBody({
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-conversation-lifetime.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-conversation-lifetime.ts
index 431ca9e761d..bba4aeec2ca 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-conversation-lifetime.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-conversation-lifetime.ts
@@ -84,6 +84,10 @@ export function createStructuredAgentSessionConversationLifetime(host: {
     isDisposed: () => disposed,
     deliveryActive: host.deliveryActive,
     childWork: host.readChildWork,
+    store: {
+      getRecord: (sessionId) => deps().store.getRecord(sessionId),
+      replacedRuntime: (sessionId) => deps().store.replacedRuntime(sessionId)
+    },
     hasOpenDispatch: (sessionId) => {
       const record = deps().store.getRecord(sessionId)
       return record !== null && deps().hasOpenDispatch?.(record) === true
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-current-work.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-current-work.test.ts
new file mode 100644
index 00000000000..bdd580d7dc9
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-current-work.test.ts
@@ -0,0 +1,274 @@
+// The host's one projection of current work (`structuredAgentSessionCurrentWork`), end to end
+// against the real host, store and SQLite journal: what an ended generation left holds nothing and
+// reads as nothing to every host reader (the projection, the session list, the frames and pages a
+// chat client is sent, Stop, the queue), whether or not its cleanup landed, while a live owner's
+// work holds exactly as before.
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { agentJournalItemKey } from '../../../shared/agent-session-journal-item-key'
+import type { AgentSessionExecutionLocation } from '../../../shared/agent-session-record'
+import type {
+  AgentSessionStatusSummary,
+  AgentSessionSubscribeEvent
+} from '../../../shared/agent-session-wire'
+import { agentSessionRecordFixture } from '../../../shared/agent-session-record.test-fixture'
+import {
+  liveTestJournalRows,
+  openTestJournalHostDatabase
+} from '../agent-session-journal/journal-host-database-test-support'
+import { HOST_TEST_SESSION as SESSION } from './structured-agent-session-host-test-data'
+import {
+  createQueuedMessageTestRig,
+  type QueuedMessageTestRig
+} from './structured-agent-session-queued-message-rig.test-fixture'
+import {
+  APPROVAL,
+  currentJournal,
+  currentWork,
+  exitWhileSettlementFails,
+  leaveUnfinishedWork,
+  REJECT_RECOVERED_ROWS,
+  sendText,
+  turnState
+} from './structured-agent-session-leftover-settlement.test-fixture'
+import { structuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
+
+let rig: QueuedMessageTestRig | undefined
+
+afterEach(async () => {
+  await rig?.dispose()
+  rig = undefined
+  vi.restoreAllMocks()
+})
+
+const APPROVAL_ID = agentJournalItemKey(APPROVAL)
+const FOLDER: AgentSessionExecutionLocation = {
+  executionHostId: 'local',
+  wslDistro: null,
+  workspaceId: 'folder-1',
+  workspaceKind: 'folder'
+}
+
+type HostWork = Pick<
+  Extract<AgentSessionSubscribeEvent, { type: 'batch' }>,
+  'latestTurn' | 'actionablePromptIds' | 'working'
+>
+
+/** A chat subscriber and the session list, each fed by the host as a real one is: the subscriber
+ *  keeps the current-work fields of the newest frame or page that stated them. */
+function watch(current: QueuedMessageTestRig) {
+  let work: HostWork = {}
+  let listed: AgentSessionStatusSummary | undefined
+  current.host.subscribe({
+    id: 'chat-1',
+    sessionId: SESSION,
+    emit: (event) => {
+      const fields =
+        event.type === 'snapshot' ? event.page : event.type === 'batch' ? event : undefined
+      if (fields?.working !== undefined) {
+        const { latestTurn, actionablePromptIds, working } = structuredClone(fields)
+        work = { latestTurn, actionablePromptIds, working }
+      }
+    }
+  })
+  current.host.subscribeStatus({
+    id: 'list-1',
+    emit: (event) => {
+      if (event.type === 'status' && event.session.sessionId === SESSION) {
+        listed = structuredClone(event.session)
+      } else if (event.type === 'snapshot') {
+        listed = event.sessions.find((session) => session.sessionId === SESSION) ?? listed
+      }
+    }
+  })
+  return { work: () => work, listed: () => listed }
+}
+
+/** The tail page a client hydrates from. */
+async function hydration(current: QueuedMessageTestRig) {
+  const page = await current.host.history({ sessionId: SESSION, direction: 'tail' })
+  if (!page.ok) {
+    throw new Error('history refused')
+  }
+  return page.page
+}
+
+async function deadGenerationWithFailedSettlement(location?: typeof FOLDER) {
+  rig = await createQueuedMessageTestRig({
+    restartable: true,
+    ...(location ? { location } : {})
+  })
+  const current = rig
+  await current.workingSend()
+  await leaveUnfinishedWork(current, { prompt: true })
+  const view = watch(current)
+  const exited = await exitWhileSettlementFails(current)
+  return { current, view, ...exited }
+}
+
+describe("a dead generation's leftovers, its settlement refused and its lease released", () => {
+  it.each([
+    ['a git worktree', undefined],
+    ['a folder workspace', FOLDER]
+  ])('in %s, read as nothing by every reader, and hold nothing', async (_name, location) => {
+    const { current, view } = await deadGenerationWithFailedSettlement(location)
+    // Still saved as running and pending: only a settlement would end them.
+    expect(turnState(current)).toBe('running')
+    const work = currentWork(current)
+
+    expect(work.liveFence).toBeNull()
+    expect(work.working()).toBe(false)
+    expect(work.actionablePromptIds()).toEqual([])
+    expect(view.listed()?.status).not.toBe('working')
+    expect(current.host.readStatusSummary(SESSION)?.status).not.toBe('working')
+    // A client hydrating now, and the one already watching, read the same.
+    const page = await hydration(current)
+    // Read interrupted, as its settlement will write it: never running, never finished.
+    expect(page.latestTurn?.turn.state).toBe('interrupted')
+    expect(page.actionablePromptIds).toEqual([])
+    expect(page.working).toBe(false)
+    await vi.waitFor(() =>
+      expect(view.work()).toMatchObject({ actionablePromptIds: [], working: false })
+    )
+    expect(view.work().latestTurn?.turn.state).not.toBe('running')
+  })
+
+  it('gives Stop nothing to stop: the dead turn is not touched', async () => {
+    const { current } = await deadGenerationWithFailedSettlement()
+
+    await current.stop()
+
+    expect(current.cancelTurn).not.toHaveBeenCalled()
+    expect(turnState(current)).toBe('running')
+  })
+})
+
+describe('a close Orca asked for, its settlement refused', () => {
+  it('tells a watching client the turn and prompt are over, with no row to carry it', async () => {
+    rig = await createQueuedMessageTestRig({ restartable: true })
+    const current = rig
+    await current.workingSend()
+    await leaveUnfinishedWork(current, { prompt: true })
+    const view = watch(current)
+    await vi.waitFor(() => expect(view.work().actionablePromptIds).toEqual([APPROVAL_ID]))
+    const database = openTestJournalHostDatabase(current.root)
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+    database.db.exec(REJECT_RECOVERED_ROWS)
+    const before = currentJournal(current).cursor().sequence
+    const child = current.host.collaboratorsForTests().sessions.get(SESSION)?.child
+    if (!child?.generation) {
+      throw new Error('expected the live child')
+    }
+
+    await current.host.handleAdapterEvent({
+      type: 'ended',
+      sessionId: SESSION,
+      cause: 'requested-close',
+      reason: 'closed by Orca',
+      fence: child.fence,
+      acquisitionGeneration: child.generation
+    })
+    await current.host.collaboratorsForTests().serialize(SESSION, async () => {})
+
+    expect(currentJournal(current).cursor().sequence).toBe(before)
+    expect(turnState(current)).toBe('running')
+    await vi.waitFor(() =>
+      expect(view.work()).toMatchObject({ actionablePromptIds: [], working: false })
+    )
+    expect(view.work().latestTurn?.turn.state).not.toBe('running')
+    expect(view.listed()?.status).not.toBe('working')
+  })
+})
+
+describe('a waiting card when the generation ahead of it ends', () => {
+  it.each([
+    ['an exit of its own, its settlement refused', 'unexpected-exit' as const],
+    ['a close Orca asked for', 'requested-close' as const]
+  ])('drains after %s, with no journal write in between', async (_name, cause) => {
+    rig = await createQueuedMessageTestRig({ restartable: true })
+    const current = rig
+    await current.workingSend()
+    await leaveUnfinishedWork(current)
+    const queued = await sendText(current, 'behind the turn').result
+    expect(queued).toMatchObject({ ok: true, value: { queued: expect.anything() } })
+    const journal = currentJournal(current)
+    const [card] = journal.queuedMessages.list()
+    expect(card?.state).toBe('waiting')
+    const database = openTestJournalHostDatabase(current.root)
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+    database.db.exec(REJECT_RECOVERED_ROWS)
+    const before = journal.cursor().sequence
+    const child = current.host.collaboratorsForTests().sessions.get(SESSION)?.child
+    if (!child?.generation) {
+      throw new Error('expected the live child')
+    }
+
+    await current.host.handleAdapterEvent({
+      type: 'ended',
+      sessionId: SESSION,
+      cause,
+      reason: 'ended',
+      fence: child.fence,
+      acquisitionGeneration: child.generation
+    })
+
+    await vi.waitFor(() =>
+      expect(journal.queuedMessages.get(card?.messageId ?? '')?.state).toBe('dispatched')
+    )
+    // The first row after the end is the drain's own hand-off: nothing was written to wake it.
+    const first = liveTestJournalRows(database.db, SESSION).find((row) => row.seq > before)
+    expect(JSON.parse(first?.rowJson ?? '{}')).toMatchObject({
+      kind: 'submission',
+      queuedMessageId: card?.messageId
+    })
+  })
+})
+
+describe('a live owner', () => {
+  it('publishes its running turn and its prompt exactly as before', async () => {
+    rig = await createQueuedMessageTestRig({ restartable: true })
+    const current = rig
+    await current.workingSend()
+    await leaveUnfinishedWork(current, { prompt: true })
+    const view = watch(current)
+
+    const work = currentWork(current)
+    expect(work.liveFence).toBe(current.store.getRecord(SESSION)?.lease.runtimeFence)
+    expect(work.activeTurnId()).toBe('unfinished')
+    expect(work.actionablePromptIds()).toEqual([APPROVAL_ID])
+    const page = await hydration(current)
+    expect(page.latestTurn?.turn).toMatchObject({ turnId: 'unfinished', state: 'running' })
+    expect(page.actionablePromptIds).toEqual([APPROVAL_ID])
+    expect(page.working).toBe(true)
+    await vi.waitFor(() => expect(view.work().actionablePromptIds).toEqual([APPROVAL_ID]))
+    expect(view.work()).toMatchObject({
+      working: true,
+      latestTurn: { turn: { turnId: 'unfinished', state: 'running' } }
+    })
+    expect(view.listed()?.status).not.toBe('idle')
+  })
+})
+
+describe('an owner whose adjudication concludes with no row written', () => {
+  it('changes the published answer when it goes from unverifiable to released', () => {
+    const journal = {
+      runningTurn: () => null,
+      itemFence: () => undefined,
+      visitItems: () => undefined,
+      submissions: () => [],
+      wroteBeforeOpen: () => false
+    }
+    const record = agentSessionRecordFixture()
+    const unverifiable = structuredAgentSessionCurrentWork(journal, {
+      record: { lease: { ...record.lease, unreconciled: true } },
+      child: null
+    })
+    const released = structuredAgentSessionCurrentWork(journal, {
+      record: { lease: { ...record.lease, claimStatus: 'released' } },
+      child: null
+    })
+
+    expect(unverifiable.liveFence).toBe(released.liveFence)
+    expect(unverifiable.viewKey()).not.toBe(released.viewKey())
+  })
+})
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-current-work.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-current-work.ts
new file mode 100644
index 00000000000..2cee82ca63f
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-current-work.ts
@@ -0,0 +1,268 @@
+// The host's one operational projection of a chat's current work: the live generation's running
+// turn, the prompts it raised that still wait on the person, the sends it owes, and the queued
+// sends this process may hand over. Every host reader asks here; none keeps a rule of its own.
+//
+// Derived on every read, never stored, from what the host already holds:
+//  - the lease: the live or reserved generation's fence; none once it is released;
+//  - this host's own sight of that generation's root exit, which ends it even when the release
+//    write failed (`lastEndedChild`);
+//  - the Orca runtimes this one replaced (`AgentSessionRecordStore.replacedRuntime`): a generation
+//    one of them held lost its pipes with it, so it is over before any startup write says so;
+//  - the journal's fold, where every item carries the generation that produced it (`ownerFence`).
+// So work an ended generation left holds nothing and is not Working whether or not its cleanup
+// landed: cleanup is bookkeeping and never gates what the person does next. Loss of contact is
+// never an end: an unreconciled or conflicted lease keeps its fence, and its work stays current, unless
+// a runtime this one replaced held it, which is this host's own proof.
+
+import {
+  AGENT_JOURNAL_THREAD_SCOPE,
+  type AgentJournalRenderItem,
+  type AgentJournalSubmission,
+  type AgentJournalTurnScope
+} from '../../../shared/agent-session-journal-types'
+import { isQueuedAgentJournalSubmission } from '../../../shared/agent-session-queued-submission'
+import type { AgentSessionRecord } from '../../../shared/agent-session-record'
+import type { AgentSessionLatestTurn } from '../../../shared/agent-session-wire'
+import type { StructuredAgentSessionWorkScope } from '../../../shared/structured-agent-session-main-agent-working'
+import { isUnansweredStructuredAgentSessionDispatch } from '../../../shared/structured-agent-session-unanswered-dispatch'
+import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
+
+export type StructuredAgentSessionCurrentWorkJournal = Pick<
+  AgentSessionJournal,
+  'runningTurn' | 'itemFence' | 'visitItems' | 'submissions' | 'wroteBeforeOpen'
+>
+
+/** What the host knows of who runs the chat now. */
+export type StructuredAgentSessionWorkEvidence = {
+  record: Pick<AgentSessionRecord, 'lease'> | null
+  /** The last child this host saw end (`StructuredAgentSessionHostSession.lastEndedChild`). */
+  ended?: StructuredAgentSessionSeenEnd
+  /** `StructuredAgentSessionHostSession.operationalRevision`. */
+  revision?: number
+  /** The runtimes this one replaced for the chat (`AgentSessionRecordStore.replacedRuntime`). */
+  replaced?: StructuredAgentSessionReplacedEnd | undefined
+  /** This host's live child (`StructuredAgentSessionHostSession.child`); absent: not known. */
+  child?: { fence: number } | null
+}
+
+/** Every fence at or below `fence` was granted by a runtime this one replaced. */
+type StructuredAgentSessionReplacedEnd = { fence: number }
+
+type StructuredAgentSessionSeenEnd = { fence: number; rootGone?: boolean; cause?: string }
+
+/** The live or reserved generation's fence, or null when no generation is live. With no record
+ *  nothing has ended: fence 0, under which every item is current, as before records scoped work. */
+export function structuredAgentSessionLiveFence(
+  evidence: StructuredAgentSessionWorkEvidence
+): number | null {
+  const lease = evidence.record?.lease
+  if (!lease) {
+    return 0
+  }
+  if (lease.claimStatus === 'released') {
+    return null
+  }
+  if (
+    structuredAgentSessionReplacedRuntimeEnded(lease, evidence.replaced) ||
+    structuredAgentSessionOwnerUnverifiable(evidence)
+  ) {
+    return null
+  }
+  const { ended } = evidence
+  return ended?.rootGone === true && ended.fence === lease.runtimeFence ? null : lease.runtimeFence
+}
+
+/** An owner not yet reconciled, or latched in recovery, that this process holds no child for: it
+ *  may still be running, so its turn is unverifiable, and nothing it left is current work. */
+function structuredAgentSessionOwnerUnverifiable(evidence: StructuredAgentSessionWorkEvidence) {
+  const lease = evidence.record?.lease
+  return (
+    (lease?.unreconciled === true || lease?.handoffStage === 'recovering') &&
+    evidence.child !== undefined &&
+    evidence.child?.fence !== lease.runtimeFence
+  )
+}
+
+/** Whether a runtime this one replaced granted the lease's generation, which is then over. A
+ *  conflicted claim's agent is a terminal's, which no runtime's pipes held. */
+export function structuredAgentSessionReplacedRuntimeEnded(
+  lease: Pick<AgentSessionRecord['lease'], 'runtimeFence' | 'claimStatus'>,
+  replaced: StructuredAgentSessionReplacedEnd | undefined
+): boolean {
+  return (
+    replaced !== undefined &&
+    lease.runtimeFence <= replaced.fence &&
+    lease.claimStatus !== 'conflicted'
+  )
+}
+
+/** `StructuredAgentSessionCurrentWork.handsOver`, for a reader that needs no other answer. */
+export function structuredAgentSessionHandsOver(
+  journal: Pick<AgentSessionJournal, 'wroteBeforeOpen'>,
+  submission: Pick<
+    AgentJournalSubmission,
+    'handoverRecorded' | 'dispatchState' | 'handedOverAt' | 'acceptedSequence'
+  >
+): boolean {
+  return (
+    isQueuedAgentJournalSubmission(submission) &&
+    !journal.wroteBeforeOpen(submission.acceptedSequence)
+  )
+}
+
+/** One read of a chat's current work; build a fresh one per decision, since nothing is cached. */
+export class StructuredAgentSessionCurrentWork {
+  /** The shared projections' form of this answer (`StructuredAgentSessionWorkScope`). */
+  readonly scope: StructuredAgentSessionWorkScope = {
+    isCurrentItem: (itemId) => this.isCurrentItem(itemId),
+    owesSend: (submission) => this.owesSend(submission)
+  }
+
+  constructor(
+    private readonly journal: StructuredAgentSessionCurrentWorkJournal,
+    /** `structuredAgentSessionLiveFence`. */
+    readonly liveFence: number | null,
+    /** Moves with every generation end this host saw, lease write or not: a reader that caches
+     *  what it derived from this answer keys it here and on the journal's cursor. */
+    readonly revision = 0,
+    private readonly ended?: StructuredAgentSessionSeenEnd,
+    private readonly replaced?: StructuredAgentSessionReplacedEnd,
+    /** `structuredAgentSessionOwnerUnverifiable`. */
+    private readonly ownerUnverifiable = false
+  ) {}
+
+  /** What a reader that published this answer compares to learn it changed with no row: the live
+   *  generation, since every answer here is the journal read through it. Not the revision, which
+   *  moves on every generation-end signal: an end that changed nothing is published once. */
+  viewKey(): string {
+    return `${this.liveFence}${this.ownerUnverifiable ? ':unverifiable' : ''}`
+  }
+
+  /** Whether the live generation's execution produced this item. */
+  isCurrentItem(itemId: string): boolean {
+    if (this.liveFence === null) {
+      return false
+    }
+    const provenance = this.journal.itemFence(itemId)
+    return provenance === undefined || provenance >= this.liveFence
+  }
+
+  /** Whether this process may hand this send over: accepted here, never by an earlier host process.
+   *  Derived from where the row sits, so nothing has to be written first; keeping an earlier
+   *  process's send as a card is the reconciliation pass's bookkeeping (`holdUnsentSends`). */
+  handsOver(submission: AgentJournalSubmission): boolean {
+    return structuredAgentSessionHandsOver(this.journal, submission)
+  }
+
+  /** A send still owed: one this process may hand over, or one handed to the live generation that
+   *  it has neither answered nor refused (`isUnansweredStructuredAgentSessionDispatch`). */
+  owesSend(submission: AgentJournalSubmission): boolean {
+    if (isQueuedAgentJournalSubmission(submission)) {
+      return this.handsOver(submission)
+    }
+    return (
+      this.liveFence !== null &&
+      isUnansweredStructuredAgentSessionDispatch(submission, this.liveFence)
+    )
+  }
+
+  /** The live generation's running turn, with its record's item. */
+  activeTurn(): { item: AgentJournalRenderItem; turnId: string } | null {
+    const running = this.journal.runningTurn()
+    return running && this.isCurrentItem(running.item.itemId) ? running : null
+  }
+
+  activeTurnId(): string | null {
+    return this.activeTurn()?.turnId ?? null
+  }
+
+  /** Where a row written now joins: the live generation's running turn, else the conversation. */
+  turnScope(): AgentJournalTurnScope {
+    const running = this.activeTurn()
+    return running ? { kind: 'turn', turnItemId: running.item.itemId } : AGENT_JOURNAL_THREAD_SCOPE
+  }
+
+  /** The approvals and questions the live generation raised that wait on the person, a
+   *  subagent's included. */
+  actionablePromptIds(): string[] {
+    const ids: string[] = []
+    this.journal.visitItems((itemId, _sequence, body) => {
+      if (
+        (body.kind === 'approval' || body.kind === 'question') &&
+        body.resolution.state === 'pending' &&
+        this.isCurrentItem(itemId)
+      ) {
+        ids.push(itemId)
+      }
+    })
+    return ids
+  }
+
+  hasActionablePrompt(): boolean {
+    return this.actionablePromptIds().length > 0
+  }
+
+  owesAnySend(): boolean {
+    return this.journal.submissions().some((submission) => this.owesSend(submission))
+  }
+
+  /** The session's own agent is working: its running turn, or a send it owes. */
+  working(): boolean {
+    return this.activeTurnId() !== null || this.owesAnySend()
+  }
+
+  /** The running turn of a generation this host saw die on its own (its root gone, nobody asked),
+   *  or that a runtime this one replaced held: its settlement writes it interrupted, so it reads so
+   *  before that lands. */
+  diedTurn(): { item: AgentJournalRenderItem; turnId: string } | null {
+    const running = this.journal.runningTurn()
+    if (!running || this.isCurrentItem(running.item.itemId)) {
+      return null
+    }
+    const fence = this.journal.itemFence(running.item.itemId)
+    const { ended, replaced } = this
+    const died = ended?.rootGone === true && ended.cause === 'exit' && fence === ended.fence
+    return died || (replaced !== undefined && fence !== undefined && fence <= replaced.fence)
+      ? running
+      : null
+  }
+
+  /** The newest turn record as a client is told it: a running one an ended generation opened is
+   *  none, interrupted when it died on its own (`diedTurn`), or unverifiable while its owner is, so
+   *  no client reads it as working, steers into it or reads it finished. */
+  publishedLatestTurn(latest: AgentSessionLatestTurn | null): AgentSessionLatestTurn | null {
+    if (latest?.turn.state !== 'running' || this.isCurrentItem(latest.itemId)) {
+      return latest
+    }
+    if (this.diedTurn()?.item.itemId === latest.itemId) {
+      return { ...latest, turn: { ...latest.turn, state: 'interrupted' } }
+    }
+    return this.ownerUnverifiable
+      ? { ...latest, turn: { ...latest.turn, state: 'unverifiable' } }
+      : null
+  }
+}
+
+export function structuredAgentSessionCurrentWork(
+  journal: StructuredAgentSessionCurrentWorkJournal,
+  evidence: StructuredAgentSessionWorkEvidence
+): StructuredAgentSessionCurrentWork {
+  return new StructuredAgentSessionCurrentWork(
+    journal,
+    structuredAgentSessionLiveFence(evidence),
+    evidence.revision,
+    evidence.ended,
+    evidence.replaced,
+    structuredAgentSessionOwnerUnverifiable(evidence)
+  )
+}
+
+/** An operation context's current work: the host projection it was built with, or, for one built
+ *  without (a test's), the generation at its fence read as live. */
+export function contextStructuredAgentSessionCurrentWork(ctx: {
+  journal: StructuredAgentSessionCurrentWorkJournal
+  fence: number
+  currentWork?: () => StructuredAgentSessionCurrentWork | null
+}): StructuredAgentSessionCurrentWork {
+  return ctx.currentWork?.() ?? new StructuredAgentSessionCurrentWork(ctx.journal, ctx.fence)
+}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-delivery-loop.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-delivery-loop.ts
index 1858eaeddf8..68abf140f20 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-delivery-loop.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-delivery-loop.ts
@@ -38,6 +38,7 @@ import { structuredAgentSessionNextHandover } from './structured-agent-session-o
 import { structuredAgentSessionCommandRunning } from './structured-agent-session-command-turn'
 import type { StructuredAgentSessionLogger } from './structured-agent-session-logger'
 import { holdRestartedStructuredAgentSessionSends } from './structured-agent-session-host-lifetime'
+import type { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 import { structuredAgentSessionEndedChildFailure } from './structured-agent-session-ended-child-failure'
 
 export type StructuredAgentSessionDeliveryLoopDeps = {
@@ -64,6 +65,8 @@ export type StructuredAgentSessionDeliveryLoopDeps = {
   failureTextContext: (sessionId: string) => AgentSessionFailureWordsContext
   logger: StructuredAgentSessionLogger
   record: (sessionId: string) => AgentSessionRecord | null
+  /** The host's projection of the chat's current work (`hostStructuredAgentSessionCurrentWork`). */
+  currentWork: (sessionId: string) => StructuredAgentSessionCurrentWork | null
   readChildWork: (sessionId: string) => readonly AgentChildWorkView[] | undefined
   /** A person's Stop is still ending the session's work: the status feed's own reading. */
   stopping: (sessionId: string) => boolean
@@ -189,7 +192,8 @@ export class StructuredAgentSessionDeliveryLoop {
     const oldest = oldestQueuedSubmission(session)
     // A running command takes no input while its child carries it; its end is a commit, which
     // wakes the loop again. With no child it is a gone generation's, which the start below settles.
-    if (!oldest || (session.child && structuredAgentSessionCommandRunning(session.journal))) {
+    const work = this.deps.currentWork(sessionId)
+    if (!oldest || (session.child && work && structuredAgentSessionCommandRunning(work))) {
       return this.stop(sessionId)
     }
     const failedStart = startThatFailedWhileQueued(session, oldest)
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
index 51894a9ff8d..a2b30d57c30 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
@@ -18,7 +18,8 @@ import {
   endExitedStructuredAgentSessionChildUnderSerialize,
   settleStructuredAgentSessionChildExit,
   type StructuredAgentSessionChildExit,
-  type StructuredAgentSessionChildExitContext
+  type StructuredAgentSessionChildExitContext,
+  type StructuredAgentSessionGenerationEnded
 } from './structured-agent-session-child-exit'
 import type { StructuredAgentSessionHostRuntimeState } from './structured-agent-session-host-runtime-state'
 
@@ -31,8 +32,8 @@ export class StructuredAgentSessionEventRecovery {
       store: StructuredAgentSessionHostDeps['store']
       sessions: Map<string, StructuredAgentSessionHostSession>
       flushLifecycle: (sessionId: string) => Promise<StructuredAgentSessionSinkBarrier>
-      publishFence: (sessionId: string, session: StructuredAgentSessionHostSession) => void
       publishStatus?: (sessionId: string) => void
+      generationEnded: StructuredAgentSessionGenerationEnded
       serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
       now: () => number
       runtimeState: StructuredAgentSessionHostRuntimeState
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-history-result.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-history-result.ts
index 49fb06e83ba..882e7f94062 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-history-result.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-history-result.ts
@@ -8,7 +8,8 @@ import type {
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
 import {
   readAgentSessionHistory,
-  type AgentSessionHistoryScope
+  type AgentSessionHistoryScope,
+  type AgentSessionPublishedWork
 } from './agent-session-history-page'
 
 export function structuredAgentSessionProviderSessionMetadata(
@@ -23,8 +24,16 @@ export function readStructuredAgentSessionHistoryResult(input: {
   record: AgentSessionRecord | null
   request: AgentSessionHistoryRequest
   scope?: AgentSessionHistoryScope
+  /** The host's current-work projection, which the page's turn and prompt fields state. */
+  work?: AgentSessionPublishedWork
 }): AgentSessionHistoryResult {
-  const result = readAgentSessionHistory(input.journal, input.request, undefined, input.scope)
+  const result = readAgentSessionHistory(
+    input.journal,
+    input.request,
+    undefined,
+    input.scope,
+    input.work
+  )
   const fence = input.record?.lease.runtimeFence
   const providerSession = structuredAgentSessionProviderSessionMetadata(input.record)
   if (fence === undefined) {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-current-work.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-current-work.ts
new file mode 100644
index 00000000000..5c5ddaccea1
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-current-work.ts
@@ -0,0 +1,57 @@
+// The host's current-work projection (`structured-agent-session-current-work.ts`) for a chat it
+// holds, read from its sessions and lease store. Apart from the projection itself, which stays free
+// of host types so shared and client code can import it.
+
+import type { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
+import {
+  structuredAgentSessionCurrentWork,
+  type StructuredAgentSessionCurrentWork,
+  type StructuredAgentSessionCurrentWorkJournal
+} from './structured-agent-session-current-work'
+import type { StructuredAgentSessionHostSession } from './structured-agent-session-host-types'
+
+/** The host's sessions and lease store, as the projection reads them. */
+export type StructuredAgentSessionCurrentWorkHost = {
+  store: Pick<AgentSessionRecordStore, 'getRecord' | 'replacedRuntime'>
+  sessions: {
+    get(
+      sessionId: string
+    ):
+      | Pick<
+          StructuredAgentSessionHostSession,
+          'journal' | 'lastEndedChild' | 'operationalRevision' | 'child'
+        >
+      | undefined
+  }
+}
+
+/** A held chat's current work; null when this host holds no conversation for it. */
+export function hostStructuredAgentSessionCurrentWork(
+  host: StructuredAgentSessionCurrentWorkHost,
+  sessionId: string
+): StructuredAgentSessionCurrentWork | null {
+  const session = host.sessions.get(sessionId)
+  return session
+    ? heldStructuredAgentSessionCurrentWork(host.store, sessionId, session.journal, session)
+    : null
+}
+
+/** The one current work every host reader decides and displays by: this host's child is always
+ *  evidence (none held reads as none), so an action never reads work the display does not show. */
+export function heldStructuredAgentSessionCurrentWork(
+  store: StructuredAgentSessionCurrentWorkHost['store'],
+  sessionId: string,
+  journal: StructuredAgentSessionCurrentWorkJournal,
+  session:
+    | Pick<StructuredAgentSessionHostSession, 'lastEndedChild' | 'operationalRevision' | 'child'>
+    | undefined
+): StructuredAgentSessionCurrentWork {
+  const ended = session?.lastEndedChild
+  return structuredAgentSessionCurrentWork(journal, {
+    record: store.getRecord(sessionId),
+    replaced: store.replacedRuntime(sessionId),
+    child: session?.child ?? null,
+    ...(ended ? { ended } : {}),
+    revision: session?.operationalRevision ?? 0
+  })
+}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-delivery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-delivery.ts
index 9ff8543d514..6e75c09ead3 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-delivery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-delivery.ts
@@ -3,6 +3,7 @@
 // with a message queued has a delivery loop — and the open is where a loop for leftovers wakes.
 
 import { isQueuedAgentJournalSubmission } from '../../../shared/agent-session-queued-submission'
+import { hostStructuredAgentSessionCurrentWork } from './structured-agent-session-host-current-work'
 import { holdClosedStructuredAgentSessionSends } from './structured-agent-session-host-lifetime'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
 import {
@@ -78,6 +79,8 @@ export function createStructuredAgentSessionConversationDelivery(input: {
         : sessions.get(sessionId)
       await retireSignedOutStructuredAgentSessionChild(sessionId, session, {
         work: {
+          currentWork: () =>
+            hostStructuredAgentSessionCurrentWork({ store: deps.store, sessions }, sessionId),
           childWork: () => input.clientDelivery.readChildWork(sessionId),
           hasOpenDispatch: () => {
             const record = deps.store.getRecord(sessionId)
@@ -109,6 +112,8 @@ export function createStructuredAgentSessionConversationDelivery(input: {
       ),
     logger: deps.logger,
     record: (sessionId) => deps.store.getRecord(sessionId),
+    currentWork: (sessionId) =>
+      hostStructuredAgentSessionCurrentWork({ store: deps.store, sessions }, sessionId),
     readChildWork: input.clientDelivery.readChildWork,
     stopping: input.clientDelivery.readStopping,
     now: () => deps.now?.() ?? Date.now()
@@ -127,9 +132,11 @@ export function createStructuredAgentSessionConversationDelivery(input: {
   }
   const wakesQueued = new Set<string>()
   const afterCommit = (sessionId: string, journal: AgentSessionJournal): void => {
+    const work = hostStructuredAgentSessionCurrentWork({ store: deps.store, sessions }, sessionId)
     if (
       wakesQueued.has(sessionId) ||
-      structuredAgentSessionCommandRunning(journal) ||
+      !work ||
+      structuredAgentSessionCommandRunning(work) ||
       !journal.submissions().some(isQueuedAgentJournalSubmission)
     ) {
       return
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
index 8e072e714b6..abfcd7076a0 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
@@ -49,6 +49,8 @@ export type StructuredAgentSessionLifetimeContext = {
   now: () => number
   /** Re-projects the session's status after its agent stopped and the chat stays. */
   publishStatus?: (sessionId: string) => void
+  /** A generation ended (`StructuredAgentSessionClientDelivery.publishGenerationEnded`). */
+  generationEnded?: (sessionId: string) => void
   /** Hands the delivery loop what is queued; for a caller inside the session's serialize. */
   wakeDelivery?: (sessionId: string) => void
   /** The one exit handler (`structured-agent-session-child-exit`), for a caller inside the
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-status-feed.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-status-feed.ts
index 25d475abb46..3ad17339753 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-status-feed.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-status-feed.ts
@@ -1,4 +1,4 @@
-import type { AgentSessionRecord } from '../../../shared/agent-session-record'
+import type { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
 import {
   deferredStructuredAgentSessionLogger,
   type StructuredAgentSessionLogger
@@ -16,7 +16,7 @@ export function createStructuredAgentSessionHostStatusFeed(args: {
   sessions: StructuredAgentSessionStatusFeedDeps['sessions']
   now: () => number
   deps: () => {
-    store: { getRecord: (sessionId: string) => AgentSessionRecord | null }
+    store: Pick<AgentSessionRecordStore, 'getRecord' | 'replacedRuntime'>
     logger: StructuredAgentSessionLogger
     onSessionStatusChanged?: StructuredAgentSessionStatusFeedDeps['onStatusChanged']
     statusSink?: StructuredAgentSessionStatusSink
@@ -27,6 +27,7 @@ export function createStructuredAgentSessionHostStatusFeed(args: {
   return new StructuredAgentSessionStatusFeed({
     sessions: args.sessions,
     getRecord: (sessionId) => args.deps().store.getRecord(sessionId),
+    replacedRuntime: (sessionId) => args.deps().store.replacedRuntime(sessionId),
     now: args.now,
     logger: deferredStructuredAgentSessionLogger(() => args.deps().logger),
     onStatusChanged: (summary, options) => args.deps().onSessionStatusChanged?.(summary, options),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-stop-event.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-stop-event.ts
index d9b8e068c37..308aa76035e 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-stop-event.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-stop-event.ts
@@ -1,7 +1,8 @@
 // The Stop event a host stop writes (`JournalStopEvent`): whether it ends work its event must
 // record, and the write itself, issued before the kill.
 
-import { isStructuredAgentSessionMainAgentWorking } from '../../../shared/structured-agent-session-main-agent-working'
+import type { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
+import { heldStructuredAgentSessionCurrentWork } from './structured-agent-session-host-current-work'
 import { withTimeout } from '../../../shared/promise-timeout-fallback'
 import type { StructuredAgentSessionStopCause } from './structured-agent-session-adapter'
 import type { StructuredAgentSessionLifetimeContext } from './structured-agent-session-host-lifetime'
@@ -62,22 +63,27 @@ export async function stopEndsWork(
     STOP_EVENT_DRAIN_TIMEOUT_MS,
     'slow' as const
   )
+  // The child is live: the work its stop ends is its generation's.
+  const work = heldStructuredAgentSessionCurrentWork(
+    context.deps.store,
+    sessionId,
+    journal,
+    session
+  )
   const working =
-    (drain === 'slow' && journal.stopMarks.latestAcceptedSendUnopened()) ||
-    isStructuredAgentSessionMainAgentWorking(
-      journal.activeTurnId(),
-      journal.submissions(),
-      child.fence
-    )
-  return working && (ending.cause === 'user-close' || !defersToPersonsStop(session))
+    (drain === 'slow' && journal.stopMarks.latestAcceptedSendUnopened()) || work.working()
+  return working && (ending.cause === 'user-close' || !defersToPersonsStop(session, work))
 }
 
 /** A host stop of work a person's Stop is already ending must not supersede that Stop's reason:
  *  the turn it decides, or, with no turn running, the work under the queue pause it still holds,
  *  with nothing sent since, which a host's event would lift. */
-function defersToPersonsStop(session: StructuredAgentSessionHostSession): boolean {
+function defersToPersonsStop(
+  session: StructuredAgentSessionHostSession,
+  work: StructuredAgentSessionCurrentWork
+): boolean {
   const { journal } = session
-  const live = journal.activeTurnId()
+  const live = work.activeTurnId()
   if (live !== null) {
     return journal.stopMarks.personStopDecides(live)
   }
@@ -101,12 +107,15 @@ export function recordStopEvent(
   if ('recorded' in ending) {
     return Promise.resolve(null)
   }
-  const turnId = session.journal.activeTurnId()
+  const fence = structuredAgentSessionConversationFence(context.deps.store, sessionId)
+  const turnId = heldStructuredAgentSessionCurrentWork(
+    context.deps.store,
+    sessionId,
+    session.journal,
+    session
+  ).activeTurnId()
   return session.journal
-    .appendStopEvent(
-      { reason: ending.cause, ...(turnId !== null ? { turnId } : {}) },
-      structuredAgentSessionConversationFence(context.deps.store, sessionId)
-    )
+    .appendStopEvent({ reason: ending.cause, ...(turnId !== null ? { turnId } : {}) }, fence)
     .then(
       () => (ending.cause === 'user-close' ? session.journal.stopMarks.beginSettle() : null),
       (error: unknown) => {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts
index d6372878b2b..35fa639691d 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts
@@ -110,6 +110,9 @@ export type StructuredAgentSessionHostSession = {
    *  observed exit. */
   child: StructuredAgentSessionProviderChild | null
   lastEndedChild?: StructuredAgentSessionEndedChild
+  /** Bumped by every signal that a generation ended, which can change what is current with no
+   *  journal row or lease write: readers key what they cache of current work on it. */
+  operationalRevision?: number
   /** Owned by one live restart action, so another caller cannot replace its progress. */
   restartResume?: NonNullable<AgentSessionStatusSummary['restartResume']> & { operationId: string }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
index 8f9a97671a0..bce26545239 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
@@ -47,7 +47,6 @@ import {
 } from './structured-agent-session-restart-resume-host'
 import { structuredAgentSessionRestartResumeSurfaces } from './structured-agent-session-restart-resume-wiring'
 import * as conversation from './structured-agent-session-host-delivery'
-import { structuredAgentSessionConversationFence } from './structured-agent-session-provider-child'
 import { wireStructuredAgentSessionQueuedMessages } from './structured-agent-session-queued-wiring'
 import * as sessionLogger from './structured-agent-session-logger'
 export type { StructuredAgentSessionHostDeps } from './structured-agent-session-host-types'
@@ -75,7 +74,7 @@ export class StructuredAgentSessionHost {
     this.sessions,
     () => this.now(),
     () => this.deps,
-    (sessionId) => this.queued.onJournalActivity(sessionId),
+    this.queued,
     (sessionId) => this.restartResume.onAgentStarted(sessionId),
     (sessionId) => this.backgroundTasks.publish(sessionId),
     (sessionId) => this.backgroundTasks.read(sessionId)
@@ -142,13 +141,8 @@ export class StructuredAgentSessionHost {
       store: deps.store,
       sessions: this.sessions,
       flushLifecycle: (sessionId) => this.runtimeState.lifecycleBarrier(sessionId),
-      publishFence: (sessionId, session) =>
-        this.subscribers.snapshot(
-          sessionId,
-          session.journal,
-          structuredAgentSessionConversationFence(deps.store, sessionId)
-        ),
       publishStatus: this.clientDelivery.publishStatusAndSettlement,
+      generationEnded: this.generationEnded,
       serialize: (sessionId, task) => this.tasks.trackAttach(this.serialize(sessionId, task)),
       now: () => this.now(),
       runtimeState: this.runtimeState,
@@ -173,6 +167,14 @@ export class StructuredAgentSessionHost {
   }
 
   private now = (): number => this.deps.now?.() ?? Date.now()
+  /** A generation ended: what readers cache of current work is keyed on the bump, then all re-derive. */
+  private generationEnded = (sessionId: string, options?: { restate?: boolean }): void => {
+    const session = this.sessions.get(sessionId)
+    if (session) {
+      session.operationalRevision = (session.operationalRevision ?? 0) + 1
+    }
+    this.clientDelivery.publishGenerationEnded(sessionId, options)
+  }
 
   hasSession = (sessionId: string): boolean => this.sessions.has(sessionId)
   hasLoadedProviders = (): boolean =>
@@ -190,6 +192,7 @@ export class StructuredAgentSessionHost {
       sessions: this.sessions,
       now: () => this.now(),
       publishStatus: this.clientDelivery.publishStatus,
+      generationEnded: this.generationEnded,
       wakeDelivery: (sessionId: string) => this.conversationDelivery.loop.wake(sessionId),
       endExitedChild: this.eventRecovery.endExitedChildUnderSerialize
     } satisfies StructuredAgentSessionLifetimeContext
@@ -330,6 +333,9 @@ export class StructuredAgentSessionHost {
   journalSnapshot = async (sessionId: string): Promise<AgentJournalSnapshot> =>
     (await this.lifetime.conversation(sessionId)).journal.snapshot()
 
+  /** The host's projection of a held chat's current work (`structuredAgentSessionCurrentWork`). */
+  currentWork = this.clientDelivery.readCurrentWork
+
   subscribe = (input: AgentSessionSubscribeInput) => this.backgroundTasks.subscribe(input)
 
   settleLateDispatch = (input: Parameters<typeof settleStructuredAgentSessionLateDispatch>[1]) =>
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-idle-sweep.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-idle-sweep.test.ts
index 7de8ad28581..f3adb18b2a2 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-idle-sweep.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-idle-sweep.test.ts
@@ -225,7 +225,7 @@ describe('the idle sweep', () => {
     await vi.waitFor(() => expect(rig.adapter.closeSession).toHaveBeenCalledWith(SESSION))
   })
 
-  it('never stops a worker whose orchestration dispatch is open, and stops it once it settles (P2-19 i)', async () => {
+  it('never stops the retry whose orchestration dispatch is open, and stops it once it settles (P2-19 i)', async () => {
     await rig.dispose()
     let open = true
     const hasOpenDispatch = vi.fn(() => open)
@@ -320,6 +320,7 @@ describe('the idle sweep with no child running (P2-22 ii)', () => {
       now: () => IDLE_MS + 1,
       isDisposed: () => false,
       deliveryActive: () => false,
+      store: { getRecord: () => null, replacedRuntime: () => undefined },
       childWork: () => undefined,
       hasOpenDispatch: () => false,
       providerHoldsDispatch: () => false,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-idle-sweep.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-idle-sweep.ts
index 1fd7fc93756..ee010cc4413 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-idle-sweep.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-idle-sweep.ts
@@ -13,7 +13,11 @@ import { isQueuedAgentJournalSubmission } from '../../../shared/agent-session-qu
 import type { AgentChildWorkView } from '../../../shared/agent-status-child-work-view'
 import type { StructuredAgentSessionHostSession } from './structured-agent-session-host-types'
 import type { StructuredAgentSessionLogger } from './structured-agent-session-logger'
-import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
+import type { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
+import {
+  heldStructuredAgentSessionCurrentWork,
+  type StructuredAgentSessionCurrentWorkHost
+} from './structured-agent-session-host-current-work'
 
 export const STRUCTURED_AGENT_SESSION_IDLE_SWEEP_INTERVAL_MS = 5 * 60_000
 export const STRUCTURED_AGENT_SESSION_IDLE_MS = 30 * 60_000
@@ -33,6 +37,8 @@ export type StructuredAgentSessionIdleSweepDeps = {
   hasOpenDispatch: (sessionId: string) => boolean
   /** The provider holds a send it took and has not answered; see `holdsDispatch`. */
   providerHoldsDispatch: (sessionId: string) => boolean
+  /** The lease store the current-work projection reads (`heldStructuredAgentSessionCurrentWork`). */
+  store: StructuredAgentSessionCurrentWorkHost['store']
   /** Each of these runs inside the session's serialize and never takes it again. */
   stopAgent: (sessionId: string) => Promise<void>
   stopStartingAgent: (sessionId: string) => Promise<void>
@@ -42,35 +48,34 @@ export type StructuredAgentSessionIdleSweepDeps = {
   idleMs?: number
 }
 
-/** The host's reads of what a running child still serves besides its journal. */
+/** The host's reads of what a running child still serves. */
 export type StructuredAgentSessionChildWorkReads = {
+  /** The host's projection of current work: an ended generation's turn or prompt holds nothing.
+   *  Null when the host holds no conversation, which has none. */
+  currentWork: () => Pick<
+    StructuredAgentSessionCurrentWork,
+    'activeTurnId' | 'hasActionablePrompt'
+  > | null
   childWork: () => readonly AgentChildWorkView[] | undefined
   hasOpenDispatch: () => boolean
   providerHoldsDispatch: () => boolean
 }
 
 /** Work the running child owes apart from queued sends: a turn, a child agent, an open
- *  orchestration dispatch, a send the provider holds, or a prompt nobody answered. Whatever owes
- *  any of it keeps its child; it builds no snapshot. */
+ *  orchestration dispatch, a send the provider holds, or a prompt nobody answered (a subagent's
+ *  too, which the lead turn cannot see). Whatever owes any of it keeps its child; it builds no
+ *  snapshot. */
 export function structuredAgentSessionChildHasOpenWork(
-  journal: Pick<AgentSessionJournal, 'activeTurnId' | 'visitItems'>,
   reads: StructuredAgentSessionChildWorkReads
 ): boolean {
-  if (
-    journal.activeTurnId() !== null ||
+  const work = reads.currentWork()
+  return (
+    (work !== null && work.activeTurnId() !== null) ||
     agentChildWorkLiveness(reads.childWork()) !== null ||
     reads.hasOpenDispatch() ||
-    reads.providerHoldsDispatch()
-  ) {
-    return true
-  }
-  let pendingPrompt = false
-  journal.visitItems((_itemId, _sequence, body) => {
-    // A subagent can raise a prompt the lead turn cannot see.
-    pendingPrompt ||=
-      (body.kind === 'approval' || body.kind === 'question') && body.resolution.state === 'pending'
-  })
-  return pendingPrompt
+    reads.providerHoldsDispatch() ||
+    (work !== null && work.hasActionablePrompt())
+  )
 }
 
 export class StructuredAgentSessionIdleSweep {
@@ -160,7 +165,14 @@ export class StructuredAgentSessionIdleSweep {
   private owesWork(sessionId: string, session: StructuredAgentSessionHostSession): boolean {
     return (
       this.queuedOrDelivering(sessionId, session) ||
-      structuredAgentSessionChildHasOpenWork(session.journal, {
+      structuredAgentSessionChildHasOpenWork({
+        currentWork: () =>
+          heldStructuredAgentSessionCurrentWork(
+            this.deps.store,
+            sessionId,
+            session.journal,
+            session
+          ),
         childWork: () => this.deps.childWork(sessionId),
         hasOpenDispatch: () => this.deps.hasOpenDispatch(sessionId),
         providerHoldsDispatch: () => this.deps.providerHoldsDispatch(sessionId)
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-leftover-settlement.test-fixture.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-leftover-settlement.test-fixture.ts
new file mode 100644
index 00000000000..56f71b566d2
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-leftover-settlement.test-fixture.ts
@@ -0,0 +1,145 @@
+// A dead generation's leftover work, for the current-work tests: a child that leaves a running
+// turn (and a prompt, when asked), and an exit whose settlement the database refuses.
+
+import { expect, vi } from 'vitest'
+import {
+  AGENT_JOURNAL_THREAD_SCOPE,
+  type AgentJournalItemIdentity
+} from '../../../shared/agent-session-journal-types'
+import { agentJournalItemKey } from '../../../shared/agent-session-journal-item-key'
+import { readAgentJournalTurn } from '../../../shared/agent-session-turn-record'
+import {
+  liveTestJournalRows,
+  openTestJournalHostDatabase
+} from '../agent-session-journal/journal-host-database-test-support'
+import type { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
+import { hostStructuredAgentSessionCurrentWork } from './structured-agent-session-host-current-work'
+import {
+  HOST_TEST_SESSION as SESSION,
+  HOST_TEST_THREAD as THREAD,
+  hostTestMessage,
+  hostTestOperationId
+} from './structured-agent-session-host-test-data'
+import {
+  QUEUED_RIG_CALLER as CALLER,
+  type QueuedMessageTestRig
+} from './structured-agent-session-queued-message-rig.test-fixture'
+
+export const TURN: AgentJournalItemIdentity = {
+  provider: 'codex',
+  threadId: THREAD,
+  turnId: 'unfinished',
+  ordinal: 1
+}
+export const TURN_KEY = agentJournalItemKey(TURN)
+const IN_TURN = { kind: 'turn' as const, turnItemId: TURN_KEY }
+export const APPROVAL: AgentJournalItemIdentity = { ...TURN, ordinal: 2 }
+/** Refuses every row a settlement writes: its rows are all `recovered`. */
+export const REJECT_RECOVERED_ROWS = `
+  CREATE TEMP TRIGGER reject_recovered BEFORE INSERT ON journal_rows
+  WHEN json_extract(NEW.row_json, '$.recovered') = 1
+  BEGIN SELECT RAISE(ABORT, 'temporary storage failure'); END;
+`
+
+/** The live child leaves a running turn, and a pending prompt when asked, in the journal. */
+export async function leaveUnfinishedWork(
+  current: QueuedMessageTestRig,
+  options: { prompt?: true } = {}
+): Promise<void> {
+  const events = current.providerEvents()
+  events.appendItem(
+    TURN,
+    { kind: 'turn', turnId: 'unfinished', state: 'running' },
+    { turnScope: AGENT_JOURNAL_THREAD_SCOPE }
+  )
+  if (options.prompt) {
+    events.appendItem(
+      APPROVAL,
+      {
+        kind: 'approval',
+        title: 'Run command?',
+        detail: null,
+        options: [{ id: 'yes', label: 'Allow' }],
+        resolution: { state: 'pending', selectedOptionId: null, resolvedBy: null, resolvedAt: null }
+      },
+      { turnScope: IN_TURN }
+    )
+  }
+  await current.host.flushStreamedEvents(SESSION)
+}
+
+/** The child dies on its own while the database refuses every settlement row: the exit releases
+ *  its lease (proof written, fence moved) and its work stays saved as running. */
+export async function exitWhileSettlementFails(current: QueuedMessageTestRig) {
+  const context = current.host.collaboratorsForTests()
+  const session = context.sessions.get(SESSION)
+  const child = session?.child
+  if (!session || !child?.generation) {
+    throw new Error('expected the original child')
+  }
+  const database = openTestJournalHostDatabase(current.root)
+  const before = liveTestJournalRows(database.db, SESSION)
+  vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+  database.db.exec(REJECT_RECOVERED_ROWS)
+  await current.host.handleAdapterEvent({
+    type: 'ended',
+    sessionId: SESSION,
+    cause: 'unexpected-exit',
+    reason: 'observed exit',
+    fence: child.fence,
+    acquisitionGeneration: child.generation
+  })
+  await context.serialize(SESSION, async () => {})
+  expect(session.child).toBeNull()
+  expect(current.store.getRecord(SESSION)?.lease).toMatchObject({
+    claimStatus: 'released',
+    runtimeFence: child.fence + 1,
+    deathEvidence: { kind: 'exit-observed', ownerFence: child.fence }
+  })
+  expect(liveTestJournalRows(database.db, SESSION)).toEqual(before)
+  return { session, database, deadFence: child.fence }
+}
+
+/** A person's ordinary text send from the composer, with queueing on, at the current fence. */
+export function sendText(current: QueuedMessageTestRig, text: string) {
+  const fence = current.store.getRecord(SESSION)?.lease.runtimeFence
+  if (fence === undefined) {
+    throw new Error('expected the record')
+  }
+  const body = hostTestMessage(text)
+  const clientOperationId = hostTestOperationId()
+  const fields = { body, delivery: 'queue-if-active' as const }
+  const result = current.host.send(CALLER, {
+    ...fields,
+    userSend: true,
+    envelope: {
+      ...current.envelope(fields, 'agentSession.send', clientOperationId),
+      expectedRuntimeFence: fence
+    }
+  })
+  return { clientOperationId, result }
+}
+
+export function currentJournal(current: QueuedMessageTestRig) {
+  const journal = current.host.collaboratorsForTests().sessions.get(SESSION)?.journal
+  if (!journal) {
+    throw new Error('expected the open conversation')
+  }
+  return journal
+}
+
+/** The host's projection of the chat's current work, as every host reader asks it. */
+export function currentWork(current: QueuedMessageTestRig): StructuredAgentSessionCurrentWork {
+  const work = hostStructuredAgentSessionCurrentWork(
+    { store: current.store, sessions: current.host.collaboratorsForTests().sessions },
+    SESSION
+  )
+  if (!work) {
+    throw new Error('expected the open conversation')
+  }
+  return work
+}
+
+export function turnState(current: QueuedMessageTestRig): string | undefined {
+  return readAgentJournalTurn(currentJournal(current).itemBody(TURN_KEY) ?? undefined)?.state
+}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-live-turn-window.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-live-turn-window.test.ts
index 75c88bcf480..895f4f39d18 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-live-turn-window.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-live-turn-window.test.ts
@@ -116,7 +116,7 @@ describe('a running turn whose record is older than the loaded page', () => {
     await runLongTurn('turn-1', 250)
     const state = hydrate()
 
-    expect(journal.activeTurnId()).toBe('turn-1')
+    expect(journal.runningTurn()?.turnId ?? null).toBe('turn-1')
     expect(state.hasOlder).toBe(true)
     // What every client read before: the record is off the page, so the loaded rows said idle.
     expect(activeStructuredAgentSessionTurnId(state.items)).toBeNull()
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
index 54a1d769a00..39a3934bd26 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
@@ -40,6 +40,7 @@ import {
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
 import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
 import type { MutationPlan } from './structured-agent-session-mutation-plans'
+import type { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 import { runSettledAgentSessionMutation } from './structured-agent-session-operation-settlement'
 import {
   agentSessionOperationOutcomeUnknown,
@@ -74,6 +75,8 @@ export type AgentSessionMutationRequest<TValue> = {
   plan: MutationPlan<TValue>
   /** Journal of the attached session, read after `prepareSession`; absent when this host holds none. */
   journal: () => AgentSessionJournal | undefined
+  /** The host's projection of the chat's current work (`hostStructuredAgentSessionCurrentWork`). */
+  currentWork?: () => StructuredAgentSessionCurrentWork | null
   /** Between the ledger's answer and the lease check, for a call that may first have to make the
    *  session ready for itself. Answers with the refusal that ends the call, if any. */
   prepareSession?: (
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-context.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-context.ts
index f9b83c3b4f3..0b3280335fb 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-context.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-context.ts
@@ -15,6 +15,7 @@ import type { MutationPlan } from './structured-agent-session-mutation-plans'
 import type { StructuredAgentSessionStopEnding } from './structured-agent-session-host-lifetime'
 import type { StructuredAgentSessionAcquireAborts } from './structured-agent-session-acquire-aborts'
 import type { StructuredAgentSessionOptionRevisions } from './structured-agent-session-option-revisions'
+import { hostStructuredAgentSessionCurrentWork } from './structured-agent-session-host-current-work'
 import type {
   StructuredAgentSessionCaller,
   StructuredAgentSessionHostDeps,
@@ -72,6 +73,11 @@ export function mutateStructuredAgentSession<TValue>(
       envelope,
       plan,
       journal: () => context.sessions.get(envelope.sessionId)?.journal,
+      currentWork: () =>
+        hostStructuredAgentSessionCurrentWork(
+          { store: context.deps.store, sessions: context.sessions },
+          envelope.sessionId
+        ),
       prepareSession,
       publish: (journal) => context.publish(envelope.sessionId, journal),
       wakeDelivery: (sessionId) => context.wakeDelivery(sessionId),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-turn-context.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-turn-context.ts
index 776937662eb..40ecfb34c6c 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-turn-context.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-turn-context.ts
@@ -11,11 +11,13 @@ export function mutationTurnContext<TValue>(
   record: AgentSessionRecord
 ): AgentSessionTurnContext {
   const fence = record.lease.runtimeFence
-  const persistedOptions = request.store.getRecord(request.envelope.sessionId)?.options
+  const { sessionId } = request.envelope
+  const persistedOptions = request.store.getRecord(sessionId)?.options
   return {
-    sessionId: request.envelope.sessionId,
+    sessionId,
     journal,
     fence,
+    ...(request.currentWork ? { currentWork: request.currentWork } : {}),
     adapter: request.adapter,
     agents: request.agents,
     agent: record.provider,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-prompt-cancel.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-prompt-cancel.ts
index b4281859aba..a92a9d036be 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-prompt-cancel.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-prompt-cancel.ts
@@ -14,6 +14,7 @@ import {
   type PendingPromptValidation
 } from './structured-agent-session-prompt-state'
 import type { AgentSessionTurnContext, TurnOutcome } from './structured-agent-session-turns'
+import { contextStructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 
 type CancelOutcome = TurnOutcome<AgentSessionCancelResult>
 type PendingPrompt = Extract<PendingPromptValidation, { ok: true }>
@@ -64,7 +65,7 @@ export async function cancelStructuredAgentSessionPrompt(
 }
 
 function raisedByLiveTurn(ctx: AgentSessionTurnContext, pending: PendingPrompt): boolean {
-  const live = ctx.journal.liveTurnScope()
+  const live = contextStructuredAgentSessionCurrentWork(ctx).turnScope()
   const raised = pending.item.turnScope
   return live.kind === 'turn' && raised?.kind === 'turn' && raised.turnItemId === live.turnItemId
 }
@@ -102,7 +103,7 @@ async function dismissPrompt(
         }
       },
       // A revision: the prompt keeps the turn it was raised in.
-      { fence: ctx.fence, turnScope: ctx.journal.liveTurnScope() }
+      { fence: ctx.fence, turnScope: contextStructuredAgentSessionCurrentWork(ctx).turnScope() }
     )
     committed = true
   }
@@ -128,7 +129,7 @@ async function dismissPrompt(
             surface: 'row'
           })
         },
-        { fence: ctx.fence, turnScope: ctx.journal.liveTurnScope() }
+        { fence: ctx.fence, turnScope: contextStructuredAgentSessionCurrentWork(ctx).turnScope() }
       )
     }
   }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-child.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-child.ts
index 978d65d055b..080a70dfb7f 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-child.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-child.ts
@@ -85,12 +85,26 @@ export function endProviderChild(
   ended: Omit<StructuredAgentSessionEndedChild, 'endedAt' | 'startedFor'> & {
     endedAt?: AgentJournalCursor
   }
+): boolean {
+  if (!recordProviderChildEnd(session, ended)) {
+    return false
+  }
+  session.child = null
+  return true
+}
+
+/** Records how the child on record ended, leaving it on record for its own teardown: every reader
+ *  projects its generation as ended from now on (`StructuredAgentSessionCurrentWork`). */
+export function recordProviderChildEnd(
+  session: ChildBearer,
+  ended: Omit<StructuredAgentSessionEndedChild, 'endedAt' | 'startedFor'> & {
+    endedAt?: AgentJournalCursor
+  }
 ): boolean {
   const child = matchingChild(session, ended)
   if (!child) {
     return false
   }
-  session.child = null
   session.lastEndedChild = {
     ...ended,
     ...(child.startedFor === undefined ? {} : { startedFor: child.startedFor }),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-card-holds.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-card-holds.test.ts
index 915e781401a..9052eb0eb38 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-card-holds.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-card-holds.test.ts
@@ -42,6 +42,7 @@ import {
   QUEUED_RIG_CALLER,
   type QueuedMessageTestRig
 } from './structured-agent-session-queued-message-rig.test-fixture'
+import { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 
 let rig: QueuedMessageTestRig
 
@@ -555,6 +556,12 @@ describe('where the host would refuse the send', () => {
     if (!journal) {
       throw new Error('expected the conversation open')
     }
+    // The clear's generation end wakes the drain, which would send the card; holding the session's
+    // lane keeps it waiting while the test reads the gate (`release` lets the drain run).
+    // The gate exists before the task runs: other work may be queued ahead of it on the lane.
+    let release = (): void => undefined
+    const gate = new Promise<void>((resolve) => (release = resolve))
+    const held = rig.host.collaboratorsForTests().serialize(HOST_TEST_SESSION, () => gate)
     const card = 'left-behind'
     await journal.queuedMessages.insert({
       messageId: card,
@@ -566,20 +573,33 @@ describe('where the host would refuse the send', () => {
     if (!record) {
       throw new Error('expected the record')
     }
-    return { card, journal, record, fence: record.lease.runtimeFence }
+    const done = async (): Promise<void> => {
+      release()
+      await held
+    }
+    return { card, journal, record, fence: record.lease.runtimeFence, done }
   }
 
   it('a card queued after clear is sendable with the completed clear record still present', async () => {
-    const { card, journal, record, fence } = await cardAddedAfterClear()
-    const gate = structuredQueueSendGate(rig.store, HOST_TEST_SESSION)
+    const { card, journal, record, fence, done } = await cardAddedAfterClear()
+    const gate = structuredQueueSendGate(
+      { store: rig.store, sessions: rig.host.collaboratorsForTests().sessions },
+      HOST_TEST_SESSION
+    )
     expect(readQueuePublication(journal, gate).nextQueuedMessageId).toBe(card)
     const { conversationCommand: _cleared, ...unblocked } = record
-    const next = readQueuePublication(journal, () => ({ record: unblocked, fence }))
+    const next = readQueuePublication(journal, () => ({
+      record: unblocked,
+      work: new StructuredAgentSessionCurrentWork(journal, fence)
+    }))
     expect(next.nextQueuedMessageId).toBe(card)
+    await done()
+    // Released, the drain the clear's end woke sends it.
+    await vi.waitFor(() => expect(journal.queuedMessages.get(card)?.state).toBe('dispatched'))
   })
 
   it('a rewind whose outcome is unknown names no next card', async () => {
-    const { journal, record, fence } = await cardAddedAfterClear()
+    const { journal, record, fence, done } = await cardAddedAfterClear()
     const { conversationCommand: _cleared, ...unblocked } = record
     const rewind = {
       operationId: hostTestOperationId(),
@@ -590,9 +610,13 @@ describe('where the host would refuse the send', () => {
       retained: []
     }
     const next = (gateRecord: typeof record) =>
-      readQueuePublication(journal, () => ({ record: gateRecord, fence })).nextQueuedMessageId
+      readQueuePublication(journal, () => ({
+        record: gateRecord,
+        work: new StructuredAgentSessionCurrentWork(journal, fence)
+      })).nextQueuedMessageId
     expect(next({ ...unblocked, rewind })).toBeNull()
     expect(next({ ...unblocked, rewind: { ...rewind, phase: 'provider-succeeded' } })).toBeNull()
     expect(next({ ...unblocked, rewind: { ...rewind, phase: 'completed' } })).not.toBeNull()
+    await done()
   })
 })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-edit.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-edit.test.ts
index 9e4280fb54f..694482b418b 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-edit.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-edit.test.ts
@@ -75,8 +75,12 @@ function hold(
       : { ...common, action }
   )
 }
+function gate() {
+  const host = { store: rig.store, sessions: rig.host.collaboratorsForTests().sessions }
+  return structuredQueueSendGate(host, HOST_TEST_SESSION)
+}
 function publication() {
-  return readQueuePublication(journal(), structuredQueueSendGate(rig.store, HOST_TEST_SESSION))
+  return readQueuePublication(journal(), gate())
 }
 function published(id: string) {
   return publication().queuedMessages.find((message) => message.messageId === id)
@@ -198,7 +202,7 @@ describe('edit leases and automatic delivery', () => {
     expect(
       shouldQueueStructuredAgentSessionSend({
         journal: journal(),
-        ...structuredQueueSendGate(rig.store, HOST_TEST_SESSION)()
+        ...gate()(journal())
       })
     ).toBe(true)
     // An explicit Send still overrides, and spends the lease with the card.
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-gate.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-gate.test.ts
index b9f6e316792..742bf19a91f 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-gate.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-gate.test.ts
@@ -18,6 +18,7 @@ import {
   hostTestMessage,
   hostTestOperationId
 } from './structured-agent-session-host-test-data'
+import { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 
 let rig: QueuedMessageTestRig
 let host: QueuedMessageTestRig['host']
@@ -87,9 +88,12 @@ describe('the one queue gate', () => {
     })
     // Read in place: the gate runs on every admission and drain step.
     const snapshot = vi.spyOn(journal, 'snapshot')
-    expect(structuredQueueHold({ journal, record: store.getRecord(SESSION), fence: 1 })).toBe(
-      'prompt'
-    )
+    expect(
+      structuredQueueHold({
+        record: store.getRecord(SESSION),
+        work: new StructuredAgentSessionCurrentWork(journal, 1)
+      })
+    ).toBe('prompt')
     expect(snapshot).not.toHaveBeenCalled()
     snapshot.mockRestore()
     await journal.appendItem(
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-message-rig.test-fixture.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-message-rig.test-fixture.ts
index ef7e36953bd..6cb6b07bee2 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-message-rig.test-fixture.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-message-rig.test-fixture.ts
@@ -11,6 +11,7 @@ import { agentSessionFailureWords } from '../../../shared/agent-session-failure-
 import { computeAgentSessionPayloadFingerprint } from '../../../shared/agent-session-mutation-envelope'
 import type { AgentJournalSubmission } from '../../../shared/agent-session-journal-types'
 import type { AgentSessionQueuePause } from '../../../shared/agent-session-wire'
+import type { AgentSessionExecutionLocation } from '../../../shared/agent-session-record'
 import type { AgentMessageSource } from '../../../shared/agent-session-message-source'
 import { agentSessionMessagePayload } from '../../../shared/structured-agent-session-send-mutation'
 import { openTestAgentSessionRecordStore } from '../../runtime/agent-session-record-store-test-harness'
@@ -49,6 +50,8 @@ export async function createQueuedMessageTestRig(
     idleSweep?: { idleMs: number; intervalMs: number }
     /** Teardown records its restart offers, which `restartOffers` lists. */
     recoveryCapsule?: true
+    /** Where the chat runs, when not the default worktree. */
+    location?: AgentSessionExecutionLocation
   } = {}
 ) {
   const root = await mkdtemp(join(tmpdir(), 'orca-queued-messages-'))
@@ -70,9 +73,11 @@ export async function createQueuedMessageTestRig(
       ...(options.recoveryCapsule ? { recoveryCapsule: new AgentSessionRecoveryCapsule(root) } : {})
     })
   let host = makeHost()
-  expect(await host.attach(QUEUED_RIG_CALLER, hostTestAttachParams(null))).toMatchObject({
-    ok: true
-  })
+  const firstAttach = hostTestAttachParams(
+    null,
+    options.location ? { location: options.location } : {}
+  )
+  expect(await host.attach(QUEUED_RIG_CALLER, firstAttach)).toMatchObject({ ok: true })
 
   function envelope(
     fields: Record<string, unknown>,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-messages.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-messages.ts
index ac85a5ed8bf..ca06988c7d0 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-messages.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-messages.ts
@@ -19,8 +19,11 @@ import { queuedSendAnswer } from './structured-agent-session-queued-send-answer'
 import { structuredAgentSessionSendBlock } from './structured-agent-session-send-preparation'
 import { queuedMessagesPublishedBytesRefusal } from './structured-agent-session-queued-published-bytes'
 import type { AgentSessionRecord } from '../../../shared/agent-session-record'
-import { isStructuredAgentSessionMainAgentWorking } from '../../../shared/structured-agent-session-main-agent-working'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
+import {
+  contextStructuredAgentSessionCurrentWork,
+  type StructuredAgentSessionCurrentWork
+} from './structured-agent-session-current-work'
 import type { AgentSessionTurnContext } from './structured-agent-session-turns'
 import { QueuedMessageNotConsumableError } from '../agent-session-journal/queued-message-consume-error'
 import type { QueuedMessageRow } from '../agent-session-journal/queued-message-table'
@@ -39,22 +42,6 @@ export function queuedMessageBodyIsTextOnly(body: AgentJournalMessageItem): bool
   return body.blocks.every((block) => block.type === 'text')
 }
 
-/** Walks the reduced items in place: the gate runs on every admission and
- *  drain step, so it must not render a snapshot of the whole journal. */
-export function pendingPromptExists(journal: Pick<AgentSessionJournal, 'visitItems'>): boolean {
-  let pending = false
-  journal.visitItems((_itemId, _sequence, body) => {
-    if (
-      !pending &&
-      (body.kind === 'approval' || body.kind === 'question') &&
-      body.resolution.state === 'pending'
-    ) {
-      pending = true
-    }
-  })
-  return pending
-}
-
 /** Waiting, not held on its own, and not positioned behind a returned card or a
  *  card the queue's pause holds: the queue never reorders. The admission rule
  *  (§accept) and the drain's selection both read it; only the drain's (`automatic`) stops at a
@@ -82,7 +69,8 @@ function oldestActionableQueuedMessage(
  *   drain step: any hold returns early; whatever clears it publishes or
  *     commits, which re-derives.
  *   Send-now: overrides only `working` (plus FIFO order and the stored hold),
- *     never for a command card; `blocked` and `prompt` refuse readably.
+ *     never for a command card while a turn runs; `blocked` and `prompt` refuse
+ *     readably.
  *
  * `blocked` is whatever refuses any send (an uncertain rewind, a cleared source);
  * the rest are waits. A /compact is a queued message and then a turn,
@@ -92,50 +80,37 @@ function oldestActionableQueuedMessage(
  */
 export type StructuredQueueHold = 'blocked' | 'working' | 'prompt'
 
-export function structuredQueueHold(input: {
-  journal: AgentSessionJournal
+/** What the queue's gate reads: the record, and the host's projection of current work
+ *  (`structuredAgentSessionCurrentWork`), so an ended generation's leftovers hold nothing. */
+export type StructuredQueueGateInput = {
   record: AgentSessionRecord | null
-  fence: number
-}): StructuredQueueHold | null {
+  work: StructuredAgentSessionCurrentWork
+}
+
+export function structuredQueueHold(input: StructuredQueueGateInput): StructuredQueueHold | null {
   // Whatever refuses any send refuses the queue too: an uncertain rewind or a source a
   // clear superseded. One rule, the immediate path's own.
   if (structuredAgentSessionSendBlock(input.record)) {
     return 'blocked'
   }
-  const { journal } = input
   // `prompt` outranks `working`: it is the one wait Send-now may not override,
   // so a prompt raised mid-turn must not read as merely `working`.
-  if (pendingPromptExists(journal)) {
+  if (input.work.hasActionablePrompt()) {
     return 'prompt'
   }
-  if (
-    isStructuredAgentSessionMainAgentWorking(
-      journal.activeTurnId(),
-      journal.submissions(),
-      input.fence
-    )
-  ) {
-    return 'working'
-  }
-  return null
+  return input.work.working() ? 'working' : null
 }
 
 /** The card the drain sends next, or null while anything holds the queue: the drain's own pick
  *  through the one gate, so a client told this reads what the drain acts on. Live facts only; the
  *  backlog is never a gate, so a lone draft drains. */
-export function nextStructuredQueuedMessage(input: {
-  journal: AgentSessionJournal
-  record: AgentSessionRecord | null
-  fence: number
-}): QueuedMessageRow | null {
+export function nextStructuredQueuedMessage(
+  input: StructuredQueueGateInput & { journal: AgentSessionJournal }
+): QueuedMessageRow | null {
   const next = oldestActionableQueuedMessage(input.journal, true)
-  const { journal, fence } = input
   // The gate's cheap `working` first: publication asks on every streamed frame, and the gate's
   // prompt check walks the whole fold.
-  if (
-    next === null ||
-    isStructuredAgentSessionMainAgentWorking(journal.activeTurnId(), journal.submissions(), fence)
-  ) {
+  if (next === null || input.work.working()) {
     return null
   }
   return structuredQueueHold(input) === null ? next : null
@@ -149,11 +124,9 @@ export function nextStructuredQueuedMessage(input: {
  * turn starting is what lifts the pause — Orca's own queue policy, a stated
  * deviation from held-head backlog counting.
  */
-export function shouldQueueStructuredAgentSessionSend(input: {
-  journal: AgentSessionJournal
-  record: AgentSessionRecord | null
-  fence: number
-}): boolean {
+export function shouldQueueStructuredAgentSessionSend(
+  input: StructuredQueueGateInput & { journal: AgentSessionJournal }
+): boolean {
   const hold = structuredQueueHold(input)
   if (hold === 'blocked') {
     // The immediate path's own refusal (`structuredAgentSessionSendBlock`)
@@ -176,7 +149,10 @@ export async function maybeQueueStructuredAgentSessionSend(
   context: {
     deps: { store: { getRecord: (sessionId: string) => AgentSessionRecord | null } }
   },
-  ctx: Pick<AgentSessionTurnContext, 'sessionId' | 'journal' | 'fence' | 'operationReceipt'>,
+  ctx: Pick<
+    AgentSessionTurnContext,
+    'sessionId' | 'journal' | 'fence' | 'operationReceipt' | 'currentWork'
+  >,
   params: {
     envelope: { clientOperationId: string }
     body: AgentJournalMessageItem
@@ -209,7 +185,7 @@ export async function maybeQueueStructuredAgentSessionSend(
     !shouldQueueStructuredAgentSessionSend({
       journal: ctx.journal,
       record: context.deps.store.getRecord(ctx.sessionId),
-      fence: ctx.fence
+      work: contextStructuredAgentSessionCurrentWork(ctx)
     })
   ) {
     return null
@@ -257,6 +233,8 @@ export type QueuedMessageDrainDeps = {
   getRecord: (sessionId: string) => AgentSessionRecord | null
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
   conversationFence: (sessionId: string) => number
+  /** The host's projection of the chat's current work (`structuredAgentSessionCurrentWork`). */
+  currentWork: (sessionId: string) => StructuredAgentSessionCurrentWork | null
   /** The consumed submission is ordinary #22821 work from here on. */
   wakeDelivery: (sessionId: string) => void
   logger: StructuredAgentSessionLogger
@@ -264,9 +242,11 @@ export type QueuedMessageDrainDeps = {
 
 /**
  * The serialized drain. Woken by every journal commit (turn, submission, prompt,
- * command and Stop settlements are all commits), by draft mutations, and by the
- * conversation opening; each step re-derives everything and consumes at most one
- * draft — the consumed submission then owes work, which gates the next.
+ * command and Stop settlements are all commits), by draft mutations, by the
+ * conversation opening, and by a generation ending, which may write nothing
+ * (`StructuredAgentSessionClientDelivery.publishGenerationEnded`); each step
+ * re-derives everything and consumes at most one draft — the consumed submission
+ * then owes work, which gates the next.
  */
 export class StructuredAgentSessionQueuedMessageDrain {
   private readonly scheduled = new Set<string>()
@@ -287,17 +267,13 @@ export class StructuredAgentSessionQueuedMessageDrain {
       return
     }
     // Cheap pre-check so token streams do not pay a serialized step per delta.
-    // Skipping while working is safe: whatever ends the work is itself a commit
-    // that schedules again, and the step re-reads every gate from the fold.
+    // Skipping while working is safe: whatever ends the work is a commit or a generation's end,
+    // and each schedules again; the step re-reads every gate.
     try {
       if (
         !journal.queuedMessages.settlementOwed() &&
         (oldestActionableQueuedMessage(journal, true) === null ||
-          isStructuredAgentSessionMainAgentWorking(
-            journal.activeTurnId(),
-            journal.submissions(),
-            this.deps.conversationFence(sessionId)
-          ))
+          this.deps.currentWork(sessionId)?.working() !== false)
       ) {
         return
       }
@@ -343,7 +319,8 @@ export class StructuredAgentSessionQueuedMessageDrain {
     const fence = this.deps.conversationFence(sessionId)
     // Whatever clears a hold publishes or commits, which re-derives this step.
     const record = this.deps.getRecord(sessionId)
-    const next = nextStructuredQueuedMessage({ journal, record, fence })
+    const work = this.deps.currentWork(sessionId)
+    const next = work ? nextStructuredQueuedMessage({ journal, record, work }) : null
     if (this.disposed || !next) {
       return
     }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-mutations.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-mutations.ts
index a3fee6e2a33..f084a1193a8 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-mutations.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-mutations.ts
@@ -4,6 +4,7 @@
 // from the operation ledger. No mutation returns draft text:
 // the published list is the one authority a client renders.
 
+import { contextStructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 import type { AgentJournalSubmission } from '../../../shared/agent-session-journal-types'
 import { agentSessionOperationKey } from '../../../shared/agent-session-operation-ledger'
 import type {
@@ -131,7 +132,8 @@ export function sendQueuedStructuredAgentMessage(
       // The one queue gate; Send-now's override set is exactly `working` (plus
       // FIFO order and the stored hold, which the consume below clears).
       const record = context.deps.store.getRecord(ctx.sessionId)
-      const hold = structuredQueueHold({ journal: ctx.journal, record, fence: ctx.fence })
+      const work = contextStructuredAgentSessionCurrentWork(ctx)
+      const hold = structuredQueueHold({ record, work })
       if (hold === 'blocked') {
         return structuredAgentSessionSendBlock(record) ?? invalid('This conversation cannot send.')
       }
@@ -154,7 +156,7 @@ export function sendQueuedStructuredAgentMessage(
       }
       // A command never steers: handed over mid-turn it would only be refused. Clients offer its
       // Send only while the agent is idle; this answers an older one that offers it mid-turn.
-      if (hold === 'working' && row.body.command) {
+      if (row.body.command && work.working()) {
         return invalid("A command can't be sent while the agent is working.")
       }
       const submissionId = operationId
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-publication.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-publication.ts
index d48d9bf27c3..1c8185485aa 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-publication.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-publication.ts
@@ -15,10 +15,14 @@ import {
   resumableQueuePause
 } from '../agent-session-journal/queued-message-pause'
 import { structuredQueuePauses } from './structured-agent-session-queued-pause'
-import { nextStructuredQueuedMessage } from './structured-agent-session-queued-messages'
-import { structuredAgentSessionConversationFence } from './structured-agent-session-provider-child'
-import type { AgentSessionRecord } from '../../../shared/agent-session-record'
-import type { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
+import {
+  nextStructuredQueuedMessage,
+  type StructuredQueueGateInput
+} from './structured-agent-session-queued-messages'
+import {
+  heldStructuredAgentSessionCurrentWork,
+  type StructuredAgentSessionCurrentWorkHost
+} from './structured-agent-session-host-current-work'
 
 export type QueuePublication = {
   queuedMessages: AgentSessionQueuedMessage[]
@@ -29,15 +33,20 @@ export type QueuePublication = {
 }
 
 /** What the drain's gate reads beyond the journal; resolved per read. */
-export type QueueSendGate = () => { record: AgentSessionRecord | null; fence: number }
+export type QueueSendGate = (journal: AgentSessionJournal) => StructuredQueueGateInput
 
 export function structuredQueueSendGate(
-  store: Pick<AgentSessionRecordStore, 'getRecord'>,
+  host: StructuredAgentSessionCurrentWorkHost,
   sessionId: string
 ): QueueSendGate {
-  return () => ({
-    record: store.getRecord(sessionId),
-    fence: structuredAgentSessionConversationFence(store, sessionId)
+  return (journal) => ({
+    record: host.store.getRecord(sessionId),
+    work: heldStructuredAgentSessionCurrentWork(
+      host.store,
+      sessionId,
+      journal,
+      host.sessions.get(sessionId)
+    )
   })
 }
 
@@ -135,7 +144,8 @@ export function readQueuePublication(
     resumable && !queuePauseLiftOnItsWay(resumable, journal.submissions()) ? resumable : null
   // The test narrows the type.
   const queuePause = pause?.reason === 'stopped' ? { reason: pause.reason } : null
-  const nextQueuedMessageId = nextStructuredQueuedMessage({ journal, ...gate() })?.messageId ?? null
+  const nextQueuedMessageId =
+    nextStructuredQueuedMessage({ journal, ...gate(journal) })?.messageId ?? null
   const previous = publications.get(journal)
   if (
     previous &&
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-stop.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-stop.ts
index fea52814749..75f53334028 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-stop.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-stop.ts
@@ -14,6 +14,7 @@ import {
 } from '../agent-session-journal/queued-message-table'
 import type { AgentSessionTurnContext, TurnOutcome } from './structured-agent-session-turns'
 import { isMainAgentWorking } from './structured-agent-session-turns-cancel'
+import { contextStructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 import {
   structuredAgentSessionStopNamesTurnNotLive,
   structuredAgentSessionStoppedTurnId
@@ -45,7 +46,11 @@ export async function runRecordedStop<TValue>(
   const skipped = (error: unknown): void => report(ctx, 'event row', error)
   return stop(() => {
     try {
-      const turnId = structuredAgentSessionStoppedTurnId(ctx.journal, event.turnId) ?? undefined
+      const turnId =
+        structuredAgentSessionStoppedTurnId(
+          contextStructuredAgentSessionCurrentWork(ctx),
+          event.turnId
+        ) ?? undefined
       return ctx.journal
         .appendStopEvent({ ...event, ...(turnId ? { turnId } : {}) }, ctx.fence)
         .then(() => undefined, skipped)
@@ -65,10 +70,10 @@ export async function runRecordedStop<TValue>(
  * already over, as a late Stop from a phone can.
  */
 export function stopReachesUnrecordedWork(
-  ctx: Pick<AgentSessionTurnContext, 'journal' | 'fence'>,
+  ctx: Pick<AgentSessionTurnContext, 'journal' | 'fence' | 'currentWork'>,
   namedTurnId: string | undefined
 ): 'unrecorded' | 'repeat' | 'late' {
-  const live = ctx.journal.activeTurnId()
+  const live = contextStructuredAgentSessionCurrentWork(ctx).activeTurnId()
   // No turn published yet while the agent works: the named one may still be opening.
   if (
     structuredAgentSessionStopNamesTurnNotLive(namedTurnId, live) &&
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-wiring.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-wiring.ts
index fc8078ad649..a764aa613e6 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-wiring.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-wiring.ts
@@ -8,6 +8,7 @@ import type {
   StructuredAgentSessionHostSession
 } from './structured-agent-session-host-types'
 import { structuredAgentSessionConversationFence } from './structured-agent-session-provider-child'
+import { hostStructuredAgentSessionCurrentWork } from './structured-agent-session-host-current-work'
 import { StructuredAgentSessionQueuedMessageDrain } from './structured-agent-session-queued-messages'
 import {
   deleteQueuedStructuredAgentMessage,
@@ -36,6 +37,8 @@ export function wireStructuredAgentSessionQueuedMessages(
     serialize: (sessionId, task) => context().serialize(sessionId, task),
     conversationFence: (sessionId) =>
       structuredAgentSessionConversationFence(context().deps.store, sessionId),
+    currentWork: (sessionId) =>
+      hostStructuredAgentSessionCurrentWork({ store: context().deps.store, sessions }, sessionId),
     wakeDelivery: (sessionId) => context().wakeDelivery(sessionId),
     // Read lazily, like the rest of this wiring: the host's deps are not assigned yet.
     logger: deferredStructuredAgentSessionLogger(() => context().deps.logger)
@@ -72,8 +75,11 @@ export function wireStructuredAgentSessionQueuedMessages(
     ) => holdQueuedStructuredAgentMessageEdit(context(), caller, params),
     /** Every journal publish: turn, submission, prompt, command and Stop
      *  settlements are all commits, and each re-derives the drain's gates. */
-    onJournalActivity: (sessionId: string) => {
-      sessions.touch(sessionId)
+    /** `activity`: false for a generation's end, which wakes the drain but is no activity. */
+    onJournalActivity: (sessionId: string, activity = true) => {
+      if (activity) {
+        sessions.touch(sessionId)
+      }
       drain.schedule(sessionId)
     },
     queuedMessageSend: (
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-restart-resume-test-harness.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-restart-resume-test-harness.ts
index e5fa9576f6a..d2fcee941a4 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-restart-resume-test-harness.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-restart-resume-test-harness.ts
@@ -155,11 +155,14 @@ export function journal(
   items: AgentJournalRenderItem[],
   submissions: AgentJournalSubmission[] = []
 ) {
-  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the code under test calls only snapshot(), submissions() and appendItem(); a real AgentSessionJournal needs an on-disk SQLite store.
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the code under test calls only snapshot(), submissions(), appendItem() and the provenance reads; a real AgentSessionJournal needs an on-disk SQLite store.
   return {
     snapshot: () => ({ items, submissions, cursor: { epoch: EPOCH, sequence: items.length } }),
     submissions: () => submissions,
-    appendItem: async () => undefined
+    appendItem: async () => undefined,
+    // Created by the generation the record names: current while its lease is held.
+    itemFence: () => undefined,
+    wroteBeforeOpen: () => false
   } as never
 }
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-provenance.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-provenance.test.ts
new file mode 100644
index 00000000000..6ed2a1d09b7
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-provenance.test.ts
@@ -0,0 +1,154 @@
+// A rewind after a failed cleanup: the dead generation's turn and prompt are still saved as
+// running and pending, and the rewind rebuilds the epoch at the live fence. Through the rewind's
+// own row builders and a real SQLite journal, each carries the old fold's provenance, so the host
+// projection never promotes that work to the live generation's.
+
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { agentJournalItemKey } from '../../../shared/agent-session-journal-item-key'
+import {
+  AGENT_JOURNAL_THREAD_SCOPE,
+  type AgentJournalItemBody,
+  type AgentJournalItemIdentity,
+  type AgentSessionJournalIdentity
+} from '../../../shared/agent-session-journal-types'
+import { codexProviderHandle } from '../../../shared/agent-session-provider-handle-encoding'
+import { createTrackedJournalOpener } from '../agent-session-journal/journal-host-database-test-support'
+import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
+import { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
+import {
+  mergeRetainedHostLifecycleRows,
+  retainedRowReplacement,
+  rewindProviderRows
+} from './structured-rewind-retained-host-rows'
+
+const IDENTITY: AgentSessionJournalIdentity = {
+  sessionId: 'session-1',
+  workspaceId: 'ws-1',
+  hostId: 'host-1',
+  agent: 'codex',
+  providerHandle: codexProviderHandle('thread-1')
+}
+const DEAD = 1
+const LIVE = 3
+
+function codexItem(turnId: string, ordinal: number): AgentJournalItemIdentity {
+  return { provider: 'codex', threadId: 'thread-1', turnId, ordinal }
+}
+const TURN = codexItem('turn-dead', 0)
+const PROMPT = codexItem('turn-dead', 1)
+const REPLY = codexItem('turn-dead', 2)
+const LATER = codexItem('turn-live', 0)
+const PENDING = {
+  state: 'pending' as const,
+  selectedOptionId: null,
+  resolvedBy: null,
+  resolvedAt: null
+}
+const REPLY_BODY: AgentJournalItemBody = {
+  kind: 'message',
+  role: 'assistant',
+  blocks: [{ type: 'text', text: 'partial' }]
+}
+
+const LATER_BODY: AgentJournalItemBody = {
+  kind: 'message',
+  role: 'assistant',
+  blocks: [{ type: 'text', text: 'mine' }]
+}
+
+let root: string
+const journals = createTrackedJournalOpener()
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'orca-rewind-provenance-'))
+})
+
+afterEach(async () => {
+  await journals.closeAll()
+  await rm(root, { recursive: true, force: true })
+})
+
+/** The dead generation's work as its cleanup left it: nothing settled. */
+async function leftByDeadGeneration(): Promise<AgentSessionJournal> {
+  const journal = await journals.open({ identity: IDENTITY, stateDirectory: root })
+  const scope = { fence: DEAD, ownerFence: DEAD, turnScope: AGENT_JOURNAL_THREAD_SCOPE }
+  await journal.appendItem(TURN, { kind: 'turn', turnId: 'turn-dead', state: 'running' }, scope)
+  const inTurn = {
+    ...scope,
+    turnScope: { kind: 'turn' as const, turnItemId: agentJournalItemKey(TURN) }
+  }
+  await journal.appendItem(
+    PROMPT,
+    {
+      kind: 'approval',
+      title: 'Run command?',
+      detail: null,
+      options: [{ id: 'yes', label: 'Allow' }],
+      resolution: PENDING
+    },
+    inTurn
+  )
+  await journal.appendItem(REPLY, REPLY_BODY, inTurn)
+  return journal
+}
+
+/** The rewind's rebuild, as `rewindStructuredAgentSession` and its recovery write it. */
+async function rewindAtLiveFence(journal: AgentSessionJournal): Promise<void> {
+  const retained = journal.snapshot().items.map(({ itemId, observedAt, turnScope }) => {
+    const ownerFence = journal.itemFence(itemId)
+    return {
+      itemId,
+      body: journal.itemBody(itemId)!,
+      observedAt,
+      ...(turnScope ? { turnScope } : {}),
+      ...(ownerFence === undefined ? {} : { ownerFence })
+    }
+  })
+  // The live agent's history names the dead turn's prompt and reply it still holds, and one of
+  // its own.
+  const provider = rewindProviderRows(
+    [
+      { identity: PROMPT, body: journal.itemBody(agentJournalItemKey(PROMPT))! },
+      { identity: REPLY, body: REPLY_BODY },
+      { identity: LATER, body: LATER_BODY }
+    ],
+    2_000,
+    LIVE
+  )
+  const merged = mergeRetainedHostLifecycleRows(retained, provider)
+  await journal.replaceEpochItems('handle_forked', LIVE, merged.map(retainedRowReplacement))
+}
+
+describe('a rewind after a failed cleanup', () => {
+  it("does not promote the dead generation's turn, prompt or reply to the live one", async () => {
+    const journal = await leftByDeadGeneration()
+    const before = journal.epoch
+
+    await rewindAtLiveFence(journal)
+
+    expect(journal.epoch).not.toBe(before)
+    const work = new StructuredAgentSessionCurrentWork(journal, LIVE)
+    // Rebuilt at the live fence, still the dead generation's work.
+    expect(journal.itemFence(agentJournalItemKey(TURN))).toBe(DEAD)
+    expect(journal.itemFence(agentJournalItemKey(PROMPT))).toBe(DEAD)
+    expect(journal.itemFence(agentJournalItemKey(REPLY))).toBe(DEAD)
+    expect(work.activeTurnId()).toBeNull()
+    expect(work.actionablePromptIds()).toEqual([])
+    expect(work.working()).toBe(false)
+    // What the live agent itself reported is its own.
+    expect(work.isCurrentItem(agentJournalItemKey(LATER))).toBe(true)
+  })
+
+  it('leaves a generation that is still live holding its own work', async () => {
+    const journal = await leftByDeadGeneration()
+
+    await rewindAtLiveFence(journal)
+
+    const work = new StructuredAgentSessionCurrentWork(journal, DEAD)
+    expect(work.activeTurnId()).toBe('turn-dead')
+    expect(work.actionablePromptIds()).toEqual([agentJournalItemKey(PROMPT)])
+  })
+})
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.ts
index 5c1f9df0ce4..4c48b155598 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.ts
@@ -18,6 +18,7 @@ import { openWithAgent } from './structured-agent-session-send-preparation'
 import type { StructuredAgentSessionAttachContext } from './structured-agent-session-attach-context'
 import type { StructuredAgentSessionCaller } from './structured-agent-session-host-types'
 import { admitAndRunAgentSessionMutation } from './structured-agent-session-mutation-admission'
+import { hostStructuredAgentSessionCurrentWork } from './structured-agent-session-host-current-work'
 import { conversationCommandBlocked } from './structured-conversation-command-admission'
 import { rewindRefusal } from './structured-rewind-refusal'
 import { renameRewindTurnOpener } from './structured-rewind-journal-body'
@@ -60,6 +61,8 @@ export async function rewindStructuredAgentSession(
           : { ok: true }
       }),
       journal: () => context.sessions.get(sessionId)?.journal,
+      currentWork: () =>
+        hostStructuredAgentSessionCurrentWork({ store, sessions: context.sessions }, sessionId),
       publish: (journal) => context.publish(sessionId, journal),
       now: context.now,
       plan: {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-settlement.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-settlement.test.ts
index 677963ab3f9..b6e7cdb4d3c 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-settlement.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-settlement.test.ts
@@ -1,9 +1,12 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
-import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
-import { StructuredAgentSessionSendSettlement } from './structured-agent-session-send-settlement'
+import {
+  StructuredAgentSessionSendSettlement,
+  type SendSettlementJournal
+} from './structured-agent-session-send-settlement'
 
-function journal(dispatchState: 'pending' | 'accepted' | 'unknown'): AgentSessionJournal {
+function journal(dispatchState: 'pending' | 'accepted' | 'unknown'): SendSettlementJournal {
   return {
+    activeTurnId: () => null,
     cursor: () => ({ epoch: 'epoch-1', sequence: dispatchState === 'pending' ? 1 : 2 }),
     submissions: () => [
       {
@@ -17,21 +20,19 @@ function journal(dispatchState: 'pending' | 'accepted' | 'unknown'): AgentSessio
         resolvedAt: dispatchState === 'pending' ? null : 2
       }
     ]
-  } as AgentSessionJournal
+  }
 }
 
-function emptyJournal(): AgentSessionJournal {
+function emptyJournal(): SendSettlementJournal {
   return {
+    activeTurnId: () => null,
     cursor: () => ({ epoch: 'epoch-1', sequence: 2 }),
     submissions: () => []
-  } as unknown as AgentSessionJournal
+  }
 }
 
 /** A message accepted and not yet handed over, while `activeTurnId` names the running turn. */
-function queuedJournal(
-  activeTurnId: string | null,
-  handedOver = false
-): Pick<AgentSessionJournal, 'submissions' | 'cursor' | 'activeTurnId'> {
+function queuedJournal(activeTurnId: string | null, handedOver = false): SendSettlementJournal {
   return {
     cursor: () => ({ epoch: 'epoch-1', sequence: handedOver ? 3 : 2 }),
     activeTurnId: () => activeTurnId,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-settlement.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-settlement.ts
index a9815b953f8..b89d36ffe3b 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-settlement.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-settlement.ts
@@ -7,8 +7,12 @@ import { isQueuedAgentJournalSubmission } from '../../../shared/agent-session-qu
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
 import { isStructuredAgentSessionCommandTurnId } from './structured-agent-session-command-turn'
 
-/** What a settlement read needs of a journal. */
-type SendSettlementJournal = Pick<AgentSessionJournal, 'submissions' | 'cursor' | 'activeTurnId'>
+/** What a settlement read needs: the journal's sends and position, and the live generation's
+ *  running turn as the host's projection reads it (`structuredAgentSessionCurrentWork`), so a send
+ *  never reads as waiting behind a command an ended generation left. */
+export type SendSettlementJournal = Pick<AgentSessionJournal, 'submissions' | 'cursor'> & {
+  activeTurnId: () => string | null
+}
 
 type SettledSend = {
   cursor: AgentJournalCursor
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-shown-work.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-shown-work.ts
index 4ed41e8c688..7f97faa864f 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-shown-work.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-shown-work.ts
@@ -15,6 +15,7 @@ import {
   type StructuredAgentSessionAgentStatus
 } from '../../../shared/structured-agent-session-agent-status'
 import { projectStructuredAgentSessionStatus } from '../../../shared/structured-agent-session-projection'
+import type { StructuredAgentSessionWorkScope } from '../../../shared/structured-agent-session-main-agent-working'
 
 /** The full row the sidebar's fold would show, for callers that need the lead's own state beside
  *  the working answer — the teardown snapshot records both from this one computation. */
@@ -25,9 +26,17 @@ export function structuredAgentSessionShownStatus(
   },
   childWork: readonly AgentChildWorkView[] | undefined,
   /** The session's lease fence, as the status feed passes it: a send from an older one is not work. */
-  fence: number | undefined
+  fence: number | undefined,
+  /** The host's projection of current work (`structuredAgentSessionCurrentWork`), as the status
+   *  feed passes it: an ended generation's turn is not work. */
+  scope?: StructuredAgentSessionWorkScope
 ): StructuredAgentSessionAgentStatus {
-  const status = projectStructuredAgentSessionStatus(journal.items, journal.submissions, fence)
+  const status = projectStructuredAgentSessionStatus(
+    journal.items,
+    journal.submissions,
+    fence,
+    scope
+  )
   return structuredAgentSessionAgentStatus({
     status,
     ...(childWork ? { childWork } : {})
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-signed-out-child.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-signed-out-child.test.ts
index ae09e13d878..02a4e11d91d 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-signed-out-child.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-signed-out-child.test.ts
@@ -126,7 +126,6 @@ const conversation = (
     child?: StructuredAgentSessionProviderChild | null
     items?: Row[]
     submissions?: ReturnType<typeof rejected>[]
-    activeTurnId?: string
     newestTurnEndedAt?: number
   } = {}
 ) => {
@@ -142,7 +141,6 @@ const conversation = (
           visit(item.itemId, index, item.body, item.agentId ? { agentId: item.agentId } : {})
         ),
       itemFence: (itemId: string) => items.find((item) => item.itemId === itemId)?.fence,
-      activeTurnId: () => input.activeTurnId ?? null,
       newestTurn: (): AgentJournalTurnLifecycle | null =>
         input.newestTurnEndedAt === undefined
           ? null
@@ -197,6 +195,7 @@ describe('retireSignedOutStructuredAgentSessionChild', () => {
     invocation: { invocationId: 'spawn-subagent-1', generation: 1 }
   }
   const idle: StructuredAgentSessionChildWorkReads = {
+    currentWork: () => ({ activeTurnId: () => null, hasActionablePrompt: () => false }),
     childWork: () => [],
     hasOpenDispatch: () => false,
     providerHoldsDispatch: () => false
@@ -223,7 +222,9 @@ describe('retireSignedOutStructuredAgentSessionChild', () => {
   it('keeps it while it owes work the idle sweep also protects', async () => {
     // A pending prompt is the shared check's too; the idle sweep's tests cover that case.
     for (const kept of [
-      await retire({ ...signedOut, activeTurnId: 'turn-1' }),
+      await retire(signedOut, {
+        currentWork: () => ({ activeTurnId: () => 'turn-1', hasActionablePrompt: () => false })
+      }),
       await retire(signedOut, { childWork: () => [liveChildWork] }),
       await retire(signedOut, { hasOpenDispatch: () => true }),
       await retire(signedOut, { providerHoldsDispatch: () => true })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-signed-out-child.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-signed-out-child.ts
index 40ea59a69eb..a4315eeb1ca 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-signed-out-child.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-signed-out-child.ts
@@ -16,10 +16,7 @@ import type { StructuredAgentSessionLogger } from './structured-agent-session-lo
 
 /** What the check reads of a conversation; every read skips building a snapshot. */
 type SignedOutReading = Pick<StructuredAgentSessionHostSession, 'child'> & {
-  journal: Pick<
-    AgentSessionJournal,
-    'visitItems' | 'visitItemsWithLinkage' | 'itemFence' | 'activeTurnId' | 'newestTurn'
-  > & {
+  journal: Pick<AgentSessionJournal, 'visitItemsWithLinkage' | 'itemFence' | 'newestTurn'> & {
     submissions(): readonly Pick<AgentJournalSubmission, 'dispatchState' | 'fence' | 'rejection'>[]
   }
 }
@@ -94,7 +91,7 @@ export async function retireSignedOutStructuredAgentSessionChild(
   if (
     !session ||
     !structuredAgentSessionChildReportedSignedOut(session, deps.startUnavailable?.()) ||
-    structuredAgentSessionChildHasOpenWork(session.journal, deps.work) ||
+    structuredAgentSessionChildHasOpenWork(deps.work) ||
     owesWakeUp(session.journal, deps.work.childWork())
   ) {
     return
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
index fed25d7dc9b..b79b0cd3ff5 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
@@ -57,7 +57,7 @@ function contextFor(session: StructuredAgentSessionChildExitSession) {
     },
     sessions: new Map([[SESSION, session]]),
     flushLifecycle: async () => ({ ok: true }),
-    publishFence: vi.fn(),
+    generationEnded: vi.fn(),
     serialize: async <T>(_sessionId: string, task: () => Promise<T>) => task(),
     now: () => 1
   }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.test.ts
index 9fa62fd170e..0a24a6b805b 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.test.ts
@@ -360,6 +360,8 @@ describe('StructuredAgentSessionStatusFeed', () => {
 
   it('carries the record model and the running tool line the sidebar row shows', async () => {
     const journal = await openJournal()
+    // Written by the record's current generation: work an ended one left never reads working.
+    const fence = agentSessionRecordFixture().lease.runtimeFence
     const { feed, events } = feedFor(new Map([[SESSION, { journal }]]), {
       location: indexed({ journal }).params.location,
       options: { model: 'gpt-5-codex' },
@@ -368,12 +370,12 @@ describe('StructuredAgentSessionStatusFeed', () => {
     await journal.appendItem(
       USER_IDENTITY,
       { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'run the tests' }] },
-      { fence: 1, turnScope: AGENT_JOURNAL_THREAD_SCOPE }
+      { fence, turnScope: AGENT_JOURNAL_THREAD_SCOPE }
     )
     await journal.appendItem(
       TURN_IDENTITY,
       { kind: 'status', text: 'Working', turnLifecycle: { turnId: 'turn-1', state: 'running' } },
-      { fence: 1, turnScope: AGENT_JOURNAL_THREAD_SCOPE }
+      { fence, turnScope: AGENT_JOURNAL_THREAD_SCOPE }
     )
     feed.publish(SESSION)
     expect(events.at(-1)).toEqual({
@@ -384,7 +386,7 @@ describe('StructuredAgentSessionStatusFeed', () => {
     await journal.appendItem(
       { ...USER_IDENTITY, ordinal: 2 },
       { kind: 'tool-call', name: 'shell', input: { command: 'pnpm test' }, state: 'running' },
-      { fence: 1, turnScope: AGENT_JOURNAL_THREAD_SCOPE }
+      { fence, turnScope: AGENT_JOURNAL_THREAD_SCOPE }
     )
     feed.publish(SESSION)
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.ts
index 2a26af994dc..81b9a273c46 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.ts
@@ -19,7 +19,10 @@ import type {
 import type { AgentChildWorkEvidence } from '../../../shared/agent-status-child-work-evidence'
 import type { AgentChildWorkView } from '../../../shared/agent-status-child-work-view'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
-import type { StructuredAgentSessionProviderChild } from './structured-agent-session-host-types'
+import type {
+  StructuredAgentSessionEndedChild,
+  StructuredAgentSessionProviderChild
+} from './structured-agent-session-host-types'
 import { structuredAgentSessionStatusSummary } from './structured-agent-session-status-summary'
 import { structuredStatusChildWork } from './structured-agent-session-status-child-work'
 import {
@@ -46,12 +49,17 @@ type StatusFeedSession = {
   journal: AgentSessionJournal
   params: { location: AgentSessionRecord['location']; provider: AgentSessionRecord['provider'] }
   child?: Pick<StructuredAgentSessionProviderChild, 'phase' | 'generation' | 'fence'> | null
+  /** What the current-work projection reads of the last child this host saw end. */
+  lastEndedChild?: Pick<StructuredAgentSessionEndedChild, 'fence' | 'rootGone'>
+  operationalRevision?: number
   restartResume?: AgentSessionStatusSummary['restartResume']
 }
 
 export type StructuredAgentSessionStatusFeedDeps = {
   sessions: ReadonlyMap<string, StatusFeedSession>
   getRecord: (sessionId: string) => AgentSessionRecord | null
+  /** `AgentSessionRecordStore.replacedRuntime`; absent where no runtime was replaced. */
+  replacedRuntime?: (sessionId: string) => { fence: number } | undefined
   now: () => number
   /** Where a failing sink or observer is reported; neither may cost subscribers their event. */
   logger: StructuredAgentSessionLogger
@@ -86,7 +94,10 @@ export class StructuredAgentSessionStatusFeed {
   /** The user's newest accepted send each session was last projected with; a new one retires
    *  settled children. */
   private readonly acceptedSends = new Map<string, string>()
-  private readonly projections = new StructuredAgentSessionJournalProjections()
+  // Read per call: field initializers run before the constructor assigns `deps`.
+  private readonly projections = new StructuredAgentSessionJournalProjections((sessionId) =>
+    this.deps.replacedRuntime?.(sessionId)
+  )
 
   constructor(private readonly deps: StructuredAgentSessionStatusFeedDeps) {}
 
@@ -208,8 +219,9 @@ export class StructuredAgentSessionStatusFeed {
     sessionId: string,
     journal?: AgentSessionJournal
   ): StructuredAgentSessionJournalProjection | null {
-    const source = journal ?? this.deps.sessions.get(sessionId)?.journal
-    return source ? this.projections.read(source, this.deps.getRecord(sessionId)) : null
+    const session = this.deps.sessions.get(sessionId)
+    const source = journal ?? session?.journal
+    return source ? this.projections.read(source, this.deps.getRecord(sessionId), session) : null
   }
 
   /** Re-projects one session after its journal changed; equal projections are not re-sent. */
@@ -220,7 +232,7 @@ export class StructuredAgentSessionStatusFeed {
     }
     const source = journal ?? session.journal
     const record = this.deps.getRecord(sessionId)
-    const projection = this.projections.read(source, record)
+    const projection = this.projections.read(source, record, session)
     this.retireSettledChildrenOnNewTurn(sessionId, session, projection.acceptedSendKey)
     const summary = structuredAgentSessionStatusSummary({
       sessionId,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-status-journal-projection.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-status-journal-projection.ts
index f28a49c81ae..23347ef6948 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-status-journal-projection.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-status-journal-projection.ts
@@ -7,6 +7,10 @@ import { isStructuredAgentSessionCommandEntry } from '../../../shared/structured
 import type { AgentSessionRecord } from '../../../shared/agent-session-record'
 import { projectStructuredAgentSessionStatusState } from '../../../shared/structured-agent-session-projection'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
+import {
+  structuredAgentSessionCurrentWork,
+  type StructuredAgentSessionWorkEvidence
+} from './structured-agent-session-current-work'
 import { newestAcceptedSendKey } from './structured-agent-session-status-child-work'
 import { structuredAgentSessionStopping } from './structured-agent-session-stopping'
 
@@ -18,6 +22,12 @@ export type StructuredAgentSessionJournalProjection = {
   epoch: string
   sequence: number
   fence: number | undefined
+  /** The live generation's fence (`structuredAgentSessionLiveFence`): an exit this host saw, or a
+   *  release, changes what is current without a journal row. */
+  liveFence: number | null
+  /** `StructuredAgentSessionCurrentWork.revision`: what this host saw end with no row or lease
+   *  write still changes the row. */
+  workRevision: number
   /** The Stop marks' settle revision: a settle edge writes no row, so it is a key of its own. */
   stopRevision: number
   state: StructuredAgentSessionStatusState
@@ -35,13 +45,34 @@ export class StructuredAgentSessionJournalProjections {
     StructuredAgentSessionJournalProjection
   >()
 
+  /** `AgentSessionRecordStore.replacedRuntime`, which ends what a replaced runtime held. */
+  constructor(
+    private readonly replacedRuntime?: (
+      sessionId: string
+    ) => StructuredAgentSessionWorkEvidence['replaced']
+  ) {}
+
   read(
     journal: AgentSessionJournal,
-    record: AgentSessionRecord | null
+    record: AgentSessionRecord | null,
+    /** What this host saw end (`StructuredAgentSessionHostSession`). */
+    seen?: {
+      lastEndedChild?: StructuredAgentSessionWorkEvidence['ended']
+      operationalRevision?: number
+      child?: StructuredAgentSessionWorkEvidence['child']
+    }
   ): StructuredAgentSessionJournalProjection {
     const cursor = journal.cursor()
     // The conversation's fence, which a child's end moves: its unanswered sends stop counting.
     const fence = record?.lease.runtimeFence
+    const ended = seen?.lastEndedChild
+    const work = structuredAgentSessionCurrentWork(journal, {
+      record,
+      replaced: record ? this.replacedRuntime?.(record.sessionId) : undefined,
+      child: seen?.child ?? null,
+      ...(ended ? { ended } : {}),
+      revision: seen?.operationalRevision ?? 0
+    })
     const stopRevision = journal.stopMarks.revision()
     let projection = this.byJournal.get(journal)
     if (
@@ -49,6 +80,8 @@ export class StructuredAgentSessionJournalProjections {
       projection.epoch !== cursor.epoch ||
       projection.sequence !== cursor.sequence ||
       projection.fence !== fence ||
+      projection.liveFence !== work.liveFence ||
+      projection.workRevision !== work.revision ||
       projection.stopRevision !== stopRevision
     ) {
       // A journalled submission bumps `lastSequence`, so the send-time working
@@ -81,17 +114,45 @@ export class StructuredAgentSessionJournalProjections {
         firstInputSubmissionKey,
         submissionCount: snapshot.submissions.length,
         fence,
+        liveFence: work.liveFence,
+        workRevision: work.revision,
         stopRevision,
-        state: projectStructuredAgentSessionStatusState(
-          snapshot.items,
-          snapshot.submissions,
-          fence
+        // The host's projection of current work: an ended generation's is not Working.
+        state: withDiedTurnVerdict(
+          projectStructuredAgentSessionStatusState(
+            snapshot.items,
+            snapshot.submissions,
+            fence,
+            work.scope
+          ),
+          work.diedTurn()
         ),
         acceptedSendKey: newestAcceptedSendKey(cursor.epoch, snapshot.submissions),
-        stopping: structuredAgentSessionStopping(journal, snapshot.items, snapshot.submissions)
+        stopping: structuredAgentSessionStopping(
+          journal,
+          snapshot.items,
+          snapshot.submissions,
+          work.scope
+        )
       }
       this.byJournal.set(journal, projection)
     }
     return projection
   }
 }
+
+/** A turn whose generation died on its own reads as its settlement writes it, interrupted, before
+ *  that lands: never a finish with no verdict (`StructuredAgentSessionCurrentWork.diedTurn`). */
+function withDiedTurnVerdict(
+  state: StructuredAgentSessionStatusState,
+  died: { turnId: string } | null
+): StructuredAgentSessionStatusState {
+  const request = state.latestRequest
+  return died &&
+    state.summary.status === 'idle' &&
+    request?.kind === 'turn' &&
+    request.id === died.turnId &&
+    request.turnState === 'running'
+    ? { ...state, summary: { ...state.summary, turnOutcome: 'interruption' } }
+    : state
+}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-binding.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-binding.test.ts
index 250c00bd1f5..3ad178f350b 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-binding.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-binding.test.ts
@@ -122,7 +122,7 @@ async function stopOfStart(options: { held?: true } = {}): Promise<string | unde
 /** Orchestration mail after the Stop starts a new child and its turn runs. */
 async function mailTurn(): Promise<void> {
   const handedOver = rig.dispatch.mock.calls.length
-  const mail = rig.send('mail for the worker')
+  const mail = rig.send('mail for the retry')
   await mail.result
   await rig.proveStart()
   await eventually(() => expect(rig.dispatch).toHaveBeenCalledTimes(handedOver + 1))
@@ -167,7 +167,7 @@ describe('a Stop of a start that never landed binds no later turn', () => {
 
   it('reads a mail turn the child end cut, with no verdict of its own, as news', async () => {
     await stopOfStart()
-    const mail = rig.send('mail for the worker')
+    const mail = rig.send('mail for the retry')
     await mail.result
     await turnOpenedBy(mail.id)
 
@@ -248,7 +248,7 @@ describe('a Stop pressed before its send opened a turn binds only the turn it st
     expect(laterTurnEndRows()).toEqual([
       expect.objectContaining({ state: 'interrupted', outcome: 'cancellation' })
     ])
-    expect(journal().activeTurnId()).toBeNull()
+    expect(journal().runningTurn()?.turnId ?? null).toBeNull()
   })
 
   it('binds no turn that opens after a Stop that stopped nothing', async () => {
@@ -346,7 +346,7 @@ describe("a Stop's settle that ends the turn its interrupt took", () => {
     expect(await rig.stop()).toMatchObject({ ok: true, value: { cancelled: true } })
 
     expect(await laterTurn()).toMatchObject({ state: 'interrupted', outcome: 'cancellation' })
-    expect(journal().activeTurnId()).toBeNull()
+    expect(journal().runningTurn()?.turnId ?? null).toBeNull()
   })
 })
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-entries.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-entries.test.ts
index 17a274d6f5f..9bba98fcf3d 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-entries.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-entries.test.ts
@@ -269,7 +269,7 @@ describe('every Stop entry writes its event, with its reason, before it ends the
       { kind: 'turn', turnId: 'turn-1', state: 'interrupted', completedAt: Date.now() },
       { fence: 1, turnScope: AGENT_JOURNAL_THREAD_SCOPE }
     )
-    expect(journal().activeTurnId()).toBeNull()
+    expect(journal().runningTurn()?.turnId ?? null).toBeNull()
     const sink = rig.host['runtimeState'].eventSinkFor(HOST_TEST_SESSION)
     const drained = sink.drained.bind(sink)
     vi.spyOn(sink, 'drained')
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-restart.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-restart.test.ts
index 55eb9080a5b..26851761a5b 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-restart.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event-restart.test.ts
@@ -364,7 +364,7 @@ describe('a restart between a Stop and its turn end', () => {
       return new Promise<never>(() => undefined)
     })
     void rig.stop()
-    await expect.poll(() => journal().activeTurnId()).toBe(TURN)
+    await expect.poll(() => journal().runningTurn()?.turnId ?? null).toBe(TURN)
     expect(journal().stopMarks.latest()?.event.turnId).toBeUndefined()
 
     await restartAndSettle('exit-observed')
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event.test.ts
index ea0dae59199..f243af3ba3c 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-event.test.ts
@@ -258,7 +258,7 @@ describe("a Stop's event", () => {
     await rig.settleAccepted(working, 'working')
     await turnRow('turn-1', 'interrupted')
     await eventually(async () => expect((await rig.handoff(next))?.handedOverAt).toBeDefined())
-    expect(journal().activeTurnId()).toBeNull()
+    expect(journal().runningTurn()?.turnId ?? null).toBeNull()
     const fields = { turnId: 'turn-1' }
     await rig.host.cancel(QUEUED_RIG_CALLER, {
       envelope: rig.envelope(fields, 'agentSession.cancel', hostTestOperationId()),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-never-waits.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-never-waits.test.ts
index 4cbc39073c1..526c82de0b2 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-never-waits.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-never-waits.test.ts
@@ -45,7 +45,7 @@ async function runningTurn(): Promise<AgentSessionJournal> {
     throw new Error('no open journal')
   }
   // The turn row landed when the provider's event was handed over.
-  expect(journal.activeTurnId()).toBe('turn-1')
+  expect(journal.runningTurn()?.turnId ?? null).toBe('turn-1')
   return journal
 }
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-settle-binding.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-settle-binding.test.ts
index a3fee6b2ed4..ed528949a95 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-settle-binding.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-settle-binding.test.ts
@@ -66,7 +66,7 @@ function openedTurn() {
 
 function nothingRuns(): boolean {
   return !isStructuredAgentSessionMainAgentWorking(
-    journal().activeTurnId(),
+    journal().runningTurn()?.turnId ?? null,
     journal().submissions()
   )
 }
@@ -169,11 +169,13 @@ describe("a person's close pressed before its send's turn showed", () => {
     await rig.host['lifetime'].stopAgent(HOST_TEST_SESSION, { cause: 'user-close' })
     expect(journal().stopMarks.latest()?.event).toMatchObject({ reason: 'user-close' })
     expect(journal().stopMarks.latest()?.event).not.toHaveProperty('turnId')
+    // The next child's turn, at the fence the stopped one's end moved to.
+    const fence = rig.store.getRecord(HOST_TEST_SESSION)!.lease.runtimeFence
 
     await journal().appendItem(
       LATER,
       { kind: 'turn', turnId: 'turn-later', state: 'running', startedAt: Date.now() },
-      { fence: 1, turnScope: AGENT_JOURNAL_THREAD_SCOPE }
+      { fence, turnScope: AGENT_JOURNAL_THREAD_SCOPE }
     )
     await journal().appendItem(
       LATER,
@@ -184,7 +186,7 @@ describe("a person's close pressed before its send's turn showed", () => {
         startedAt: Date.now(),
         completedAt: Date.now() + 5
       },
-      { fence: 1, turnScope: AGENT_JOURNAL_THREAD_SCOPE }
+      { fence, turnScope: AGENT_JOURNAL_THREAD_SCOPE }
     )
 
     const later = journal()
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-wind-down.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-wind-down.ts
index 8750fe909a0..a6dc5d103b0 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-stop-wind-down.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-stop-wind-down.ts
@@ -11,6 +11,7 @@ import {
   type AgentJournalTurnScope
 } from '../../../shared/agent-session-journal-types'
 import { isMainAgentWorking } from './structured-agent-session-turns-cancel'
+import { contextStructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 import type { AgentSessionTurnContext } from './structured-agent-session-turns'
 import type { JournalStopFailedOn } from '../agent-session-journal/queued-message-pause'
 import { structuredAgentSessionFailedStopMark } from './structured-agent-session-stopping'
@@ -38,7 +39,7 @@ export type StructuredAgentSessionStopWindDown = {
  * keeps the child on record, and the next operation that reaches the agent joins that close.
  */
 export async function endStoppedStructuredAgentSession(
-  ctx: Pick<AgentSessionTurnContext, 'sessionId' | 'adapter' | 'journal' | 'fence'>,
+  ctx: Pick<AgentSessionTurnContext, 'sessionId' | 'adapter' | 'journal' | 'fence' | 'currentWork'>,
   windDown: StructuredAgentSessionStopWindDown,
   stopChild: () => Promise<void>,
   onError: (error: unknown) => void
@@ -51,7 +52,10 @@ export async function endStoppedStructuredAgentSession(
     await stopChild()
   } catch (error) {
     onError(error)
-    failedOn = structuredAgentSessionFailedStopMark(ctx.journal)
+    failedOn = structuredAgentSessionFailedStopMark(
+      contextStructuredAgentSessionCurrentWork(ctx),
+      ctx.journal
+    )
     await reviseStopNoteUnconfirmed(ctx, windDown.stopNote).catch(onError)
   } finally {
     windDown.settled?.(failedOn)
@@ -61,7 +65,7 @@ export async function endStoppedStructuredAgentSession(
 /** While the work it stopped runs on, the Stop's own note, if it wrote one, says what a lost
  *  interrupt's says. Work that ended took the Stop, whatever became of the child. */
 async function reviseStopNoteUnconfirmed(
-  ctx: Pick<AgentSessionTurnContext, 'journal' | 'fence'>,
+  ctx: Pick<AgentSessionTurnContext, 'journal' | 'fence' | 'currentWork'>,
   identity: AgentJournalItemIdentity
 ): Promise<void> {
   if (!isMainAgentWorking(ctx)) {
@@ -85,7 +89,7 @@ async function reviseStopNoteUnconfirmed(
   // Stop of that turn writes it: its proven end finds it there. A row keeps the scope it was created
   // with, so a note a Stop wrote before the turn showed is re-keyed, in one batch. Known limit: with
   // no turn open yet, the note keeps its key and scope, and no turn's end revises it.
-  const running = ctx.journal.activeTurnId()
+  const running = contextStructuredAgentSessionCurrentWork(ctx).activeTurnId()
   const turnScope =
     running !== null ? structuredAgentSessionNamedTurnScope(ctx.journal, running) : null
   const onTurn = running !== null ? structuredAgentSessionStopNoteIdentity(running) : identity
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-stopping.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-stopping.test.ts
index 92cd6f57433..3dbc001b951 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-stopping.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-stopping.test.ts
@@ -268,7 +268,7 @@ describe('a Stop that failed before the turn it meant to stop opened', () => {
     expect(await rig.stop()).toMatchObject({ ok: true })
     // A Stop that ends its session ends the child on the session's next step.
     await rig.host['tasks'].serialize(HOST_TEST_SESSION, async () => {})
-    expect(journal().activeTurnId()).toBeNull()
+    expect(journal().runningTurn()?.turnId ?? null).toBeNull()
     return { sent, status }
   }
 
@@ -283,7 +283,7 @@ describe('a Stop that failed before the turn it meant to stop opened', () => {
 
       await rig.settleAccepted(sent, 'sent')
       await turn('turn-1', sent, 'running')
-      await eventually(() => expect(journal().activeTurnId()).toBe('turn-1'))
+      await eventually(() => expect(journal().runningTurn()?.turnId ?? null).toBe('turn-1'))
       expect(status()).toMatchObject({ status: 'working', stopping: true })
       await turn('turn-1', sent, 'interrupted')
       await eventually(() => expect(status()?.status).toBe('idle'))
@@ -351,7 +351,7 @@ describe('a Stop pressed before its send opened a turn', () => {
   it('ends the turn its interrupt took at the settle, and Stopping with it', async () => {
     const { status } = await stopAsTheTurnOpens({ cancelled: true, turnId: 'turn-1' })
 
-    expect(journal().activeTurnId()).toBeNull()
+    expect(journal().runningTurn()?.turnId ?? null).toBeNull()
     await eventually(() => expect(status()?.status).toBe('idle'))
     expect(status()).not.toHaveProperty('stopping')
   })
@@ -390,7 +390,7 @@ describe('a Stop pressed before its send opened a turn', () => {
     expect(status()).not.toHaveProperty('stopping')
     await rig.settleAccepted(sent, 'sent')
     await turn('turn-1', sent, 'running')
-    await eventually(() => expect(journal().activeTurnId()).toBe('turn-1'))
+    await eventually(() => expect(journal().runningTurn()?.turnId ?? null).toBe('turn-1'))
     expect(status()).not.toHaveProperty('stopping')
   })
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-stopping.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-stopping.ts
index 284a474b9c6..c491814f542 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-stopping.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-stopping.ts
@@ -10,6 +10,8 @@ import type {
 } from '../../../shared/agent-session-journal-types'
 import { readAgentJournalTurn } from '../../../shared/agent-session-turn-record'
 import { activeStructuredAgentSessionTurnId } from '../../../shared/structured-agent-session-live-turn'
+import type { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
+import type { StructuredAgentSessionWorkScope } from '../../../shared/structured-agent-session-main-agent-working'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
 import { stopIsAPersons } from '../agent-session-journal/journal-stop-turn-end'
 import type { JournalStopFailedOn } from '../agent-session-journal/queued-message-pause'
@@ -19,7 +21,9 @@ import type { JournalStopFailedOn } from '../agent-session-journal/queued-messag
 export function structuredAgentSessionStopping(
   journal: Pick<AgentSessionJournal, 'stopMarks'>,
   items: readonly AgentJournalRenderItem[],
-  submissions: readonly AgentJournalSubmission[] = []
+  submissions: readonly AgentJournalSubmission[] = [],
+  /** The host's projection of current work: a Stop bound to an ended generation's turn is over. */
+  scope?: StructuredAgentSessionWorkScope
 ): boolean {
   const stop = journal.stopMarks.latest()
   if (stop === null || !stopIsAPersons(stop.event.reason)) {
@@ -33,7 +37,10 @@ export function structuredAgentSessionStopping(
     stop.event.turnId ??
     stop.settle?.turnId ??
     (failed && 'turnId' in failed ? failed.turnId : undefined)
-  const live = activeStructuredAgentSessionTurnId(items)
+  const live = activeStructuredAgentSessionTurnId(
+    items,
+    scope && ((item) => scope.isCurrentItem(item.itemId))
+  )
   if (bound !== undefined) {
     return bound === live
   }
@@ -64,9 +71,10 @@ function firstSendHandedOverAfter(
 /** Where a Stop that failed leaves "Stopping…" (display only): the turn running now, or, with
  *  none, the first that opens after this position. */
 export function structuredAgentSessionFailedStopMark(
-  journal: Pick<AgentSessionJournal, 'activeTurnId' | 'cursor'>
+  work: Pick<StructuredAgentSessionCurrentWork, 'activeTurnId'>,
+  journal: Pick<AgentSessionJournal, 'cursor'>
 ): JournalStopFailedOn {
-  const live = journal.activeTurnId()
+  const live = work.activeTurnId()
   return live !== null ? { turnId: live } : { openedAfter: journal.cursor().sequence }
 }
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-subscribers.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-subscribers.ts
index dcd3e07c4f2..5e0470430e6 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-subscribers.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-subscribers.ts
@@ -22,6 +22,7 @@ import { emptyAgentSessionBatch } from './agent-session-empty-batch'
 import { readAgentSessionHydrationPage } from './agent-session-history-page'
 import { rememberSessionActivity } from './structured-agent-session-activity-retention'
 import { refreshDerivedStopNotes } from './agent-session-stop-note-refresh'
+import type { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 
 export type AgentSessionSubscriberEmit = (event: AgentSessionSubscribeEvent) => void
 export type AgentSessionSubscribeInput = {
@@ -43,6 +44,9 @@ export type Subscriber = {
   queuePublication?: QueuePublication
   /** Fingerprint of the background-task roster last SENT. */
   backgroundTasks?: string
+  /** The current-work view the last frame's fields were read under
+   *  (`StructuredAgentSessionCurrentWork.viewKey`); a change with no row still owes a frame. */
+  workView?: string
 }
 
 export type AgentSessionSubscribersHooks = {
@@ -53,6 +57,12 @@ export type AgentSessionSubscribersHooks = {
   readBackgroundTasks?: SubscriberFieldHooks['readBackgroundTasks']
   /** Fires after publications that can change journal content. */
   onJournalPublished?: (sessionId: string, journal: AgentSessionJournal) => void
+  /** The host's projection of current work (`structuredAgentSessionCurrentWork`), which every
+   *  page and frame states as its turn and prompt fields. */
+  readCurrentWork?: (
+    sessionId: string,
+    journal: AgentSessionJournal
+  ) => StructuredAgentSessionCurrentWork | undefined
   now?: () => number
 }
 
@@ -100,10 +110,13 @@ export class AgentSessionSubscribers {
         },
         subscriber,
         input.journal,
-        hostNow
+        hostNow,
+        this.hooks.readCurrentWork?.(input.sessionId, input.journal)
       )
     } else {
-      const page = readAgentSessionHydrationPage(input.journal, input.fence)
+      const work = this.hooks.readCurrentWork?.(input.sessionId, input.journal)
+      const page = readAgentSessionHydrationPage(input.journal, input.fence, work)
+      subscriber.workView = work?.viewKey()
       this.emit(subscriber, {
         type: 'snapshot',
         sessionId: input.sessionId,
@@ -144,20 +157,36 @@ export class AgentSessionSubscribers {
         this.activityBySession.delete(sessionId)
       }
     }
-    const hostNow = this.now()
-    for (const subscriber of this.subscribers(sessionId)) {
-      this.deliver(subscriber, journal, hostNow, false, activity)
-    }
+    this.deliverFrames(sessionId, journal, activity)
     if (activity === undefined) {
       this.hooks.onJournalPublished?.(sessionId, journal)
     }
   }
 
-  /** Every subscriber back to a bounded tail page. */
-  snapshot(sessionId: string, journal: AgentSessionJournal, fence: number): void {
-    const page = readAgentSessionHydrationPage(journal, fence)
+  /** The queue as frames publish it, for a history page to read the same. */
+  readQueuePublication(sessionId: string): QueuePublication | undefined {
+    return this.hooks.readQueuePublication?.(sessionId)
+  }
+
+  /** Each subscriber's frame for what changed, with none of a journal write's other edges. */
+  deliverFrames(
+    sessionId: string,
+    journal: AgentSessionJournal,
+    activity?: AgentSessionTurnActivity | null
+  ): void {
     const hostNow = this.now()
     for (const subscriber of this.subscribers(sessionId)) {
+      this.deliver(subscriber, journal, hostNow, false, activity)
+    }
+  }
+
+  /** Every subscriber back to a bounded tail page. */
+  snapshot(sessionId: string, journal: AgentSessionJournal, fence: number): void {
+    const work = this.hooks.readCurrentWork?.(sessionId, journal)
+    const page = readAgentSessionHydrationPage(journal, fence, work)
+    const hostNow = this.now()
+    for (const subscriber of this.subscribers(sessionId)) {
+      subscriber.workView = work?.viewKey()
       this.emit(subscriber, {
         type: 'snapshot',
         sessionId,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-thread-goal.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-thread-goal.ts
index 4af804263ae..1310663c998 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-thread-goal.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-thread-goal.ts
@@ -13,6 +13,7 @@ import type {
 } from '../../../shared/agent-session-wire'
 import type { MutationPlan } from './structured-agent-session-mutation-plans'
 import type { AgentSessionTurnContext, TurnOutcome } from './structured-agent-session-turns'
+import { contextStructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 
 function refused(
   reason: AgentSessionRefusalReason<'agent_session_operation_invalid'>,
@@ -70,7 +71,7 @@ export async function performThreadGoalChange(
         sentAs: 'goal'
       },
       // Accepting a goal is delivering it, so it joins whatever turn runs now.
-      { fence: ctx.fence, turnScope: ctx.journal.liveTurnScope() }
+      { fence: ctx.fence, turnScope: contextStructuredAgentSessionCurrentWork(ctx).turnScope() }
     )
   }
   const withdrawObjective = async (): Promise<void> => {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-turn-stop-notes.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-turn-stop-notes.ts
index 0f86c053ad6..4a954f7e8fa 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-turn-stop-notes.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-turn-stop-notes.ts
@@ -5,15 +5,16 @@
 import type { AgentJournalTurnScope } from '../../../shared/agent-session-journal-types'
 import { readAgentJournalTurn } from '../../../shared/agent-session-turn-record'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
+import type { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 
 export const STOP_NOTE_CANCELLATION_REQUESTED = 'Cancellation requested.'
 
-/** The turn a Stop is about: the one it named, else the one running when it is read. */
+/** The turn a Stop is about: the one it named, else the live generation's running turn. */
 export function structuredAgentSessionStoppedTurnId(
-  journal: Pick<AgentSessionJournal, 'activeTurnId'>,
+  work: Pick<StructuredAgentSessionCurrentWork, 'activeTurnId'>,
   namedTurnId: string | undefined
 ): string | null {
-  return namedTurnId ?? journal.activeTurnId()
+  return namedTurnId ?? work.activeTurnId()
 }
 
 /** A Stop names a turn the journal does not show running, as a phone does once that turn ended. */
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-turns-cancel.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-turns-cancel.ts
index a588fa7168a..ab65c4512cc 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-turns-cancel.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-turns-cancel.ts
@@ -25,7 +25,7 @@ import {
   structuredAgentSessionStopNamesTurnNotLive,
   structuredAgentSessionStoppedTurnId
 } from './structured-agent-session-turn-stop-notes'
-import { isStructuredAgentSessionMainAgentWorking } from '../../../shared/structured-agent-session-main-agent-working'
+import { contextStructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 import type { StructuredAgentSessionStopWindDown } from './structured-agent-session-stop-wind-down'
 import type { JournalStopFailedOn } from '../agent-session-journal/queued-message-pause'
 import { structuredAgentSessionFailedStopMark } from './structured-agent-session-stopping'
@@ -33,16 +33,12 @@ import { sendStopCanTakeBack } from './structured-agent-session-unopened-send-wi
 import { settleTakenStop } from './structured-agent-session-taken-stop-settle'
 import type { AgentSessionTurnContext, TurnOutcome } from './structured-agent-session-turns'
 
-/** Whether the fold reads working. Every write has landed by its call's return, so a Stop reads it
- *  without waiting on the write queue. */
+/** Whether the host's projection reads working (`structuredAgentSessionCurrentWork`). Every write
+ *  has landed by its call's return, so a Stop reads it without waiting on the write queue. */
 export function isMainAgentWorking(
-  ctx: Pick<AgentSessionTurnContext, 'journal' | 'fence'>
+  ctx: Pick<AgentSessionTurnContext, 'journal' | 'fence' | 'currentWork'>
 ): boolean {
-  return isStructuredAgentSessionMainAgentWorking(
-    ctx.journal.activeTurnId(),
-    ctx.journal.submissions(),
-    ctx.fence
-  )
+  return contextStructuredAgentSessionCurrentWork(ctx).working()
 }
 
 /**
@@ -51,14 +47,15 @@ export function isMainAgentWorking(
  * its exit ends its turn, and the host's own exit handling waits behind this step.
  */
 function stillRunsStoppedTurn(
-  ctx: Pick<AgentSessionTurnContext, 'journal' | 'fence'>,
+  ctx: Pick<AgentSessionTurnContext, 'journal' | 'fence' | 'currentWork'>,
   stoppedTurnId: string | null
 ): boolean {
-  if (!isMainAgentWorking(ctx)) {
+  const work = contextStructuredAgentSessionCurrentWork(ctx)
+  if (!work.working()) {
     return false
   }
   // Working with no turn open after the Stop's turn is a later send whose turn has not opened.
-  return stoppedTurnId === null || ctx.journal.activeTurnId() === stoppedTurnId
+  return stoppedTurnId === null || work.activeTurnId() === stoppedTurnId
 }
 
 /** Whether the Stop took back every send it found in flight, none of them having run
@@ -148,6 +145,8 @@ type PerformCancelInput = {
   childWork?: () => readonly AgentChildWorkView[] | undefined
   /** The latest Stop event is this press's own, or the in-force one it repeats: its settle binds. */
   opensSettle?: true
+  /** The fence the note is written at: a child end this Stop caused moved it past `ctx.fence`. */
+  noteFence?: () => number
 }
 
 async function cancelAndNote(
@@ -161,17 +160,20 @@ async function cancelAndNote(
     kind: 'status',
     text: STOP_NOTE_CANCELLATION_REQUESTED
   }
+  // Every read of what runs goes through the host's projection: an ended generation's turn is no
+  // Stop's target, whether or not its cleanup landed.
+  const work = () => contextStructuredAgentSessionCurrentWork(ctx)
   // The turn the Stop names, read before the cancel settles it: the note reports on that turn.
   const turnScope =
     (input.turnId !== undefined && !input.scope
       ? structuredAgentSessionNamedTurnScope(ctx.journal, input.turnId)
-      : null) ?? ctx.journal.liveTurnScope()
+      : null) ?? work().turnScope()
   // Only the provider's end or the child's ends a command. A command the provider has not opened a
   // turn for, would not interrupt, or was already asked to stop, ends with its child; that child's
   // dead-generation settlement writes the command's verdict.
-  const liveTurnId = ctx.journal.activeTurnId()
+  const liveTurnId = work().activeTurnId()
   // Read with the live turn, before the cancel settles it: the note is keyed by this turn.
-  const stoppedTurnId = structuredAgentSessionStoppedTurnId(ctx.journal, input.turnId)
+  const stoppedTurnId = structuredAgentSessionStoppedTurnId(work(), input.turnId)
   const namesTurnNotLive = structuredAgentSessionStopNamesTurnNotLive(input.turnId, liveTurnId)
   const runningCommand =
     input.stopChild !== undefined &&
@@ -223,7 +225,7 @@ async function cancelAndNote(
             ...(input.turnId !== undefined ? { turnId: input.turnId } : {}),
             fence: ctx.fence,
             // The journal is what the client read to name a turn, so it is what judges the request.
-            resolveLiveTurnId: () => ctx.journal.activeTurnId(),
+            resolveLiveTurnId: () => work().activeTurnId(),
             ...(dispatchStatus ? { dispatchStatus } : {}),
             ...(input.prompt ? { prompt: { itemId: input.prompt.itemId } } : {})
           })
@@ -330,7 +332,7 @@ async function cancelAndNote(
     binding.turnId = stoppedTurn ?? stoppedTurnId ?? undefined
   } else if (interruptFailed) {
     // A Stop that failed reads "Stopping…" through the turn it could not stop; its end stays its own.
-    binding.failedOn = structuredAgentSessionFailedStopMark(ctx.journal)
+    binding.failedOn = structuredAgentSessionFailedStopMark(work(), ctx.journal)
   }
   if (taken === true && stoppedTurn !== undefined && !binding.closedByWindDown && !input.scope) {
     const opened = await settleTakenStop(ctx, stoppedTurn)
@@ -349,6 +351,7 @@ async function cancelAndNote(
     (stoppedTurn !== undefined
       ? structuredAgentSessionNamedTurnScope(ctx.journal, stoppedTurn)
       : null) ?? turnScope
-  await ctx.journal.appendItem(noteIdentity, note, { fence: ctx.fence, turnScope: noteScope })
+  const fence = Math.max(ctx.fence, input.noteFence?.() ?? ctx.fence)
+  await ctx.journal.appendItem(noteIdentity, note, { fence, turnScope: noteScope })
   return { ok: true, value }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-turns-prompt.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-turns-prompt.ts
index a7bbf523c3c..b7b21c767d6 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-turns-prompt.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-turns-prompt.ts
@@ -26,6 +26,7 @@ import {
 import type { CommandReceiptResult } from '../agent-session-journal/command-receipt-schema'
 import type { JournalRow } from '../agent-session-journal/journal-row-schema'
 import { settledPrompt, validatePendingPrompt } from './structured-agent-session-prompt-state'
+import { contextStructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
 import type { AgentSessionTurnContext, TurnOutcome } from './structured-agent-session-turns'
 
 export type AgentSessionPromptRequest = {
@@ -134,7 +135,10 @@ export async function performPrompt(
           identity,
           { ...prompt, resolution },
           // A revision: the prompt keeps the turn it was raised in.
-          { fence: ctx.fence, turnScope: ctx.journal.liveTurnScope() },
+          {
+            fence: ctx.fence,
+            turnScope: contextStructuredAgentSessionCurrentWork(ctx).turnScope()
+          },
           // The answer's identity commits here, before the adapter tells the provider.
           ctx.operationReceipt
         )
@@ -159,7 +163,7 @@ export async function performPrompt(
           surface: 'row'
         })
       },
-      { fence: ctx.fence, turnScope: ctx.journal.liveTurnScope() }
+      { fence: ctx.fence, turnScope: contextStructuredAgentSessionCurrentWork(ctx).turnScope() }
     )
   }
   const appended = committed.item
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-turns.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-turns.ts
index cb3d87e72e9..b9c6b5e0bbc 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-turns.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-turns.ts
@@ -24,6 +24,10 @@ import {
 } from '../../../shared/agent-session-wire'
 import { isAgentSessionRefusalError } from '../../../shared/agent-session-wire-refusals'
 import { DISPATCH_DOUBT_PERSISTENCE_FAILED } from '../agent-session-journal/journal-dispatch-doubt-reasons'
+import {
+  contextStructuredAgentSessionCurrentWork,
+  type StructuredAgentSessionCurrentWork
+} from './structured-agent-session-current-work'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
 import type { JournalOperationReceipt } from '../agent-session-journal/journal-row-writer'
 import type {
@@ -53,6 +57,9 @@ export type AgentSessionTurnContext = {
   sessionId: string
   journal: AgentSessionJournal
   fence: number
+  /** The host's projection of what work is current (`structuredAgentSessionCurrentWork`), read
+   *  fresh per call: a child's end can move it mid-operation. */
+  currentWork?: () => StructuredAgentSessionCurrentWork | null
   adapter: StructuredAgentSessionAdapter
   /** What each agent declares; the session's own answer is `agents.capabilities(agent)`. */
   agents: StructuredAgentRegistry
@@ -219,12 +226,13 @@ export async function handOverSubmission(
     await handOverStructuredAgentSessionCommand(ctx, submission, body)
     return
   }
-  // The message joins the turn running at handover, a steer, or opens its own.
+  // The message joins the turn the child it goes to is running, a steer, or opens its own; never a
+  // turn an ended generation left.
   await ctx.journal.resolveDispatch({
     clientMessageId,
     state: 'pending',
     fence: ctx.fence,
-    turnScope: ctx.journal.liveTurnScope()
+    turnScope: contextStructuredAgentSessionCurrentWork(ctx).turnScope()
   })
   // The handover row's instant on the host clock; the turn this dispatch opens records it so the
   // live counter never re-anchors at turn-open.
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.test.ts
index b1fdcb5d860..1fb10c9d8f2 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.test.ts
@@ -115,7 +115,7 @@ describe('provider-exit settlement', () => {
           now = 60_000
           return { ok: false, error: new Error('sink unavailable') }
         },
-        publishFence: vi.fn(),
+        generationEnded: vi.fn(),
         serialize: async (_sessionId, task) => task(),
         now: () => now
       } as never,
@@ -191,11 +191,12 @@ describe('provider-exit settlement', () => {
     }
 
     await settleStructuredAgentSessionChildExit(
+      // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the exit settlement reads only these members of its context; the store double is partial.
       {
         store,
         sessions: new Map([[SESSION, session]]),
         flushLifecycle: async () => ({ ok: true }),
-        publishFence: vi.fn(),
+        generationEnded: vi.fn(),
         serialize: async (_sessionId, task) => task(),
         now: () => 1_234
       } as never,
@@ -308,7 +309,7 @@ describe('provider-exit settlement', () => {
           ]
           return { ok: true }
         },
-        publishFence: vi.fn(),
+        generationEnded: vi.fn(),
         serialize: async <T>(_sessionId: string, task: () => Promise<T>) => task(),
         now: () => 1_234
       }
@@ -357,7 +358,7 @@ describe('provider-exit settlement', () => {
       store,
       sessions: new Map([[SESSION, session]]),
       flushLifecycle: async () => ({ ok: true }),
-      publishFence: vi.fn(),
+      generationEnded: vi.fn(),
       serialize: async <T>(_sessionId: string, task: () => Promise<T>) => task(),
       now: () => 1
     }
@@ -411,7 +412,7 @@ describe('provider-exit settlement', () => {
       }
     }
     const log = recordingStructuredAgentSessionLogger()
-    const publishFence = vi.fn()
+    const generationEnded = vi.fn()
     const event = {
       type: 'ended' as const,
       sessionId: SESSION,
@@ -425,7 +426,7 @@ describe('provider-exit settlement', () => {
       store,
       sessions: new Map([[SESSION, session]]),
       flushLifecycle: async () => ({ ok: false, error: new Error('sink failed') }),
-      publishFence,
+      generationEnded,
       serialize: async (_sessionId, task) => task(),
       now: () => 1,
       logger: log.logger
@@ -433,7 +434,9 @@ describe('provider-exit settlement', () => {
     await settleStructuredAgentSessionChildExit(context, event)
 
     expect(session.child).toBeNull()
-    expect(publishFence).toHaveBeenCalledTimes(1)
+    expect(generationEnded).toHaveBeenCalledTimes(2)
+    expect(generationEnded).toHaveBeenNthCalledWith(1, SESSION)
+    expect(generationEnded).toHaveBeenLastCalledWith(SESSION, { restate: true })
     expect(log.scopes()).toEqual(['exit-lifecycle-barrier', 'exit-settlement'])
   })
 })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-working-at-teardown.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-working-at-teardown.ts
index aae177bbd65..329f4405597 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-working-at-teardown.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-working-at-teardown.ts
@@ -52,6 +52,8 @@ import {
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
 import { isUnansweredHandedOverSubmission } from '../agent-session-journal/journal-unsent-send-hold'
 import { structuredAgentSessionShownStatus } from './structured-agent-session-shown-work'
+import { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work'
+import type { StructuredAgentSessionWorkScope } from '../../../shared/structured-agent-session-main-agent-working'
 
 /** A send Orca journaled that the provider has neither opened a turn for nor refused. Mirrors the
  *  projection's own unanswered-dispatch rule, which is what makes that window read as `working`. */
@@ -71,13 +73,18 @@ function pendingSubmissionInFlight(
   return null
 }
 
-/** The work identity to record: a running turn if one exists, else the send still awaiting one. */
+/** The work identity to record: a running turn if one exists, else the send still awaiting one.
+ *  `scope`: the host's (`structuredAgentSessionCurrentWork`), so an ended generation's turn is none. */
 export function structuredAgentSessionWorkInFlight(
   items: readonly AgentJournalRenderItem[],
-  submissions: readonly AgentJournalSubmission[]
+  submissions: readonly AgentJournalSubmission[],
+  scope?: StructuredAgentSessionWorkScope
 ): AgentSessionResumeWork | null {
   const current = agentSessionCurrentContextRows(items, submissions)
-  const turnId = activeStructuredAgentSessionTurnId(current.items)
+  const turnId = activeStructuredAgentSessionTurnId(
+    current.items,
+    scope && ((item) => scope.isCurrentItem(item.itemId))
+  )
   if (turnId) {
     return { kind: 'turn', id: turnId }
   }
@@ -91,7 +98,8 @@ export function structuredAgentSessionWorkInFlight(
  */
 function structuredAgentSessionResumeWork(
   items: readonly AgentJournalRenderItem[],
-  submissions: readonly AgentJournalSubmission[]
+  submissions: readonly AgentJournalSubmission[],
+  scope: StructuredAgentSessionWorkScope
 ): AgentSessionResumeWork | null {
   const bodies = new Map(items.map((item) => [item.itemId, item.body]))
   const bodyOf = (itemId: string) => bodies.get(itemId)
@@ -107,7 +115,7 @@ function structuredAgentSessionResumeWork(
   ) {
     return null
   }
-  const inFlight = structuredAgentSessionWorkInFlight(items, submissions)
+  const inFlight = structuredAgentSessionWorkInFlight(items, submissions, scope)
   if (inFlight) {
     return inFlight
   }
@@ -129,13 +137,17 @@ function boundedLabel(text: string | undefined): string {
 
 /** The prompts the session is blocked on, from the same items the projection called `attention`
  *  over — one read, so the recorded state and the prompts it stands for cannot disagree. */
-function pendingPrompts(items: readonly AgentJournalRenderItem[]): AgentSessionRestartPrompt[] {
+function pendingPrompts(
+  items: readonly AgentJournalRenderItem[],
+  scope: StructuredAgentSessionWorkScope
+): AgentSessionRestartPrompt[] {
   const prompts: AgentSessionRestartPrompt[] = []
   for (const item of items) {
     const body = item.body
     if (
       (body.kind !== 'approval' && body.kind !== 'question') ||
-      body.resolution.state !== 'pending'
+      body.resolution.state !== 'pending' ||
+      !scope.isCurrentItem(item.itemId)
     ) {
       continue
     }
@@ -197,16 +209,19 @@ export function structuredAgentSessionWorkingAtStop(input: {
       !(unanswered && isUnansweredHandedOverSubmission(submission))
   )
   const childWork = input.childWork(sessionId)
+  const record = input.getRecord(sessionId)
+  // The live generation is this host's own child, read first-hand like the rest, never the lease.
+  const { scope } = new StructuredAgentSessionCurrentWork(session.journal, session.child.fence)
   const status = structuredAgentSessionShownStatus(
     { items: current.items, submissions: handedOver },
     childWork,
-    session.child.fence
+    session.child.fence,
+    scope
   )
   if (status.state === 'done') {
     return null
   }
-  const work = structuredAgentSessionResumeWork(current.items, handedOver)
-  const record = input.getRecord(sessionId)
+  const work = structuredAgentSessionResumeWork(current.items, handedOver, scope)
   const head = record ? agentSessionProviderHandleChainHead(record.providerHandleChain) : null
   if (!work || !head) {
     return null
@@ -215,7 +230,7 @@ export function structuredAgentSessionWorkingAtStop(input: {
     // The lead's OWN state, not the fold: a settled lead with running children reads `done` here
     // and carries them in `tasks`, which is how the dialog tells the two apart.
     state: status.mainAgent.state,
-    prompts: pendingPrompts(current.items),
+    prompts: pendingPrompts(current.items, scope),
     tasks: liveTasks(childWork)
   }
   return {
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command-admission.test.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command-admission.test.ts
index 50ddcbc08e9..9a0d655c771 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command-admission.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command-admission.test.ts
@@ -27,7 +27,14 @@ function contextWith(
   return {
     sessionId: 'session-1',
     fence: 1,
-    journal: { snapshot: () => ({ items: [] }), submissions: () => [] },
+    journal: {
+      snapshot: () => ({ items: [] }),
+      submissions: () => [],
+      runningTurn: () => null,
+      itemFence: () => undefined,
+      visitItems: () => undefined,
+      wroteBeforeOpen: () => false
+    },
     adapter
   }
 }
@@ -59,6 +66,8 @@ const SETTLED = child({
   settledAt: 300
 })
 const RECORD = { lease: {} } as unknown as AgentSessionRecord
+// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: admission reads only the running turn's id and item id.
+const RUNNING_TURN = { turnId: 'turn-1', item: { itemId: 'turn-1' } } as never
 const STOP = 'Stop background tasks before using this command.'
 const WAIT = 'Wait for background tasks to finish before using this command.'
 
@@ -120,6 +129,7 @@ describe('conversationCommandBlocked background work', () => {
           }
         ]
       }) as unknown as ReturnType<typeof ctx.journal.snapshot>
+    ctx.journal.runningTurn = () => RUNNING_TURN
     expect(conversationCommandBlocked(ctx, RECORD, [child()])?.message).toBe(
       'Wait for the current turn to finish before using this command.'
     )
@@ -135,6 +145,7 @@ describe('conversationCommandBlocked for a command sent at rest (C6, B3)', () =>
     const ctx = contextWith(undefined)
     // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the admission reads only each item's body.
     ctx.journal.snapshot = () => staleTurn as never
+    ctx.journal.runningTurn = () => RUNNING_TURN
     expect(conversationCommandBlocked(ctx, RECORD, [], 'at-rest')).toBeNull()
     expect(conversationCommandBlocked(ctx, RECORD, [])).toMatchObject({
       details: { reason: 'turnActive' },
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command-admission.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command-admission.ts
index 7d81e4a7718..b40265c16b4 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command-admission.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command-admission.ts
@@ -6,10 +6,13 @@ import type { AgentSessionRecord } from '../../../shared/agent-session-record'
 import { isQueuedAgentJournalSubmission } from '../../../shared/agent-session-queued-submission'
 import { agentChildWorkLiveness } from '../../../shared/agent-status-child-work-liveness'
 import type { AgentChildWorkView } from '../../../shared/agent-status-child-work-view'
-import { activeStructuredAgentSessionTurnId } from '../../../shared/structured-agent-session-projection'
 import { agentSessionCurrentContextRows } from '../../../shared/agent-session-context-clear'
-import { isUnansweredStructuredAgentSessionDispatch } from '../../../shared/structured-agent-session-unanswered-dispatch'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
+import {
+  contextStructuredAgentSessionCurrentWork,
+  type StructuredAgentSessionCurrentWork,
+  type StructuredAgentSessionCurrentWorkJournal
+} from './structured-agent-session-current-work'
 import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
 import {
   refuse,
@@ -21,10 +24,11 @@ import {
 export type ConversationCommandAdmissionContext = {
   sessionId: string
   fence: number
-  journal: {
+  journal: StructuredAgentSessionCurrentWorkJournal & {
     snapshot(): Pick<ReturnType<AgentSessionJournal['snapshot']>, 'items'>
-    submissions: AgentSessionJournal['submissions']
   }
+  /** The host's projection of current work; without one, the generation at `fence` is live. */
+  currentWork?: () => StructuredAgentSessionCurrentWork | null
   adapter: Pick<StructuredAgentSessionAdapter, 'backgroundTaskStops'>
 }
 
@@ -64,14 +68,18 @@ export function conversationCommandBlocked(
   if (record.lease.handoffStage || record.lease.handoffOperationId) {
     return blocked('handoffInFlight', 'Wait for the session handoff to finish.')
   }
-  if (admission !== 'at-rest' && activeStructuredAgentSessionTurnId(items)) {
+  // What is current is the host projection's to say: an ended generation's turn, prompt or send
+  // refuses nothing.
+  const work = contextStructuredAgentSessionCurrentWork(ctx)
+  if (admission !== 'at-rest' && work.activeTurnId()) {
     return blocked('turnActive', 'Wait for the current turn to finish before using this command.')
   }
   if (
     items.some(
       (item) =>
         (item.body.kind === 'approval' || item.body.kind === 'question') &&
-        item.body.resolution.state === 'pending'
+        item.body.resolution.state === 'pending' &&
+        work.isCurrentItem(item.itemId)
     )
   ) {
     return blocked(
@@ -80,7 +88,9 @@ export function conversationCommandBlocked(
     )
   }
   // The same liveness fold the strip's monitoring indicator reads: settled rows block nothing.
-  if (agentChildWorkLiveness(childWork) !== null) {
+  // Child records are the live generation's: its adapter ends them on every close, so with no
+  // generation live, any still running are an ended one's leftovers and hold nothing.
+  if (work.liveFence !== null && agentChildWorkLiveness(childWork) !== null) {
     return blocked(
       'backgroundTasksRunning',
       stripOffersStop(childWork ?? [], ctx.adapter.backgroundTaskStops?.(ctx.sessionId))
@@ -93,8 +103,7 @@ export function conversationCommandBlocked(
   if (
     submissions.some(
       (entry) =>
-        !(admission === 'handover' && isQueuedAgentJournalSubmission(entry)) &&
-        isUnansweredStructuredAgentSessionDispatch(entry, ctx.fence)
+        !(admission === 'handover' && isQueuedAgentJournalSubmission(entry)) && work.owesSend(entry)
     )
   ) {
     return blocked(
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
index ab6df634d13..606d2093c93 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
@@ -11,6 +11,7 @@ import { agentSessionOperationKey } from '../../../shared/agent-session-operatio
 import type { StructuredAgentSessionMutationContext } from './structured-agent-session-host-mutations'
 import { sendPreparation } from './structured-agent-session-send-preparation'
 import type { StructuredAgentSessionCaller } from './structured-agent-session-host-types'
+import { hostStructuredAgentSessionCurrentWork } from './structured-agent-session-host-current-work'
 import { conversationCommandBlocked } from './structured-conversation-command-admission'
 import type { AgentSessionFailureFact } from '../../../shared/agent-session-failure'
 import {
@@ -69,6 +70,8 @@ export function runStructuredConversationCommand(
       // Starts the agent only to settle a rewind in doubt, as a send does; a /clear itself starts nothing.
       prepareSession: sendPreparation(context, envelope, { refusesInRun: true }),
       journal: () => context.sessions.get(sessionId)?.journal,
+      currentWork: () =>
+        hostStructuredAgentSessionCurrentWork({ store, sessions: context.sessions }, sessionId),
       publish: (journal) => context.publish(sessionId, journal),
       now: context.now,
       plan: {
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-compaction.test.ts b/src/main/native-chat/agent-session-wire/structured-conversation-compaction.test.ts
index 35e5b4fda21..cbd1197d511 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-compaction.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-compaction.test.ts
@@ -248,15 +248,16 @@ it('hands over a message held behind the command when the command ends just as t
   await state.host.conversationCommand(CALLER, compactParams())
   await vi.waitFor(() => expect(compact).toHaveBeenCalledOnce(), { interval: 1 })
   const { journal: live } = state.host['sessions'].get(SESSION)!
-  const activeTurnId = live.activeTurnId
+  const runningTurn = live.runningTurn
   let ended = false
-  vi.spyOn(live, 'activeTurnId').mockImplementation(() => {
-    const read = activeTurnId()
+  // The loop reads the command through the host's current-work projection, which asks this.
+  vi.spyOn(live, 'runningTurn').mockImplementation(() => {
+    const read = runningTurn()
     // The provider's end lands the moment the loop's own step reads the command as running and
     // stops; no other reader's view of it matters here.
     if (
       !ended &&
-      read?.startsWith('compact:') &&
+      read?.turnId.startsWith('compact:') &&
       /at (?:StructuredAgentSessionDeliveryLoop\.)?prepare \(.*structured-agent-session-delivery-loop/.test(
         new Error('who reads').stack ?? ''
       )
diff --git a/src/main/runtime/orchestration/structured-mailbox-pointer-host.test.ts b/src/main/runtime/orchestration/structured-mailbox-pointer-host.test.ts
index d3bf795a19c..05683fcc505 100644
--- a/src/main/runtime/orchestration/structured-mailbox-pointer-host.test.ts
+++ b/src/main/runtime/orchestration/structured-mailbox-pointer-host.test.ts
@@ -73,7 +73,10 @@ describe('structured mailbox pointer host', () => {
     // far from the tail, so any page-sized read reports a busy worker as idle — and `@idle` then
     // wakes it mid-turn.
     const items = [runningTurn(), ...transcript(500)]
-    hostRef.current = { journalSnapshot: () => ({ items, submissions: [] }) }
+    hostRef.current = {
+      journalSnapshot: () => ({ items, submissions: [] }),
+      currentWork: () => null
+    }
     expect(await readStructuredSessionGateFacts('s1')).toEqual({
       turnRunning: true,
       awaitingHuman: false
diff --git a/src/main/runtime/orchestration/structured-mailbox-pointer-host.ts b/src/main/runtime/orchestration/structured-mailbox-pointer-host.ts
index e51734b5b85..92b1e059482 100644
--- a/src/main/runtime/orchestration/structured-mailbox-pointer-host.ts
+++ b/src/main/runtime/orchestration/structured-mailbox-pointer-host.ts
@@ -47,7 +47,12 @@ export async function readStructuredSessionGateFacts(
   sessionId: string
 ): Promise<StructuredSessionGateFacts | null> {
   const snapshot = await readSessionJournal(sessionId)
-  return snapshot ? structuredSessionGateFacts(snapshot.items) : null
+  if (!snapshot) {
+    return null
+  }
+  // The host's projection of current work: an agent that ended is idle, whatever its rows say.
+  const work = getStructuredAgentSessionHost()?.currentWork(sessionId)
+  return structuredSessionGateFacts(snapshot.items, work?.scope)
 }
 
 /** What each recorded send settled as. */
diff --git a/src/main/runtime/orchestration/structured-session-pointer-delivery.ts b/src/main/runtime/orchestration/structured-session-pointer-delivery.ts
index fc7758e07a1..8a99deb3995 100644
--- a/src/main/runtime/orchestration/structured-session-pointer-delivery.ts
+++ b/src/main/runtime/orchestration/structured-session-pointer-delivery.ts
@@ -8,6 +8,7 @@
  */
 
 import type { AgentJournalRenderItem } from '../../../shared/agent-session-journal-types'
+import type { StructuredAgentSessionWorkScope } from '../../../shared/structured-agent-session-main-agent-working'
 import {
   activeStructuredAgentSessionTurnId,
   projectStructuredAgentSessionStatus
@@ -46,11 +47,17 @@ export type StructuredSessionGateFacts = {
  * and idle-with-history is the normal steady state of a working agent.
  */
 export function structuredSessionGateFacts(
-  items: readonly AgentJournalRenderItem[]
+  items: readonly AgentJournalRenderItem[],
+  /** The host's projection of current work (`structuredAgentSessionCurrentWork`). */
+  scope?: StructuredAgentSessionWorkScope
 ): StructuredSessionGateFacts {
   return {
-    turnRunning: activeStructuredAgentSessionTurnId(items) !== null,
-    awaitingHuman: projectStructuredAgentSessionStatus(items) === 'attention'
+    turnRunning:
+      activeStructuredAgentSessionTurnId(
+        items,
+        scope && ((item) => scope.isCurrentItem(item.itemId))
+      ) !== null,
+    awaitingHuman: projectStructuredAgentSessionStatus(items, [], undefined, scope) === 'attention'
   }
 }
 
diff --git a/src/main/runtime/orchestration/structured-worker-group-addressing.test.ts b/src/main/runtime/orchestration/structured-worker-group-addressing.test.ts
index e255f5eefc8..dd1a7ec78dc 100644
--- a/src/main/runtime/orchestration/structured-worker-group-addressing.test.ts
+++ b/src/main/runtime/orchestration/structured-worker-group-addressing.test.ts
@@ -83,7 +83,8 @@ function installHost(options: {
       present: true,
       sessionIds: options.tabListed ? [SESSION_ID] : []
     }),
-    journalSnapshot: async () => ({ items: options.items ?? [idleTurn()] })
+    journalSnapshot: async () => ({ items: options.items ?? [idleTurn()] }),
+    currentWork: () => null
   }
 }
 
diff --git a/src/main/runtime/rpc/methods/structured-agent-session-rpc.test-fixture.ts b/src/main/runtime/rpc/methods/structured-agent-session-rpc.test-fixture.ts
index dfda59b17b3..ce9b35c8f3c 100644
--- a/src/main/runtime/rpc/methods/structured-agent-session-rpc.test-fixture.ts
+++ b/src/main/runtime/rpc/methods/structured-agent-session-rpc.test-fixture.ts
@@ -101,12 +101,14 @@ function statusFeed(): StructuredAgentSessionStatusFeed {
       [
         STATUS_SESSION,
         {
-          // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the status feed reads only cursor(), lastActivityAt(), stopMarks and snapshot() of a journal.
+          // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the status feed reads only cursor(), lastActivityAt(), stopMarks, snapshot(), itemFence() and runningTurn() of a journal with no sends.
           journal: {
             cursor: () => ({ epoch: 'epoch-status', sequence: 2 }),
             lastActivityAt: () => 2,
             stopMarks: { latest: () => null, revision: () => 0 },
-            snapshot: () => ({ items: STATUS_ITEMS, submissions: [] })
+            snapshot: () => ({ items: STATUS_ITEMS, submissions: [] }),
+            itemFence: () => undefined,
+            runningTurn: () => null
           } as unknown as AgentSessionJournal,
           params: {
             location: {
@@ -143,11 +145,7 @@ export function hostStub(): StructuredAgentSessionHost {
           items: [],
           removedItemIds: [],
           submissions: [],
-          window: {
-            oldest: null,
-            newest: null,
-            nextCursor: { epoch: 'epoch-a', sequence: 0 }
-          },
+          window: { oldest: null, newest: null, nextCursor: { epoch: 'epoch-a', sequence: 0 } },
           liveCursor: { epoch: 'epoch-a', sequence: 0 },
           hasOlder: false,
           hasNewer: false
diff --git a/src/main/runtime/structured-worker-cleared-session.test.ts b/src/main/runtime/structured-worker-cleared-session.test.ts
index c4d07df01fb..037ec7beb14 100644
--- a/src/main/runtime/structured-worker-cleared-session.test.ts
+++ b/src/main/runtime/structured-worker-cleared-session.test.ts
@@ -207,6 +207,8 @@ function installHost(): void {
       open.add(id)
       return { items: [message(`${id}-1`, 'idle')], submissions: [] }
     },
+    // No projection held: the gate reads the timeline as it stands.
+    currentWork: () => null,
     setSessionTabVisibility: async (id: string, visible: boolean) => {
       if (id === failHideOf) {
         throw new Error('the durable tab index is wedged')
diff --git a/src/shared/agent-session-wire.ts b/src/shared/agent-session-wire.ts
index b8ff6a14055..a9030334385 100644
--- a/src/shared/agent-session-wire.ts
+++ b/src/shared/agent-session-wire.ts
@@ -148,6 +148,16 @@ export type AgentSessionHistoryPage = {
   subagentRoster?: AgentSessionSubagentRosterEntry[]
   /** As of the page's read; a client applies it only from a page that replaces its state. */
   latestTurn?: AgentSessionLatestTurn | null
+  /** Rides with `latestTurn`: the approvals and questions still waiting on the person that the
+   *  agent running now raised, over the whole journal. One an agent that has ended raised is not
+   *  listed, since nothing can take its answer. Absent from an older host, whose clients read every
+   *  pending prompt they hold as waiting. */
+  actionablePromptIds?: string[]
+  /** Rides with `latestTurn`: whether the agent running now is working, by the host's projection of
+   *  current work — its running turn, or a send it owes, eligible or handed over and unanswered.
+   *  What an agent that has ended left counts for nothing. Absent from an older host, whose
+   *  clients derive it from the rows they hold. */
+  working?: boolean
 }
 
 export type AgentSessionHistoryResult =
@@ -207,6 +217,10 @@ export type AgentSessionSubscribeEvent =
       /** Rides every batch that carries rows, removals or submissions, so absent there means an
        *  older host; absent on one that carries none, which changes no turn. */
       latestTurn?: AgentSessionLatestTurn | null
+      /** Rides with `latestTurn` (`AgentSessionHistoryPage.actionablePromptIds`). */
+      actionablePromptIds?: string[]
+      /** Rides with `latestTurn` (`AgentSessionHistoryPage.working`). */
+      working?: boolean
     } & AgentSessionFrameFields)
   | ({
       type: 'reset'
@@ -459,9 +473,7 @@ export type AgentSessionSlashCommand = {
 /** The provider's own command surface, read per session. Additive read-only
  *  surface: a host that predates it answers `method_not_found`, and the client
  *  keeps rendering its curated catalog. */
-export type AgentSessionCommandsResult = {
-  commands?: AgentSessionSlashCommand[]
-}
+export type AgentSessionCommandsResult = { commands?: AgentSessionSlashCommand[] }
 
 /** Longest objective a client may send; matches the provider's own limit. */
 export const AGENT_SESSION_THREAD_GOAL_OBJECTIVE_MAX_LENGTH = 4000
@@ -473,9 +485,7 @@ export type AgentSessionThreadGoalChange =
   | { kind: 'status'; status: 'active' | 'paused' }
   | { kind: 'clear' }
 
-export type AgentSessionThreadGoalResult = {
-  change: AgentSessionThreadGoalChange['kind']
-}
+export type AgentSessionThreadGoalResult = { change: AgentSessionThreadGoalChange['kind'] }
 
 /** Provider-reported choices and effective next-turn values. Additive read-only
  *  surface so older hosts can reject it without changing structured v1 writes. */
diff --git a/src/shared/structured-agent-session-live-turn.ts b/src/shared/structured-agent-session-live-turn.ts
index a716b8f4a13..94d3ac92173 100644
--- a/src/shared/structured-agent-session-live-turn.ts
+++ b/src/shared/structured-agent-session-live-turn.ts
@@ -35,16 +35,20 @@ import {
   type StructuredAgentSessionToolAction
 } from './structured-agent-session-tool-call-block'
 
+/** `current`: a host's answer to whether the running turn's item is current work
+ *  (`StructuredAgentSessionWorkScope`); one an ended generation opened is none. */
 export function activeStructuredAgentSessionTurnId(
-  items: readonly AgentJournalRenderItem[]
+  items: readonly AgentJournalRenderItem[],
+  current?: (item: AgentJournalRenderItem) => boolean
 ): string | null {
   for (let index = items.length - 1; index >= 0; index -= 1) {
-    if (isAgentSessionContextClear(items[index]?.body)) {
+    const item = items[index]
+    if (isAgentSessionContextClear(item?.body)) {
       return null
     }
-    const turn = readAgentJournalTurn(items[index]?.body)
+    const turn = readAgentJournalTurn(item?.body)
     if (turn) {
-      return turn.state === 'running' ? turn.turnId : null
+      return turn.state === 'running' && (!current || (item && current(item))) ? turn.turnId : null
     }
   }
   return null
@@ -81,6 +85,14 @@ export function newestStructuredAgentSessionTurnBySequence(
 export function liveStructuredAgentSessionTurnScope(
   items: Iterable<AgentJournalRenderItem>
 ): AgentJournalTurnScope {
+  const running = runningStructuredAgentSessionTurnItemBySequence(items)
+  return running ? { kind: 'turn', turnItemId: running.item.itemId } : AGENT_JOURNAL_THREAD_SCOPE
+}
+
+/** The newest turn record's item when that turn is running, by sequence. */
+export function runningStructuredAgentSessionTurnItemBySequence(
+  items: Iterable<AgentJournalRenderItem>
+): { item: AgentJournalRenderItem; turnId: string } | null {
   let newest: AgentJournalRenderItem | null = null
   for (const item of items) {
     if (
@@ -90,17 +102,8 @@ export function liveStructuredAgentSessionTurnScope(
       newest = item
     }
   }
-  return newest && readAgentJournalTurn(newest.body)?.state === 'running'
-    ? { kind: 'turn', turnItemId: newest.itemId }
-    : AGENT_JOURNAL_THREAD_SCOPE
-}
-
-/** Whether that newest turn is still running, which is all most callers want. */
-export function activeStructuredAgentSessionTurnIdBySequence(
-  items: Iterable<AgentJournalRenderItem>
-): string | null {
-  const newest = newestStructuredAgentSessionTurnBySequence(items)
-  return newest?.state === 'running' ? newest.turnId : null
+  const turn = newest ? readAgentJournalTurn(newest.body) : null
+  return newest && turn?.state === 'running' ? { item: newest, turnId: turn.turnId } : null
 }
 
 /** The newest turn record whatever state it ended in, STATE INCLUDED. Restart resume compares both
diff --git a/src/shared/structured-agent-session-main-agent-working.ts b/src/shared/structured-agent-session-main-agent-working.ts
index 05e3b775aaa..ea8af777128 100644
--- a/src/shared/structured-agent-session-main-agent-working.ts
+++ b/src/shared/structured-agent-session-main-agent-working.ts
@@ -1,14 +1,30 @@
 import type { AgentJournalSubmission } from './agent-session-journal-types'
 import { hasUnansweredStructuredAgentSessionDispatch } from './structured-agent-session-unanswered-dispatch'
 
+/** The host's answer to which work is current, built only by its operational projection
+ *  (`structuredAgentSessionCurrentWork`). A client has none, so every running turn, pending prompt
+ *  and unanswered send it holds reads as current, as it always has. */
+export type StructuredAgentSessionWorkScope = {
+  /** Whether the live generation's execution produced this item. */
+  isCurrentItem: (itemId: string) => boolean
+  /** Whether this send is still owed: handed to the live generation and unanswered, or accepted by
+   *  this host and not yet handed over. */
+  owesSend: (submission: AgentJournalSubmission) => boolean
+}
+
 /** Whether the session's own agent is working: a running turn, or a send it has not answered.
- *  The one rule behind every session list's Working and the chat's own Stop. */
+ *  The one rule behind every session list's Working and the chat's own Stop. A host passes the turn
+ *  its projection scoped, and that projection's `scope`. */
 export function isStructuredAgentSessionMainAgentWorking(
   activeTurnId: string | null,
   submissions: readonly AgentJournalSubmission[],
-  currentFence?: number | null
+  currentFence?: number | null,
+  scope?: StructuredAgentSessionWorkScope
 ): boolean {
   return (
-    activeTurnId !== null || hasUnansweredStructuredAgentSessionDispatch(submissions, currentFence)
+    activeTurnId !== null ||
+    (scope
+      ? submissions.some(scope.owesSend)
+      : hasUnansweredStructuredAgentSessionDispatch(submissions, currentFence))
   )
 }
diff --git a/src/shared/structured-agent-session-owed-work.ts b/src/shared/structured-agent-session-owed-work.ts
index fe7c9695ae7..259bbfe6877 100644
--- a/src/shared/structured-agent-session-owed-work.ts
+++ b/src/shared/structured-agent-session-owed-work.ts
@@ -1,6 +1,9 @@
 import type { AgentJournalRenderItem, AgentJournalSubmission } from './agent-session-journal-types'
 import { activeStructuredAgentSessionTurnId } from './structured-agent-session-live-turn'
-import { isStructuredAgentSessionMainAgentWorking } from './structured-agent-session-main-agent-working'
+import {
+  isStructuredAgentSessionMainAgentWorking,
+  type StructuredAgentSessionWorkScope
+} from './structured-agent-session-main-agent-working'
 import { agentSessionCurrentContextRows } from './agent-session-context-clear'
 
 /** A running turn or an unanswered send: what a `working` status means, and what an `attention`
@@ -8,12 +11,17 @@ import { agentSessionCurrentContextRows } from './agent-session-context-clear'
 export function owesStructuredAgentSessionWork(
   items: readonly AgentJournalRenderItem[],
   submissions: readonly AgentJournalSubmission[],
-  currentFence?: number | null
+  currentFence?: number | null,
+  scope?: StructuredAgentSessionWorkScope
 ): boolean {
   const current = agentSessionCurrentContextRows(items, submissions)
   return isStructuredAgentSessionMainAgentWorking(
-    activeStructuredAgentSessionTurnId(current.items),
+    activeStructuredAgentSessionTurnId(
+      current.items,
+      scope && ((item) => scope.isCurrentItem(item.itemId))
+    ),
     current.submissions,
-    currentFence
+    currentFence,
+    scope
   )
 }
diff --git a/src/shared/structured-agent-session-projection.ts b/src/shared/structured-agent-session-projection.ts
index 610b08e9167..6b66904c275 100644
--- a/src/shared/structured-agent-session-projection.ts
+++ b/src/shared/structured-agent-session-projection.ts
@@ -39,6 +39,7 @@ import { sha256 } from './sha256'
 import { readAgentMessageSource } from './agent-session-message-source'
 import { structuredAgentSessionStatusStartedAt } from './structured-agent-session-status-started-at'
 import { owesStructuredAgentSessionWork } from './structured-agent-session-owed-work'
+import type { StructuredAgentSessionWorkScope } from './structured-agent-session-main-agent-working'
 import { agentSessionCurrentContextRows } from './agent-session-context-clear'
 
 // Re-exported so the live-turn readers' and the unanswered-send rule's existing consumers keep one
@@ -214,23 +215,32 @@ export function structuredAgentSessionTabId(sessionId: string): string {
   return `structured-agent-session-${sessionId}`
 }
 
-function isPendingStructuredAgentSessionPrompt(item: AgentJournalRenderItem): boolean {
-  return (
+/** A prompt waiting on the user, unless the host's scope says an ended generation raised it:
+ *  nothing can take its answer. */
+function pendingStructuredAgentSessionPrompt(
+  scope?: StructuredAgentSessionWorkScope
+): (item: AgentJournalRenderItem) => boolean {
+  return (item) =>
     (item.body.kind === 'approval' || item.body.kind === 'question') &&
-    item.body.resolution.state === 'pending'
-  )
+    item.body.resolution.state === 'pending' &&
+    (!scope || scope.isCurrentItem(item.itemId))
 }
 
+/** `scope`: a host's (`StructuredAgentSessionWorkScope`), so work an ended generation left neither
+ *  holds nor reads as Working. */
 export function projectStructuredAgentSessionStatus(
   items: readonly AgentJournalRenderItem[],
   submissions: readonly AgentJournalSubmission[] = [],
-  currentFence?: number | null
+  currentFence?: number | null,
+  scope?: StructuredAgentSessionWorkScope
 ): StructuredAgentSessionProjectedStatus {
   ;({ items, submissions } = agentSessionCurrentContextRows(items, submissions))
-  if (items.some(isPendingStructuredAgentSessionPrompt)) {
+  if (items.some(pendingStructuredAgentSessionPrompt(scope))) {
     return 'attention'
   }
-  return owesStructuredAgentSessionWork(items, submissions, currentFence) ? 'working' : 'idle'
+  return owesStructuredAgentSessionWork(items, submissions, currentFence, scope)
+    ? 'working'
+    : 'idle'
 }
 
 /** The activity fields a sidebar row shows beside the prompt, named as the agent-status
@@ -269,7 +279,8 @@ export function projectStructuredAgentSessionStatusSummary(
 export function projectStructuredAgentSessionStatusState(
   items: readonly AgentJournalRenderItem[],
   submissions: readonly AgentJournalSubmission[] = [],
-  currentFence?: number | null
+  currentFence?: number | null,
+  scope?: StructuredAgentSessionWorkScope
 ): {
   summary: StructuredAgentSessionStatusProjection
   latestRequest: StructuredAgentSessionLatestRequest | null
@@ -288,7 +299,7 @@ export function projectStructuredAgentSessionStatusState(
     }
   }
   ;({ items, submissions } = agentSessionCurrentContextRows(items, submissions))
-  const status = projectStructuredAgentSessionStatus(items, submissions, currentFence)
+  const status = projectStructuredAgentSessionStatus(items, submissions, currentFence, scope)
   const statusToolCall = status === 'working' ? statusStructuredAgentSessionToolCall(items) : null
   const toolName = statusToolCall
     ? normalizeOptionalField(statusToolCall.name, AGENT_STATUS_TOOL_NAME_MAX_LENGTH)
@@ -318,10 +329,11 @@ export function projectStructuredAgentSessionStatusState(
   )
   return {
     latestRequest,
-    owesWork: status !== 'idle' && owesStructuredAgentSessionWork(items, submissions, currentFence),
+    owesWork:
+      status !== 'idle' && owesStructuredAgentSessionWork(items, submissions, currentFence, scope),
     pendingPromptIds:
       status === 'attention'
-        ? items.filter(isPendingStructuredAgentSessionPrompt).map((item) => item.itemId)
+        ? items.filter(pendingStructuredAgentSessionPrompt(scope)).map((item) => item.itemId)
         : [],
     summary: {
       status,