feat(agent-status): publish the main agent's own state beside the combined row state

[brennanb2025]

	Files	Added	Deleted	Net
Test	21	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​1931	$\color{#cf222e}{\Huge{\mathbf{−}}}$​54	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​1877
Prod	32	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​732	$\color{#cf222e}{\Huge{\mathbf{−}}}$​186	$\color{#1a7f37}{\Huge{\mathbf{+}}}$​546

ELI5

The sidebar, worktree ps, mobile and the dashboard each show one status per agent: working, waiting or done. When Claude's main agent has finished but a subagent it started is still running, that status says "working", which is right for the user, but it throws away the fact that the main agent itself is done. This change records that fact next to the status. Along the way it replaces an old saved marker that Orca used to remember "only subagents are keeping this row busy", which fixes a few cases where a row got stuck on "working" after a restart.

What Changed

Before and after, as the user experiences it. Normal flows look the same: every row still shows the same combined status, the same "monitoring" label for a settled agent with a background watch loop, and the same timers. These edge cases change, all around Claude or Codex background subagents:

• After an Orca restart, rows settle instead of sticking on "working". Main agent finished, a subagent still running, Orca restarted, the subagent then finishes: the row now goes to done. Before, some of these rows (a subagent that started after a normal stop, or a Codex root that finished beside a live child) stayed "working" until the agent did something else.
• A terminal title can no longer hide a live subagent. If the main agent is done and a subagent is still working, an idle terminal title used to be able to mark the row done. It now stays working, including when a shell is also running. When everything has finished, a "working" title is now applied like it is on any other finished row.
• A shell left running behind a subagent's permission prompt keeps the row open. Before, approving the prompt and letting the subagent finish could mark the row done while that shell still ran.
• After a restart, the next subagent event keeps the saved prompt label instead of blanking it, which matches what happens without a restart.

The mechanism. Claude, Codex and Grok hook rows and structured-session rows now also carry the main agent's own state (other agents' rows and terminal-title-only rows carry none, and readers fall back to state):

mainAgent?: { state: AgentStatusState; outcome?: AgentJournalTurnOutcome; stateStartedAt: number }

• state is the main agent's own state before child work is folded in. While a wait belongs to a subagent (a subagent's permission prompt), it is the main agent's state that the wait displaced, usually done, not waiting.
• outcome is the recorded verdict on the main agent's most recent finished turn, present only while mainAgent.state is done; a new turn clears it and restating the same finished turn keeps it. Absent means unknown, never success. It is reported by the agent (Claude StopFailure → failure, is_interrupt on builds that send it, Grok stop_cancelled / stop_failure, the structured journal's own verdict) or, for a cancel, inferred from the user's Ctrl+C: current Claude Code sends no hook on a cancel, so Orca's inferred interrupt is the main source in the Claude hook lane. A bare Esc is never read as a Claude cancel.
• stateStartedAt is the main agent's own clock, separate from the row's clock. A new Claude session restarts it.

Those producers publish it: the Claude hook lane from the main-agent turn record it already kept; structured sessions (host ingest and the renderer bridge), with the session summary gaining an optional turnOutcome; Grok, whose inline "keep working after stop" logic moves onto the shared fold with identical results; and Codex from its root record (its own combining rule stays, because a waiting child wins there and the shared fold has no waiting-child input yet).

mainAgent lives inside the normalized payload, so one function admits it on the relay wire, over IPC and from disk; a malformed one drops the field and keeps the row.

What replaced the old saved marker. Orca used to persist claudeLeadBoundaryChildOnly, a flag recording "the main agent's last stop happened while only subagents were running, and nothing but subagent events arrived since". It is no longer written:

• Restart seeds the Claude main agent directly from a saved mainAgent that is done, but only when the row also says no shell was running (claudeRunningNonAgentTask: false, now persisted). A row that does not say stays unseeded, because a shell's liveness is not restored after a restart. Codex seeds its root from a saved mainAgent too. Older rows that still carry the flag load as mainAgent: done with no shell.
• Terminal-title updates are refused on a Claude row whose main agent is done while a subagent is working, including while a subagent's permission prompt is showing.
• One rule pairs the shell fact with mainAgent where every row is built: a Claude hook event restates the shell fact, and any other rewrite (a terminal-title repaint, an inferred answer) keeps it only while mainAgent is unchanged. This replaces three places that each had to remember to copy it.
• A held subagent permission prompt still records the main agent's progress and background evidence in the row, and pushes the row to subscribers when mainAgent changes.
• The renderer keeps a previous mainAgent only for writers that never carry one (terminal-title, launch and process rows), so a hook row without it matches what the host serves mobile and the CLI.

