feat(native-chat): the chat strip and the sidebar read the host's child records

docs/reference/agent-status-store.md

@@ -94,16 +94,16 @@ The structured feed keeps its job of projecting a session's journal into a
 summary and streaming it to subscribers. On every publish it additionally
 ingests the summary into the hook server as a status row:
 
-| Row field                                           | From                                                                                                                                                                          |
-| --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `paneKey`                                           | `structuredAgentSessionPaneKey(tabId, sessionId)`, the key the renderer already uses; its leaf is UUID-shaped so pane-key validation accepts it                               |
-| `tabId`                                             | `structuredAgentSessionTabId(sessionId)`                                                                                                                                      |
-| `worktreeId`                                        | `summary.workspaceId` (a folder workspace id is a valid value)                                                                                                                |
-| `state`                                             | `structuredAgentSessionAgentStatus(summary).state`: the lead's own status folded with its live `backgroundTasks`, so a settled lead whose subagent still runs reads `working` |
-| `workingMode`                                       | `'monitoring'` from the same fold when watch loops are the only live child work; omitted otherwise, which clears it on the row                                                |
-| `mainAgent`                                         | the main agent's own state before the fold, its last-turn verdict (`summary.turnOutcome`, present only while idle) and its own clock; see "The main agent fact" below         |
-| `structuredHost`                                    | `'owned'` while `summary.hostExecutionOwned` is set, otherwise `'held'`; `worktree ps` derives its row's `structuredHostOwned` from it                                        |
-| prompt, tool, last message, model, provider session | the summary's fields                                                                                                                                                          |
+| Row field                                           | From                                                                                                                                                                                                                                    |
+| --------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `paneKey`                                           | `structuredAgentSessionPaneKey(tabId, sessionId)`, the key the renderer already uses; its leaf is UUID-shaped so pane-key validation accepts it                                                                                         |
+| `tabId`                                             | `structuredAgentSessionTabId(sessionId)`                                                                                                                                                                                                |
+| `worktreeId`                                        | `summary.workspaceId` (a folder workspace id is a valid value)                                                                                                                                                                          |
+| `state`                                             | `structuredAgentSessionAgentStatus(summary).state`: the lead's own status folded with the live child records the store holds for the session (not the summary's task list), so a settled lead whose subagent still runs reads `working` |
+| `workingMode`                                       | `'monitoring'` from the same fold when watch loops are the only live child work; omitted otherwise, which clears it on the row                                                                                                          |
+| `mainAgent`                                         | the main agent's own state before the fold, its last-turn verdict (`summary.turnOutcome`, present only while idle) and its own clock; see "The main agent fact" below                                                                   |
+| `structuredHost`                                    | `'owned'` while `summary.hostExecutionOwned` is set, otherwise `'held'`; `worktree ps` derives its row's `structuredHostOwned` from it                                                                                                  |
+| prompt, tool, last message, model, provider session | the summary's fields                                                                                                                                                                                                                    |
 
 Sessions with no request (`status === null`) produce no row. A request is a
 turn record, an assistant message, a user message the provider journaled itself

src/cli/runtime/websocket-transport.test.ts

@@ -32,6 +32,7 @@ import {
   WORKTREE_VISIBILITY_DEFAULTS_RUNTIME_CAPABILITY,
   WORKTREE_VISIBILITY_SOURCE_DEFAULTS_RUNTIME_CAPABILITY
 } from '../../shared/protocol-version'
