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,