A parity table drives all four lanes through the same six stories and asserts the published { state, workingMode, mainAgent }. One is pinned as a known divergence: after a cancelled turn with a shell still running, the hook lane reads done and the structured lane reads monitoring; the cancel policy change removes it.

Why

The combined status was answering two questions at once: "is the main agent working?" and "should the user see working?". Answering only the second destroyed the first at publish time, and every consumer that needed it grew a guard that rebuilt a fragment: the saved child-only flag, the structured fromChildWork clock switch, keep-awake special cases. Storing the fact once and deriving from it removes that class of guard.

Alternatives considered:

• A boolean such as fromChildWork on the row. Derivable from mainAgent but not the other way round, it cannot say "the main agent is blocked on a question while a subagent runs", and once persisted it is permanent.
• Fold on the client and publish only the facts. Clients and hosts update independently and an old mobile client reads only state, so the host keeps publishing the combined value and mainAgent is a new optional field.
• Keep writing the old flag beside mainAgent. It reproduces the old behavior exactly, including a terminal title hiding a subagent that started after a normal stop, and it is a second persisted copy of "the main agent is done" that can disagree with mainAgent.
• Persist an equivalent history marker. Once mainAgent is accurate during subagent waits, the marker is derivable, and a permanent field that duplicates a derivable fact is the thing this change removes.

Linked Issue

Follow-up to #22295, which added the fold this change makes explicit. No separate issue.

Visual Proof

Isolated dev instance, real Claude Code 2.1.280, sidebar plus the row read from the renderer store. Captured at 5ffe00ffa0; the commits after it change how the shell fact is kept and do not change these three flows.

Main agent done, background subagent still working: sidebar working, mainAgent.state: done.

A background subagent's permission prompt after the main agent finished: sidebar waiting, mainAgent.state: done. Claude's terminal title was its idle ✳ form for the whole wait; the row still stayed waiting (below: 34 seconds later), then settled to done after approval.

After quitting and relaunching Orca while the subagent ran, the same session came back working with mainAgent.state: done.

That subagent then died on an API usage-limit error, and the row stayed working with the dead subagent listed. That happens on main too, with or without a restart (Claude sends no subagent-stop event for it), so it is left for a separate change.

Testing

• pnpm tc exit 0; pnpm exec oxlint on every changed file clean; pnpm run check:code-quality:changed passed.

• pnpm test (with ORCA_STRUCTURED_SESSION unset) over src/main/agent-hooks, src/shared, src/relay, src/renderer/src/store/slices, the structured status bridge, the runtime mobile projection and src/main/native-chat/agent-session-wire: 1511 files, 15753 tests passed.

• Server-level regression tests drive the real hook server with the events Claude, Codex and Grok send, including restarts through a persisted profile: server-last-status-child-held-main-agent.test.ts, server-main-agent-turn-verdicts.test.ts, server-last-status-main-agent-fact.test.ts. Each fix was proven by deleting it and watching its test go red for the pinned reason: restart seeding, the terminal-title refusal (both narrowed and removed), the shell-fact pairing rule, fail-closed seeding, the legacy-row mapping, the held-prompt background evidence, the held-row push, the renderer carry, the Claude session clock, and the Grok and Codex verdict carry (Codex both local and relayed).

• The restart and permission-prompt stories were also run against main: the cases main already handled pass there, and the "subagent started after a normal stop" restart case fails on main (stuck working), as expected.

• Mobile checks: no file under mobile/ changes; the runtime agent-row projection carries mainAgent as an optional field old apps ignore.

• Platforms: macOS. No platform branches; relay and SSH paths go through the same normalizer the tests drive via ingestRemote.

• I manually tested these changes locally (Electron QA above)

• Automated tests added/updated, or explained why not below

AI Disclosure

Author: @BrennanKB5

Review

Persisted shape. Two fields reach last-status.json: payload.mainAgent and the top-level claudeRunningNonAgentTask. The shell fact is the one piece of child work mainAgent cannot express, and restart needs it to avoid settling a row a shell still holds. It is Claude-only and stays outside the status payload readers receive.

Two combining rules deliberately remain outside the shared fold and are named in docs/reference/agent-status-store.md: Codex's own combine, and the cancelled-turn watch-loop divergence between the hook and structured lanes.

Known limits, unchanged from main: a background subagent that dies without a stop event stays listed as working; an inferred Claude cancel is not restored as settled after a restart; an old SSH/WSL relay that predates mainAgent gets neither the restart seeding nor the terminal-title refusal until it updates.