+import { AGENT_SESSION_BACKGROUND_TASK_CHILD_VIEWS_CAPABILITY } from '../../shared/agent-session-background-task-child-views-capability'
 
 vi.mock('./launch', () => ({
   launchOrcaApp: vi.fn()
@@ -75,6 +76,7 @@ describe('CLI remote WebSocket transport', () => {
         clientCapabilities: [
           AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY,
           AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
+          AGENT_SESSION_BACKGROUND_TASK_CHILD_VIEWS_CAPABILITY,
           AGENT_SESSION_TURN_ITEM_CAPABILITY,
           SESSION_TAB_CLOSE_INTENT_RUNTIME_CAPABILITY,
           SESSION_TABS_AUTHORITATIVE_INVENTORY_RUNTIME_CAPABILITY,

src/main/agent-hooks/server-ingest-structured-state-clock.test.ts

@@ -4,6 +4,7 @@
 
 import { beforeEach, describe, expect, it } from 'vitest'
 import type { AgentSessionStatusSummary } from '../../shared/agent-session-wire'
+import type { AgentChildWorkEvidence } from '../../shared/agent-status-child-work-evidence'
 import { makeStructuredAgentStatusSubject } from '../../shared/agent-status-subject'
 import { AgentHookServer, _internals } from './server'
 
@@ -32,6 +33,22 @@ function summary(over: Partial<AgentSessionStatusSummary> = {}): AgentSessionSta
   }
 }
 
+const CHILD = { idKind: 'task_id', id: 'child-1' } as const
+
+function liveChild(observedAt: number): AgentChildWorkEvidence {
+  return {
+    type: 'live',
+    observedAt,
+    child: {
+      handle: CHILD,
+      kind: 'agent',
+      residency: 'background',
+      state: 'working',
+      stoppable: true
+    }
+  }
+}
+
 function row(server: AgentHookServer) {
   return server.getStatusSnapshot()[0]
 }
@@ -68,16 +85,16 @@ describe("the host row's state clock", () => {
       summary({ status: 'working', statusStartedAt: 10_000, updatedAt: 10_000 }),
       SUBJECT
     )
-    server.ingestStructuredStatus(
-      summary({
-        statusStartedAt: SETTLED,
-        updatedAt: 24_000,
-        backgroundTasks: [{ id: 'child-1', kind: 'agent', state: 'working' }]
-      }),
-      SUBJECT
-    )
+    // The row reads child liveness from the host's records, not the summary's task list.
+    server.ingestStructuredChildWork(SUBJECT, [liveChild(23_000)], 'codex')
+    server.ingestStructuredStatus(summary({ statusStartedAt: SETTLED, updatedAt: 24_000 }), SUBJECT)
     expect(row(server)).toMatchObject({ state: 'working', stateStartedAt: 10_000 })
 
+    server.ingestStructuredChildWork(
+      SUBJECT,
+      [{ type: 'ended', observedAt: 25_000, handle: CHILD, outcome: 'succeeded' }],
+      'codex'
+    )
     server.ingestStructuredStatus(summary({ statusStartedAt: SETTLED, updatedAt: 26_000 }), SUBJECT)
     expect(row(server)).toMatchObject({ state: 'done', stateStartedAt: SETTLED })
   })

src/main/agent-hooks/server-ingest-structured-status.test.ts

@@ -4,6 +4,7 @@ import { mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'nod
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import type { AgentSessionStatusSummary } from '../../shared/agent-session-wire'
+import type { AgentChildWorkEvidence } from '../../shared/agent-status-child-work-evidence'
 import { isFreshNonDoneAgentStatus } from '../../shared/agent-status-freshness'
 import {
   structuredAgentSessionPaneKey,
@@ -39,6 +40,30 @@ const TAB = structuredAgentSessionTabId(SESSION)
 const STRUCTURED_PANE = structuredAgentSessionPaneKey(TAB, SESSION)
 const OBSERVED_AT = 1_757_030_400_000
 
+/** A child the provider reports live, as the structured producers hand it to the host. */
+function liveChild(id: string, kind: 'agent' | 'command'): AgentChildWorkEvidence {
+  return {
+    type: 'live',
+    observedAt: OBSERVED_AT,
+    child: {
+      handle: { idKind: 'task_id', id },
+      kind,
+      residency: 'background',
+      state: 'working',
+      stoppable: true
+    }
+  }
+}
+
+function endedChild(id: string): AgentChildWorkEvidence {
+  return {
+    type: 'ended',
+    observedAt: OBSERVED_AT + 1,
+    handle: { idKind: 'task_id', id },
+    outcome: 'succeeded'
+  }
+}
+
 function summary(over: Partial<AgentSessionStatusSummary> = {}): AgentSessionStatusSummary {
   return {
     sessionId: SESSION,
@@ -103,66 +128,60 @@ describe('AgentHookServer ingestStructuredStatus', () => {
     expect(server.getStatusSnapshot()[0]?.state).toBe('done')
   })
 
-  it('folds live background tasks into an idle session the way the hook lane folds a roster', () => {
+  it("folds the host's live child records into an idle session the way the hook lane folds a roster", () => {
     const server = new AgentHookServer()
-    server.ingestStructuredStatus(
-      summary({
-        status: 'idle',
-        backgroundTasks: [{ id: 'child-1', kind: 'agent', state: 'working' }]
-      }),
-      SUBJECT
-    )
+    server.ingestStructuredStatus(summary({ status: 'idle' }), SUBJECT)
+    server.ingestStructuredChildWork(SUBJECT, [liveChild('child-1', 'agent')], 'codex')
+    server.ingestStructuredStatus(summary({ status: 'idle', updatedAt: OBSERVED_AT + 1 }), SUBJECT)
     expect(server.getStatusSnapshot()[0]).toMatchObject({ state: 'working' })
     expect(server.getStatusSnapshot()[0]).not.toHaveProperty('workingMode')
 
-    server.ingestStructuredStatus(
-      summary({
-        status: 'idle',
-        updatedAt: OBSERVED_AT + 1,
-        backgroundTasks: [{ id: 'shell-1', kind: 'command', state: 'working' }]
-      }),
-      SUBJECT
+    server.ingestStructuredChildWork(
+      SUBJECT,
+      [endedChild('child-1'), liveChild('shell-1', 'command')],
+      'codex'
     )
+    server.ingestStructuredStatus(summary({ status: 'idle', updatedAt: OBSERVED_AT + 2 }), SUBJECT)
     expect(server.getStatusSnapshot()[0]).toMatchObject({
       state: 'working',
       workingMode: 'monitoring'
     })
 
+    server.ingestStructuredChildWork(SUBJECT, [endedChild('shell-1')], 'codex')
+    server.ingestStructuredStatus(summary({ status: 'idle', updatedAt: OBSERVED_AT + 3 }), SUBJECT)
+    expect(server.getStatusSnapshot()[0]).toMatchObject({ state: 'done' })
+    expect(server.getStatusSnapshot()[0]).not.toHaveProperty('workingMode')
+  })
+
+  // The summary's task list is derived from these records for older clients; the row reads the
+  // records themselves, so a list that disagrees with them cannot hold the parent open.
+  it("reads child liveness from the host's records, never from the summary's task list", () => {
+    const server = new AgentHookServer()
     server.ingestStructuredStatus(
       summary({
         status: 'idle',
-        updatedAt: OBSERVED_AT + 2,
-        backgroundTasks: [{ id: 'shell-1', kind: 'command', state: 'done' }]
+        backgroundTasks: [{ id: 'child-1', kind: 'agent', state: 'working' }]
       }),
       SUBJECT
     )
     expect(server.getStatusSnapshot()[0]).toMatchObject({ state: 'done' })
-    expect(server.getStatusSnapshot()[0]).not.toHaveProperty('workingMode')
   })
 
   // The timer beside the row belongs to the state it labels: monitoring that becomes a real turn
   // must not report the watch loop's age as how long the agent has been working.
   it('restarts the state clock when monitoring becomes a real turn', () => {
     const server = new AgentHookServer()
-    server.ingestStructuredStatus(
-      summary({
-        status: 'idle',
-        backgroundTasks: [{ id: 'shell-1', kind: 'command', state: 'working' }]
-      }),
-      SUBJECT
-    )
+    server.ingestStructuredStatus(summary({ status: 'idle' }), SUBJECT)
+    server.ingestStructuredChildWork(SUBJECT, [liveChild('shell-1', 'command')], 'codex')
+    server.ingestStructuredStatus(summary({ status: 'idle' }), SUBJECT)
     expect(server.getStatusSnapshot()[0]).toMatchObject({
       state: 'working',
       workingMode: 'monitoring',
       stateStartedAt: OBSERVED_AT
     })
 
     server.ingestStructuredStatus(
-      summary({
-        status: 'working',
-        updatedAt: OBSERVED_AT + 2_700_000,
-        backgroundTasks: [{ id: 'shell-1', kind: 'command', state: 'working' }]
-      }),
+      summary({ status: 'working', updatedAt: OBSERVED_AT + 2_700_000 }),
       SUBJECT
     )
     expect(server.getStatusSnapshot()[0]).toMatchObject({
@@ -178,14 +197,9 @@ describe('AgentHookServer ingestStructuredStatus', () => {
   it('dates a task edge by when the host saw it, not by the journal clock', () => {
     const server = new AgentHookServer()
     const before = Date.now()
-    server.ingestStructuredStatus(
-      summary({
-        status: 'idle',
-        updatedAt: OBSERVED_AT,
-        backgroundTasks: [{ id: 'shell-1', kind: 'command', state: 'working' }]
-      }),
-      SUBJECT
-    )
+    server.ingestStructuredStatus(summary({ status: 'idle', updatedAt: OBSERVED_AT }), SUBJECT)
+    server.ingestStructuredChildWork(SUBJECT, [liveChild('shell-1', 'command')], 'codex')
+    server.ingestStructuredStatus(summary({ status: 'idle', updatedAt: OBSERVED_AT }), SUBJECT)
     const row = server.getStatusSnapshot()[0]
     expect(row).toMatchObject({ state: 'working', workingMode: 'monitoring' })
     expect(row?.evidenceObservedAt).toBeGreaterThanOrEqual(before)
@@ -354,17 +368,17 @@ describe('structured rows and last-status.json', () => {
 describe('the main agent fact on a structured row', () => {
   it('publishes the main agent beside the folded state, on the journal clock with continuity', () => {
     const server = new AgentHookServer()
-    server.ingestStructuredStatus(
-      summary({ status: 'idle', backgroundTasks: [{ id: 'c', kind: 'agent', state: 'working' }] }),
-      SUBJECT
-    )
+    server.ingestStructuredStatus(summary({ status: 'idle' }), SUBJECT)
+    server.ingestStructuredChildWork(SUBJECT, [liveChild('c', 'agent')], 'codex')
+    server.ingestStructuredStatus(summary({ status: 'idle' }), SUBJECT)
     expect(server.getStatusSnapshot()[0]).toMatchObject({
       state: 'working',
       mainAgent: { state: 'done', stateStartedAt: OBSERVED_AT }
     })
     expect(server.getStatusSnapshot()[0]?.mainAgent).not.toHaveProperty('outcome')
 
     // The main agent is still done while its child drains: the main agent's clock does not move.
+    server.ingestStructuredChildWork(SUBJECT, [endedChild('c')], 'codex')
     server.ingestStructuredStatus(
       summary({ status: 'idle', updatedAt: OBSERVED_AT + 5, turnOutcome: 'failure' }),
       SUBJECT

src/main/agent-hooks/server/server-ingest-structured-children.ts

@@ -7,6 +7,10 @@ import {
   reconcileAgentChildWorkEvidence,
   type AgentChildWorkReconcileOutcome
 } from '../../../shared/agent-status-child-work-reconciliation'
+import {
+  projectAgentChildWorkViews,
+  type AgentChildWorkView
+} from '../../../shared/agent-status-child-work-view'
 import {
   parseAgentStatusSubject,
   type AgentStatusStructuredSessionSubject
@@ -57,4 +61,13 @@ export abstract class AgentHookServerIngestStructuredChildren extends AgentHookS
     const parent = parseAgentStatusSubject(subject)
     return parent ? this.canonicalStatusStore.getChildren(parent) : []
   }
+
+  /** The same records as the views every surface reads; the one record-to-view projection. */
+  getStructuredChildWorkViews(subject: AgentStatusStructuredSessionSubject): AgentChildWorkView[] {
+    const children = this.getStructuredChildWork(subject)
+    return projectAgentChildWorkViews(
+      children,
+      children.flatMap((child) => this.canonicalStatusStore.getAliasesForChild(child.childWorkId))
+    )
+  }
 }

src/main/agent-hooks/server/server-ingest-structured.ts

@@ -44,9 +44,11 @@ export abstract class AgentHookServerIngestStructured extends AgentHookServerIng
     }
     const previous = this.canonicalStatusStore.getParent(parsed)
     const priorStatus = previous?.status
+    // The host's own child records, not the summary's lossy task list: the summary is derived
+    // from these records, and reading them here keeps the row and every view of it on one source.
     const agentStatus = structuredAgentSessionAgentStatus({
       status: summary.status,
-      backgroundTasks: summary.backgroundTasks,
+      childWork: this.canonicalStatusStore.getChildren(parsed),
       turnOutcome: summary.turnOutcome
     })
     const { state, workingMode } = agentStatus

src/main/claude/__fixtures__/claude-agent-sdk-scripted-cli.mjs

@@ -5,7 +5,8 @@
 //
 // Env contract (set by the test):
 //   ORCA_SDK_CONTRACT_SCENARIO_PATH — JSON file
-//     { steps: Step[], controlResponses?: { [subtype]: <response> } } where a Step is
+//     { steps: Step[], controlResponses?: { [subtype]: <response> },
+//       controlResponseLeadingFrames?: { [subtype]: <frame>[] } } where a Step is
 //     { emit: <frame> } | { awaitUserMessage: true } | { stderr: <text> } |
 //     { awaitControlResponse: <request_id> } | { delayMs: <n> } | { exit: <code> }
 //   ORCA_SDK_CONTRACT_REPORT_PATH — where argv/env observations are written
@@ -93,7 +94,7 @@ createInterface({ input: process.stdin }).on('line', (line) => {
     if (process.env.ORCA_SDK_CONTRACT_IGNORE_CONTROL_REQUESTS) {
       return
     }
-    emit({
+    const response = {
       type: 'control_response',
       response: {
         subtype: 'success',
@@ -103,7 +104,10 @@ createInterface({ input: process.stdin }).on('line', (line) => {
           models: []
         }
       }
-    })
+    }
+    // Frames the CLI wrote just before its answer, in the same write: one read chunk.
+    const leading = scenario.controlResponseLeadingFrames?.[frame.request?.subtype] ?? []
+    process.stdout.write([...leading, response].map((line) => `${JSON.stringify(line)}\n`).join(''))
     return
   }
   if (frame.type === 'control_response') {