Agent skill upstream boundary

• Not applicable, or this change follows docs/reference/agent-skill-sharing-upstream-boundary.md and copies or mechanically translates no upstream skill-installer source, tests, fixtures, registry entries, path tables, comments, or documentation.

Notes

• Wire: mainAgent on the status payload and turnOutcome on the session summary are new optional fields. Old clients ignore them; new clients fall back to state when an old host sends none. The worktree ps row keeps its shape.
• SSH and WSL relays: the relay's own normalizer builds mainAgent and sends the shell fact with each event; main re-runs the canonical normalizer on receipt. Codex rows re-publish mainAgent from main's longer-lived cache after a relay restart.
• Folder workspaces: the structured ingest keys rows by workspace id as before.

Checklist

• This PR is small and focused (53 files: one field threaded through every producer, admission point and projection, most of it tests)
• I explained what changed and why (ELI5, the user-facing before/after, the mechanism, and why over the alternatives)
• Before/after screenshots or videos attached for UI changes, or N/A with reason
• Self-reviewed for correctness, security, and performance
• Cross-platform, SSH/remote, and path/shortcut impact considered (or N/A)
• pnpm lint, pnpm typecheck, pnpm test, and pnpm build pass (or CI will cover; local preferred)

[pullfrog]

✅ No new issues found.

Reviewed changes — the complete diff (51 files, one commit) that adds the lead agent's own state beside the combined row state.

• A new lead fact on every status row. AgentLeadStatus (state, optional provider outcome, stateStartedAt) rides on AgentStatusPayload.lead, admitted by normalizeAgentStatusPayload on the relay wire, over IPC and from disk; a malformed value drops the field and keeps the row.
• Child-only state is now derived, never stored. The persisted claudeLeadBoundaryChildOnly flag and structured fromChildWork are gone, replaced by isAgentStatusHeldOpenByChildWork over lead plus the row's child evidence; hydration maps a legacy flag onto an absent lead.
• Every producer publishes it. Claude stores a verdict instead of an interrupt flag via setClaudeLeadTurnState (now the sole writer), structured sessions add turnOutcome to the summary, Grok moves its stop-keeps-working rule onto the shared fold, and Codex publishes from its root record while deliberately keeping its own combine.
• Parity and restart coverage. A six-story table drives all four lanes against the fold, alongside restart round-trip, OSC carry, inferred-interrupt, IPC/store and mobile-projection tests.

ℹ️ Persisting claudeRunningNonAgentTask is consistent with the design

The author flagged this as a persisted-shape change; I traced it and agree with the call. lead cannot express "a shell is running beside the child agents" (lead.state === 'done' holds either way), yet hydration needs that fact to decide whether to seed a settled lead, so recording the boolean is the only non-divergent option once the derived flag stops being written. The derived boundary treats a missing/undefined value as "no shell" (row.claudeRunningNonAgentTask !== true), which is exactly what the old persisted flag's absence encoded, so legacy rows hydrate to the same child-only decision. No change requested.

Technical details

# Persisted shell fact

## Affected sites
- `src/main/agent-hooks/server/server-types.ts` — `claudeRunningNonAgentTask` removed from the `Omit` list, so it now serializes.
- `src/main/agent-hooks/server/server-persistence-validation.ts` — reads the boolean back onto the hydrated entry and maps a legacy child-only flag onto an absent `lead`.
- `src/main/agent-hooks/server/server-hydration.ts` — calls `isClaudeLeadBoundaryHeldByChildrenOnly(entry)` to seed the lead record.

## Required outcome
- None. Recorded so the persisted-shape decision is on the record; the field is a boolean, is not a secret, and `lead`'s admission path already governs the payload it rides in.

## Note
- After restart the in-memory `state.claudeRunningNonAgentTaskPaneKeys` set is still not seeded from the persisted boolean, but every consumer either already consulted the row itself (`reapRestoredClaudeSubagentsWithoutLiveAgent`'s `payload.state !== 'done'`, `inferInterrupt`'s `restoredUnconfirmed` refusal) or reproduces the old absent-flag semantics, so the disagreement cannot leave a row stuck non-terminal.

  ^{｜ View workflow run ｜ Using DeepSeek Flash (free via Pullfrog for OSS) ｜ 𝕏}

[coderabbitai]

Navigate logical layers of code changes, visualize relationships, and explore their blast radius.

Note

Reviews paused

It looks like this branch is under active development. To avoid overwhelming you with review comments due to an influx of new commits, CodeRabbit has automatically paused this review. You can configure this behavior by changing the reviews.auto_review.auto_pause_after_reviewed_commits setting.

Use the following commands to manage reviews:

• @coderabbitai resume to resume automatic reviews.
• @coderabbitai review to trigger a single review.

Use the checkboxes below for quick actions:

• ▶️ Resume reviews
• 🔍 Trigger review

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Advanced

Run ID: 122b2dfd-7e63-46fb-88ff-231e0e947be3

📥 Commits

Reviewing files that changed from the base of the PR and between 42773a3 and 2b24918.

📒 Files selected for processing (4)

• src/shared/agent-hook-listener/providers/claude-roster-state.ts
• src/shared/agent-session-journal-types.ts
• src/shared/agent-session-wire.ts
• src/shared/structured-agent-session-projection.ts

🚧 Files skipped from review as they are similar to previous changes (1)

• src/shared/agent-session-journal-types.ts

Included review availability: Your plan provides up to 10 included reviews per hour; 6 remain after this review.

---

📝 Walkthrough

Walkthrough

Agent status rows now carry a mainAgent fact with its own state, timestamp, and optional turn outcome. Claude, Codex, Grok, and structured-session paths publish or continue this fact, and normalization and persistence retain it across status updates and hydration. Legacy Claude boundary data can seed a missing fact during hydration. Renderer status entries preserve the fact across IPC and matching state updates. Tests cover provider parity, turn outcomes, persistence, hydration, and renderer projections.

Priority: ⬇️ Low

Merge Risk: 🟡 Moderate · up to 2b249

The new main-agent status can lose a Grok turn verdict or show a timestamp from an earlier Claude session. Correct these status facts before merging.

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 44.87% which is insufficient. The required threshold is 80.00%. Docstring coverage is scoped to functions touched by this diff. Analyzed 78 functions across 58 files.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (4 passed)

Check name	Status	Explanation
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Title check	✅ Passed	The title clearly and concisely describes the primary change: publishing the main agent's own state alongside the combined row state.
Description check	✅ Passed	The description is detailed and covers the required explanation, changes, rationale, testing, visual proof, AI disclosure, review notes, compatibility considerations, and checklist. It references issu…

• Fix all pre-merge checks with AI

✨ Finishing Touches 💡 2

📝 Generate docstrings 💡

• Commit to this branch
• Create a new PR

🛠️ Fix failing CI checks 💡

• Commit to this branch
• Create a new PR

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[coderabbitai]

Actionable comments posted: 3

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Advanced

Run ID: d9a410b8-685f-4a1a-9b9b-058b50632bb7

📥 Commits

Reviewing files that changed from the base of the PR and between a2a78ab and 0d9d5e0.

📒 Files selected for processing (51)

• docs/reference/agent-status-store.md
• src/main/agent-hooks/server-ingest-structured-status.test.ts
• src/main/agent-hooks/server-ingest-terminal-status.test.ts
• src/main/agent-hooks/server-interrupt-inference-validation.test.ts
• src/main/agent-hooks/server-last-status-lead-boundary.test.ts
• src/main/agent-hooks/server-last-status-lead-fact.test.ts
• src/main/agent-hooks/server-last-status-write.test.ts
• src/main/agent-hooks/server/server-claude-status-rules.ts
• src/main/agent-hooks/server/server-hydration.ts
• src/main/agent-hooks/server/server-ingest-structured.ts
• src/main/agent-hooks/server/server-ingest-terminal.ts
• src/main/agent-hooks/server/server-persistence-validation.ts
• src/main/agent-hooks/server/server-persistence.ts
• src/main/agent-hooks/server/server-status-inference.ts
• src/main/agent-hooks/server/server-status-update.ts
• src/main/agent-hooks/server/server-types.ts
• src/main/agent-hooks/terminal-handle-row-identity.test.ts
• src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.ts
• src/main/runtime/runtime-agent-row-lead-projection.test.ts
• src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.test.tsx
• src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx
• src/renderer/src/hooks/ipc-events/normalize-agent-status-event.ts
• src/renderer/src/store/slices/agent-status-lead-fact.test.ts
• src/renderer/src/store/slices/agent-status-live-entry-builder.ts
• src/renderer/src/store/slices/agent-status-live-entry-lead.ts
• src/shared/agent-hook-listener-claude-subagents.test.ts
• src/shared/agent-hook-listener-claude-turn-state.test.ts
• src/shared/agent-hook-listener-codex-lead.test.ts
• src/shared/agent-hook-listener-extraction-characterization.test.ts
• src/shared/agent-hook-listener/lead-turn-state.ts
• src/shared/agent-hook-listener/listener-state.ts
• src/shared/agent-hook-listener/providers/claude-events.ts
• src/shared/agent-hook-listener/providers/claude-lifecycle-events.ts
• src/shared/agent-hook-listener/providers/claude-roster-state.ts
• src/shared/agent-hook-listener/providers/claude-status-build.ts
• src/shared/agent-hook-listener/providers/codex-events.ts
• src/shared/agent-hook-listener/providers/codex-state.ts
• src/shared/agent-hook-listener/providers/grok-events.ts
• src/shared/agent-lead-status-fold.test.ts
• src/shared/agent-lead-status-fold.ts
• src/shared/agent-lead-status-parity.test.ts
• src/shared/agent-lead-status.ts
• src/shared/agent-session-journal-types.ts
• src/shared/agent-session-wire.ts
• src/shared/agent-status-types.test.ts
• src/shared/agent-status-types.ts
• src/shared/agent-turn-outcome.ts
• src/shared/structured-agent-session-agent-status.test.ts
• src/shared/structured-agent-session-agent-status.ts
• src/shared/structured-agent-session-projection.test.ts
• src/shared/structured-agent-session-projection.ts

Included review availability: Your plan provides up to 10 included reviews per hour; 1 remains after this review.

[coderabbitai]

🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

Restart the lead clock at a Claude SessionStart boundary.

setClaudeLeadTurnState goes through continueAgentLeadStatus. That function keeps previous.stateStartedAt when the previous state is also done. Suppose the previous lead is already done, for example after /clear, a resume, or a relaunch on an idle pane. The new session then publishes lead.stateStartedAt from the old session's last turn. The Grok lane treats a new process as a new lead and drops its lead cache on session_start. The Claude lane should also restart the lead clock here.

Proposed fix

-    setClaudeLeadTurnState(state, paneKey, { state: 'done' })
+    // A new process owns the pane: its lead clock starts now, not at the old session's last Stop.
+    setClaudeLeadTurnState(state, paneKey, { state: 'done', stateStartedAt: Date.now() })

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	setClaudeLeadTurnState(state, paneKey, { state: 'done' })
	// A new process owns the pane: its lead clock starts now, not at the old session's last Stop.
	setClaudeLeadTurnState(state, paneKey, { state: 'done', stateStartedAt: Date.now() })

[coderabbitai]

🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

Keep the Grok turn verdict when an idle_prompt notification restates done.

outcome comes only from stop_cancelled or stop_failure. A later notification/idle_prompt, or a repeated done from session_end, also maps to leadState = 'done'. That event passes outcome: undefined, so continueAgentLeadStatus removes the stored verdict. The published lead then loses cancellation or failure while the lead is still in the same finished turn. This breaks the AgentLeadStatus.outcome contract that "a new turn clears it". The Claude lane keeps the cached verdict on such refreshes. Carry the previous verdict forward when the lead stays done and the event is not a turn end.

Proposed fix

-  const outcome = isGrokEvent(eventName, 'stop_cancelled')
-    ? ('cancellation' as const)
-    : isGrokEvent(eventName, 'stop_failure')
-      ? ('failure' as const)
-      : undefined
+  const previousLead = state.grokLeadStatusByPaneKey.get(paneKey)
+  const outcome = isGrokEvent(eventName, 'stop_cancelled')
+    ? ('cancellation' as const)
+    : isGrokEvent(eventName, 'stop_failure')
+      ? ('failure' as const)
+      : !isTurnEnd && leadState === 'done' && previousLead?.state === 'done'
+        ? previousLead.outcome
+        : undefined
 ...
-  const lead = continueAgentLeadStatus(
-    state.grokLeadStatusByPaneKey.get(paneKey),
-    { state: leadState, outcome },
-    Date.now()
-  )
+  const lead = continueAgentLeadStatus(previousLead, { state: leadState, outcome }, Date.now())

If you apply this change, check whether interrupted and the fold's interrupted input should also stay set on these refreshes. They currently read the same outcome value.

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	// Why: the provider's verdict, never inferred — a plain `stop` stays absent.
	const outcome = isGrokEvent(eventName, 'stop_cancelled')
	? ('cancellation' as const)
	: isGrokEvent(eventName, 'stop_failure')
	? ('failure' as const)
	: undefined
	// Only a plain end-of-turn `stop` reports what it left running; a cancel, a failure and a
	// session boundary settle the pane whatever the inventory says, as they always have.
	const resolution = foldAgentLeadStatus({
	leadState,
	interrupted: outcome === 'cancellation',
	childWorkLiveness:
	isGrokEvent(eventName, 'stop') && !sessionBoundary
	? grokChildWorkLivenessAfterStop(hookPayload)
	: null
	})
	const stateName = resolution.stateName
	const lead = continueAgentLeadStatus(
	state.grokLeadStatusByPaneKey.get(paneKey),
	{ state: leadState, outcome },
	Date.now()
	)
	state.grokLeadStatusByPaneKey.set(paneKey, lead)
	// Why: the provider's verdict, never inferred — a plain `stop` stays absent.
	const previousLead = state.grokLeadStatusByPaneKey.get(paneKey)
	const outcome = isGrokEvent(eventName, 'stop_cancelled')
	? ('cancellation' as const)
	: isGrokEvent(eventName, 'stop_failure')
	? ('failure' as const)
	: !isTurnEnd && leadState === 'done' && previousLead?.state === 'done'
	? previousLead.outcome
	: undefined
	// Only a plain end-of-turn `stop` reports what it left running; a cancel, a failure and a
	// session boundary settle the pane whatever the inventory says, as they always have.
	const resolution = foldAgentLeadStatus({
	leadState,
	interrupted: outcome === 'cancellation',
	childWorkLiveness:
	isGrokEvent(eventName, 'stop') && !sessionBoundary
	? grokChildWorkLivenessAfterStop(hookPayload)
	: null
	})
	const stateName = resolution.stateName
	const lead = continueAgentLeadStatus(previousLead, { state: leadState, outcome }, Date.now())
	state.grokLeadStatusByPaneKey.set(paneKey, lead)

[pullfrog]

✅ No new issues found.

Reviewed changes — the two commits pushed since the prior pullfrog review (0d9d5e0f), both small behavior fixes with supporting tests and doc/comment corrections.

• Kept an already settled main agent intact through an inferred interrupt. server-status-inference.ts now reuses payload.mainAgent when it is already done instead of synthesizing a fresh cancellation verdict, so a watch loop holding the row open cannot rewrite the settled main agent's clock or verdict. The branch is only reachable for Grok/custom agents: for Claude and Codex, state === 'working' alongside mainAgent.state === 'done' implies child evidence, and the non-idle-subagent guard returns first.
• A child-induced wait now publishes the main agent state it displaced. claudeMainAgentStatusForPayload selects stateBeforeWait when the record carries a waitingAgentId, so the row's combined waiting state no longer masquerades as the main agent's own state; clearClaudeAnsweredQuestionWait's mainAgent becomes optional to match.
• Verdict provenance documented. agent-turn-outcome.ts, main-agent-status.ts, main-agent-turn-state.ts, claude-events.ts, grok-events.ts, agent-session-journal-types.ts and docs/reference/agent-status-store.md now name the inferred interrupt as a recorded outcome source.
• Coverage updated. Exact assertions added for the settled-behind-watch-loop interrupt and for the child-vs-own wait distinction.

  ^{｜ View workflow run ｜ Using DeepSeek Flash (free via Pullfrog for OSS) ｜ 𝕏}

[pullfrog]

ℹ️ No critical issues — one actionable gap in the new Grok verdict fallback, inline.

Reviewed changes — the four commits pushed since the prior pullfrog review (8bbe6d4).

• Hydration now seeds the Claude main-agent record from the saved mainAgent fact. seedClaudeLeadTurnFromPersistedStatus dropped its childOnlyBoundary option and seeds any restored row whose persisted mainAgent is done with no shell holding it, so a restored row's children's drain can still settle it to done. The live-child, shell/cron and cancelled-verdict holds all still prevent a false settle.
• A held child permission prompt now records the main agent's own progress. withHeldChildWaitMainAgent rewrites the held row's mainAgent when the main agent moves behind a child's sticky prompt, so a stale done can no longer let a later drain settle a working main agent.
• OSC refuses any Claude row child agents hold open. The server-ingest-terminal guard now reads the shared isAgentStatusHeldOpenByChildWork plus a working subagent — covering waiting child-prompt rows and dropping the old shell disqualifier — and carries the shell fact forward beside the preserved mainAgent.
• Turn verdicts survive restatement. Codex keeps a recorded verdict across a late root Stop (codexOutcomeRestatedByStop), Grok preserves it across idle/session-end restatements, and Claude SessionStart now stamps its own main-agent clock.
• Coverage. Two new server suites (child-held rows across restart, main-agent turn verdicts) and updated boundary/legacy-flag tests, with exact assertions.

  ^{｜ Fix all ➔ ｜ Fix 👍s ➔ ｜ View workflow run ｜ Using DeepSeek Flash (free via Pullfrog for OSS) ｜ 𝕏}

[pullfrog]

A trailing stop reason=shutdown (or channel_closed) arrives as a turn end, so !isTurnEnd skips the fallback and continueMainAgentStatus drops the verdict on the done→done restatement — even though isGrokSessionBoundary (line 125) classifies that same event as the session ending, not a new turn. The captured fixture grok-background-completion-hooks.jsonl:13-14 emits session_end and then a trailing stop reason=shutdown, so a cancelled turn's cancellation is preserved by the session_end and erased by the stop right after it. Including session-boundary turn ends keeps the recorded verdict.

Technical details

# Grok drops a recorded verdict on the trailing shutdown stop

## Affected sites
- `src/shared/agent-hook-listener/providers/grok-events.ts:224` — `!isTurnEnd` excludes `stop reason=shutdown`, which `isGrokSessionBoundary` (`:125`) already treats as the same finished session.
- `src/shared/agent-hook-listener/providers/grok-events.ts:222-226` — the fallback restores `previousMainAgent.outcome` only for non-turn-end events.
- `src/shared/agent-lead-status-fold.ts:63` — `continueMainAgentStatus` emits `outcome` only from `next.outcome`, so a done→done call with `outcome: undefined` clears it.
- `src/shared/__fixtures__/grok-background-completion-hooks.jsonl:13-14` — real `session_end` followed by a trailing `stop reason=shutdown` with no `promptId` (`grokTurnEndApplies` returns true).

## Required outcome
- A session-boundary turn end that restates a finished turn keeps that turn's recorded `outcome`, matching the comment's "an idle prompt or session end restates the same finished turn".

## Suggested approach (optional)
- Widen the guard to `(!isTurnEnd || sessionBoundary) && leadState === 'done' && previousMainAgent?.state === 'done'`, using the `sessionBoundary` value already computed at `:165`. This also covers a `stop_failure` followed by a shutdown stop.

## Open questions for the human (optional)
- Confirm a `stop reason=shutdown` is not intended to be a fresh-turn boundary that deliberately clears the prior verdict.

[pullfrog]

✅ No new issues in the latest commits.

Reviewed changes — the three commits pushed since the prior pullfrog review (fc0fb44).

• A held child permission row is now pushed when its mainAgent changes. server-status-update.ts emits the held row to enriched subscribers when held.payload differs, so pushed readers see the main-agent update a snapshot reader already has; no push when only the unpublished shell fact changed.
• A held child permission row now keeps the shell fact. withHeldChildWaitMainAgent carries next.claudeRunningNonAgentTask ?? previous.claudeRunningNonAgentTask and returns early only when neither the mainAgent nor the shell fact moved, so restart no longer seeds a shell-held held row.
• Docs and tests. Both behaviors are pinned by exact new tests (one push on a main-agent change, none on an unchanged main agent; a shell-held held row stays unsettled across restart).

The inline concern from the prior review (Grok's trailing stop reason=shutdown erasing a restated verdict) is unchanged by these commits and remains open.

  ^{｜ Fix it ➔ ｜ View workflow run ｜ Using DeepSeek Flash (free via Pullfrog for OSS) ｜ 𝕏}

[pullfrog]

ℹ️ No new issues in the commits since the last review. This delta is a refactor that centralizes the Claude shell-fact pairing, tightens restart seeding to require an explicit no-shell, and narrows the renderer's mainAgent reuse to blind writers — all documented and pinned by exact tests. This is not an approval because the earlier Grok grok-events.ts note is untouched by these commits and its thread remains open.

Reviewed changes — the three commits pushed since the prior pullfrog review (5ffe00f).

• Centralized the Claude shell-fact pairing. attachClaudeChildOnlyBoundary / invalidateClaudeChildOnlyBoundary are replaced by pairedClaudeNonAgentWork, which a listener event restates and any other write carries only while mainAgent is unchanged. The per-write carries in the OSC ingest and inferred-answer paths are removed because the row builder now pairs once.
• Tightened restart seeding. seedClaudeLeadTurnFromPersistedStatus seeds a settled main agent only when the row states claudeRunningNonAgentTask === false; hydrate maps a legacy child-only row to that explicitly, while a row silent about the shell stays unseeded.
• Held child permission takes the event's background evidence. The held branch now calls onAccepted for a child-owned prompt, so a shell reported on the same event keeps holding the row open.
• Renderer reuse narrowed to blind writers. Only osc/title/launch/process origins reuse a previous mainAgent on an unchanged state; a hook row without one drops it to match the host snapshot.
• Coverage. Exact new tests for the shell-held held row, the silent-shell non-seed, the inferred-answer restart settle, and the renderer drop.

  ^{｜ Fix it ➔ ｜ View workflow run ｜ Using DeepSeek Flash (free via Pullfrog for OSS) ｜ 𝕏}

[brennanb2025]

Review status: ready for review at 824185d3f8

Verdict: the change does what it sets out to do, with no known regressions. CI is green (25 passed, 12 skipped).

What the review found and fixed (all pushed here, fast-forward only, so the stacked PRs can rebase):

• Visible regression, fixed. As first submitted, the calculated replacement for the old saved "only subagents are keeping this row busy" marker did not match it. An idle terminal title could hide a subagent's permission prompt, and some rows stuck on "working" after an Orca restart. The fix is to restore from the saved mainAgent and to refuse title updates while a subagent holds the row open. Both are pinned by server-level tests against the real hook server, and several cases now settle that stayed stuck on main.
• mainAgent accuracy.
  • During a subagent's permission wait it now reports the main agent's own state, usually done, instead of waiting.
  • An inferred Ctrl+C no longer overwrites a main agent that had already finished.
  • A new Claude session restarts the main agent's clock.
  • Grok and Codex keep a turn's verdict when a later event restates the same finished turn.
  • The docs now say the verdict can be inferred from Ctrl+C, not only reported by the agent.
• A repeated bug class, fixed once. Three separate code paths lost the saved "a shell is running" fact when they rewrote a row, so a restart could mark a row done while a shell still ran. One rule now pairs that fact with mainAgent where rows are built. Restart only restores a finished main agent when the row explicitly says no shell ran. A held subagent permission prompt also accepts the main agent's background evidence, which fixes a case that is wrong on main too.
• Live subscribers. The held permission row is now pushed to subscribers when its mainAgent changes, and the renderer no longer keeps a stale mainAgent that the host has dropped.

Validation:

• Local checks:
  • pnpm tc passes.
  • oxlint on the changed files passes.
  • The changed-code quality gate passes.
  • The anti-slop lint passes.
  • 15,753 tests pass across agent-hooks, shared, relay, the renderer status store, the structured bridge and the runtime projection.
• Removal tests: each fix was deleted in turn, and its test went red for the pinned reason.
• Electron QA: run on an isolated dev instance with real Claude Code at 5ffe00ffa0. The screenshots are in the description.
  • Main agent done with a subagent working: the row shows working.
  • A subagent's permission prompt: the row stayed waiting for more than 30 seconds while Claude's title showed idle, then went to done after approval.
  • Restart: the row came back working with mainAgent: done.
• Readiness checklist: passed at the start and at the end, with no release-blocking findings.

Known limits, out of scope here, all the same as on main:

• A background subagent that dies without a stop event (for example on an API usage limit) stays listed as working. Reproduced identically on main with and without a restart.
• An inferred Claude cancel is not restored as finished after a restart.
• Grok's cached main-agent record is not synced on an inferred interrupt. The cancel-policy PR reworks that path.

Stacked PRs (#22474, #22475, #22476) need a rebase onto this head. Two things change for them:

• mainAgent during a subagent's permission wait now reports the main agent's own state. As a result, isAgentExecutionOwed counts "main agent working and a subagent waiting" as owed.
• Files these commits also touch:
  • fix(agent-status): count only agent work in stats, and read a Grok background subagent as working #22474: codex-events.ts, codex-state.ts
  • feat(agent-status): combine Codex child work through the shared main-agent status fold #22475: claude-events.ts, claude-roster-state.ts, codex-*.ts, agent-status-store.md
  • fix(agent-status): a cancel never hides live work #22476: claude-events.ts, claude-roster-state.ts, grok-events.ts, server-status-inference.ts (only inferQuestionAnswered and the settled-main-agent keep in inferInterrupt), agent-status-store.md

[brennanb2025]

One more independent review at 824185d3f8 came back clean: no correctness, compatibility, performance or user-visible regressions. The only change since is df41109e4a, a one-line doc fix plus the matching PR description sentence. Both now say that only Claude, Codex and Grok hook rows and structured-session rows carry mainAgent; other agents' rows fall back to state.