From 433d33ddfb04c7a0df549f129a367c67ba12856c Mon Sep 17 00:00:00 2001 From: Jinwoo Hong <73622457+Jinwoo-H@users.noreply.github.com> Date: Wed, 11 Nov 2026 21:04:44 -0500 Subject: [PATCH] feat(orchestration): answer workers' permission prompts from the coordinator (re-land with fixes) (#41259) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * revert: worker permission approvals (#40756) This reverts commit 818055fcbb225cc8cfafd8040fe6727cb68e2b3e. The feature misbehaves in real use: an Allow on a worker's approval card was recorded as closed without an answer, and closed approval cards render at the bottom of the coordinator chat, below newer messages. Removed: the Claude PermissionRequest hook hold and its 130 s timeout, the approval card in the coordinator chat, `orchestration deny`, the approval payload on stop escalations, and the held-delivery lines on send receipts. Escalation text goes back to its pre-#40756 wording. Kept from later commits: - #40983 (lost-worker alerts): its `lost` reason, cause/leftover/settled fields, turnStartedAt and the rejected-report check stay; only the approval branches around them are removed. - #41158 (owner moves) and the test cleanups (#41151, #41175, #41177) only touched approval code that is now deleted. * feat(orchestration): answer workers' permission prompts from the coordinator (re-land of #40756) * fix(orchestration): credit an approval from Claude's own decision record and place each worker card at its time - An Allow that Claude took is answered by the person even when the command then fails or is still running; a failed command's PostToolUseFailure counts as ran. - Expired means the agent's own timeout only; a close Orca can't name is not an expiry, and reasonDelivered is true only with a reason. - Escalations wait for the dialog to paint and read Claude's warning even when a long command hides the top of its box. - Worker cards and receipts render after the message they followed in time, not after the whole conversation; the toast says what happened. * fix(native-chat): place timed rows without a memo the compiler skips * perf(orchestration): feed chat approvals from their own stream, pin open cards, close cards whose worker ended Native chats no longer subscribe to the crew stream for worker approvals. A narrow orchestration.workerApprovalsSubscribe stream per chat party wakes only on that party's own mail and on Run/Dispatch changes, never on agent status, and reads the crew only when the approval list itself changes. The pane no longer redraws for approvals: the transcript receipts and the pinned stack each hold the feed themselves. Open worker prompts are pinned above the composer (above the chat's own prompt), oldest first, in a bounded scrolling stack; the transcript keeps only receipts, at the time the worker asked. The countdown ticks only for open cards in a visible pane. An approval whose Dispatch is no longer running reads as closed ("No longer open · worker ended"); a hook that hangs up after its worker is gone closes as worker-ended rather than "answer it in the terminal"; and a click that finds the prompt or Dispatch already gone turns the card into its receipt at once. Also carries over: a stop owes a closing line only to an approval whose escalation went out. * fix(native-chat): no toast when a worker approval answer lands; the card's receipt says it * fix(native-chat): a worker approval card answers on click, as the chat's own prompt does The card turns into 'Allowed by you' at once and Claude's confirmation runs behind it; only an answer Claude did not take changes it to the real outcome, and a failure reopens the card. * fix(orchestration): keep main's stop-report index for the open-approval sweep after the re-land * fix(orchestration): final-review fixes for chat worker approvals - A click that gets approval_not_open no longer hides the card: the host's list decides, so a prompt the host still holds stays answerable. Only dispatch_inactive closes it locally. - The approvals stream watches only the orchestration database's own changes (Runs, Dispatches, mail), not terminal identity notices, so agent status and title changes cost it nothing in main. - Receipts are the chat's history: no 30-minute window, bounded by 100 rows with still-open prompts kept first. - The pinned stack is capped against the pane and gives way first, so the chat's own prompt keeps its room; a prompt that closes while shown stays pinned as its receipt for 4 s, and one only the worker's terminal can answer stays pinned. - A close no one named, after the worker's Dispatch ended, reads as worker-ended, and an unanswered close of an ended worker sends the coordinator no second notice. - The transcript's receipts keep one array until a receipt changes. * refactor(native-chat): a worker approval card waits on the host after a click instead of answering ahead of it Both buttons turn off and the clicked one shows a spinner until the answer returns; the host's list then turns the card into its receipt. Drops the client-side close and its reconciliation. * fix(native-chat): let the compiler memoize the worker approval answer handler (cherry picked from commit b8950a4f6631864679e86b6b46fd8babbfaa32a3) --- .../orca-runtime-agent-transitions.ts | 8 +- .../orchestration/crew/crew-party-snapshot.ts | 2 +- .../runtime/orchestration/crew/crew-query.ts | 76 +++-- .../orchestration/crew/crew-source-inputs.ts | 7 +- .../crew/crew-worker-approvals.test.ts | 73 ++++- .../crew/worker-approval-stream.test.ts | 58 ++++ .../crew/worker-approval-stream.ts | 102 +++++++ .../claude-tool-result-close.test.ts | 36 +++ .../approvals/claude-tool-result-close.ts | 91 ++++-- .../terminal-worker-approval-hold.ts | 10 +- .../terminal-worker-approval-holds.test.ts | 230 +++++++++++++--- .../terminal-worker-approval-holds.ts | 88 +++--- .../approvals/worker-approval-report.ts | 2 +- .../workers/approvals/worker-approval.ts | 27 +- .../turn-stops/terminal-worker-turn-stops.ts | 25 +- .../turn-stops/worker-turn-stop-report.ts | 14 +- .../turn-stops/worker-turn-stops.test.ts | 2 +- .../rpc/methods/orchestration/crew-methods.ts | 98 ++++--- .../worker/worker-approval-answer.ts | 2 +- .../terminal/wait/claude-open-dialog-hold.ts | 5 +- .../persisted-surfaces/crew-operations.ts | 48 +++- .../worker-approval-stream-wakes.test.ts | 36 +++ .../native-chat/NativeChatMessageList.tsx | 9 +- .../NativeChatStructuredSession.tsx | 68 +++-- .../NativeChatMessageList.timed-rows.test.tsx | 62 +++++ .../slots/native-chat-timed-rows.ts | 65 +++++ .../use-native-chat-transcript-row-context.ts | 2 +- .../messages/rows/NativeChatTranscriptRow.tsx | 6 + .../prompts/NativeChatApprovalCard.tsx | 28 +- .../NativeChatTranscriptItems.tsx | 17 +- .../NativeChatWorkerApprovals.fixture.tsx | 244 +++++++++++------ .../NativeChatWorkerApprovals.test.tsx | 86 ++++++ .../NativeChatWorkerApprovals.tsx | 259 ++++++++++-------- .../native-chat-worker-approval-feed.test.ts | 93 +++++++ .../native-chat-worker-approval-feed.ts | 215 +++++++++++++++ .../worker-approval-card-model.ts | 8 +- .../src/i18n/en-runtime-required.json | 2 - src/renderer/src/i18n/locales/en.json | 8 +- .../approvals/worker-approval-payload.ts | 22 +- .../orchestration/orchestration-crew.ts | 28 +- .../rpc-params-catalog.generated.ts | 6 +- 41 files changed, 1805 insertions(+), 463 deletions(-) create mode 100644 src/main/runtime/orchestration/crew/worker-approval-stream.test.ts create mode 100644 src/main/runtime/orchestration/crew/worker-approval-stream.ts create mode 100644 src/main/runtime/orchestration/workers/approvals/claude-tool-result-close.test.ts create mode 100644 src/main/runtime/workspaces/persisted-surfaces/worker-approval-stream-wakes.test.ts create mode 100644 src/renderer/src/components/native-chat/conversation/slots/NativeChatMessageList.timed-rows.test.tsx create mode 100644 src/renderer/src/components/native-chat/conversation/slots/native-chat-timed-rows.ts create mode 100644 src/renderer/src/components/native-chat/worker-approvals/NativeChatWorkerApprovals.test.tsx create mode 100644 src/renderer/src/components/native-chat/worker-approvals/native-chat-worker-approval-feed.test.ts create mode 100644 src/renderer/src/components/native-chat/worker-approvals/native-chat-worker-approval-feed.ts diff --git a/src/main/runtime/construction/orca-runtime-agent-transitions.ts b/src/main/runtime/construction/orca-runtime-agent-transitions.ts index 6e4772d6a3a..4700e65ad43 100644 --- a/src/main/runtime/construction/orca-runtime-agent-transitions.ts +++ b/src/main/runtime/construction/orca-runtime-agent-transitions.ts @@ -16,7 +16,7 @@ import { TerminalWorkerTurnStops } from '../orchestration/workers/turn-stops/terminal-worker-turn-stops' import { TerminalWorkerApprovalHolds } from '../orchestration/workers/approvals/terminal-worker-approval-holds' -import { readClaudeToolResult } from '../orchestration/workers/approvals/claude-tool-result-close' +import { readClaudeToolRecord } from '../orchestration/workers/approvals/claude-tool-result-close' import type { WorkerTerminalResourceRow } from '../orchestration/terminal-authority/release/worker-terminal-ownership' import { resolveStructuredWorkerIdentity } from '../orchestration/terminal-authority/structured-sessions/structured-worker-authority' import { @@ -84,7 +84,7 @@ export abstract class OrcaRuntimeWithAgentTransitions extends OrcaRuntimeWithWin return process.platform !== 'win32' && pty !== null && pty.connectionId === null && !pty.isWsl }, processIncarnation: (handle) => this.getTerminalProcessIncarnation(handle), - readToolResult: (call) => readClaudeToolResult(call.transcriptPath, call.toolUseId), + readToolRecord: (call) => readClaudeToolRecord(call.transcriptPath, call.toolUseId), readScreen: (paneKey) => { const ptyId = this.getPtyRecordForPaneKey(paneKey)?.ptyId return ptyId ? (this.readCaughtUpRuledScreen(ptyId)?.lines ?? null) : null @@ -99,8 +99,8 @@ export abstract class OrcaRuntimeWithAgentTransitions extends OrcaRuntimeWithWin readHookRow: (paneKey) => this.agentTransitions.latestRow(paneKey), setTimer: unrefTimer, readScreen: (handle) => this.readTerminal(handle, { screen: true, limit: 15 }), - takeOpenApproval: (paneKey, dispatchId) => - this.terminalWorkerApprovals.takeOpenApproval(paneKey, dispatchId) + takeOpenApproval: (paneKey, dispatchId, reporting) => + this.terminalWorkerApprovals.takeOpenApproval(paneKey, dispatchId, reporting) }) private readonly externalConversations = installExternalConversations(this.store, this) diff --git a/src/main/runtime/orchestration/crew/crew-party-snapshot.ts b/src/main/runtime/orchestration/crew/crew-party-snapshot.ts index 0bb50fedcf2..3559822f7d9 100644 --- a/src/main/runtime/orchestration/crew/crew-party-snapshot.ts +++ b/src/main/runtime/orchestration/crew/crew-party-snapshot.ts @@ -206,7 +206,7 @@ export function buildCrewSnapshot( } const snapshot = emptyCrew('ok') const approvals = Map.groupBy( - host.sourceInputs.approvals(selfAliases(), now), + host.sourceInputs.approvals(selfAliases()), ({ approval }) => approval.worker.dispatchId ) for (const { assignment, worker, parent } of host.relations.get(self.address) ?? []) { diff --git a/src/main/runtime/orchestration/crew/crew-query.ts b/src/main/runtime/orchestration/crew/crew-query.ts index f9728517fbb..e6eadeb1a40 100644 --- a/src/main/runtime/orchestration/crew/crew-query.ts +++ b/src/main/runtime/orchestration/crew/crew-query.ts @@ -4,7 +4,10 @@ import type { OrchestrationCoordinatorKey } from '../addressing/orchestration-ca import type { OrchestrationDb } from '../db/orchestration-db' import { exposeUtcTimestamp } from '../db/utc-timestamp' import { currentRunCoordinatorOrcaSessionIdSql } from '../db/runs/run-coordinator-orca-session' -import type { WorkerApprovalPayload } from '../../../../shared/orchestration/approvals/worker-approval-payload' +import { + closedApproval, + type WorkerApprovalPayload +} from '../../../../shared/orchestration/approvals/worker-approval-payload' import { readApprovalReport } from '../workers/approvals/worker-approval-report' const nullable = z.string().nullable() @@ -133,18 +136,32 @@ export function readCrewTraffic( ) } -// Why a bound: one coordinator's open and recently closed approvals, newest report each. +const WORKER_ENDED = { + by: 'worker-ended', + decision: null, + reason: null, + reasonDelivered: false +} as const + +// Why a bound: one coordinator's approvals, the still-open ones first, then the newest receipts. const CREW_APPROVAL_ROWS = 100 -/** Each worker approval's newest report to this party: open ones, and ones closed since `closedSince`. - * Only Orca's own stop reports count, never a payload a worker sent itself. Oldest first. */ +/** Each worker approval's newest report to this party, oldest first: receipts are the chat's + * history, so they stay. Only Orca's own stop reports count, never a payload a worker sent itself. */ export function readCrewApprovals( db: OrchestrationDb, - aliases: string[], - closedSince: string -): { approval: WorkerApprovalPayload; at: string }[] { + aliases: string[] +): { approval: WorkerApprovalPayload; at: string; askedAt: string }[] { const rows = z - .object({ id: z.string(), payload: z.string(), created_at: z.string() }) + .object({ + id: z.string(), + payload: z.string(), + created_at: z.string(), + asked_at: z.string(), + asked_sequence: z.number(), + ended: z.number(), + ended_at: z.string() + }) .array() .parse( db.db @@ -153,22 +170,43 @@ export function readCrewApprovals( FROM messages WHERE to_handle IN (SELECT value FROM json_each(?)) AND id LIKE 'msg\\_stop\\_%' ESCAPE '\\' AND payload LIKE '%"approval":%' AND json_valid(payload) AND json_type(payload, '$.approval') = 'object' - ), newest AS (SELECT approval_id, MAX(sequence) AS sequence FROM reports GROUP BY approval_id) - SELECT reports.id, reports.payload, reports.created_at FROM reports - JOIN newest ON newest.sequence = reports.sequence - WHERE json_extract(reports.payload, '$.approval.state') = 'open' - OR julianday(reports.created_at) >= julianday(?) - ORDER BY reports.sequence DESC LIMIT ${CREW_APPROVAL_ROWS}`) - .all(JSON.stringify(aliases), closedSince) + ), newest AS (SELECT approval_id, MAX(sequence) AS sequence, MIN(created_at) AS asked_at, + MIN(sequence) AS asked_sequence + FROM reports GROUP BY approval_id) + SELECT reports.id, reports.payload, reports.created_at, newest.asked_at, newest.asked_sequence, + d.status IS NOT NULL AND d.status NOT IN ('pending', 'dispatched') AS ended, + COALESCE(d.completed_at, reports.created_at) AS ended_at + FROM reports JOIN newest ON newest.sequence = reports.sequence + LEFT JOIN dispatch_contexts d ON d.id = json_extract(reports.payload, '$.approval.worker.dispatchId') + -- The bound never hides one still waiting on an answer. + ORDER BY (json_extract(reports.payload, '$.approval.state') = 'open' + AND (d.status IS NULL OR d.status IN ('pending', 'dispatched'))) DESC, + reports.sequence DESC + LIMIT ${CREW_APPROVAL_ROWS}`) + .all(JSON.stringify(aliases)) ) - const shown: { approval: WorkerApprovalPayload; at: string }[] = [] + .toSorted((a, b) => a.asked_sequence - b.asked_sequence) + const shown: { approval: WorkerApprovalPayload; at: string; askedAt: string }[] = [] for (const row of rows) { const approval = readApprovalReport(row) - if (approval) { - shown.push({ approval, at: exposeUtcTimestamp(row.created_at) ?? row.created_at }) + if (!approval) { + continue } + // A prompt is answerable only while its Dispatch runs: once that ends it is closed, and a + // terminal that is gone, or a close no one named, was the worker ending. + const ended = + row.ended === 1 && + (approval.state === 'open' || + approval.outcome?.by === 'terminal-only' || + approval.outcome?.by === 'unknown') + const at = ended ? row.ended_at : row.created_at + shown.push({ + approval: ended ? closedApproval(approval, WORKER_ENDED) : approval, + at: exposeUtcTimestamp(at) ?? at, + askedAt: exposeUtcTimestamp(row.asked_at) ?? row.asked_at + }) } - return shown.toReversed() + return shown } export function readCrewQuestions(db: OrchestrationDb, aliases: string[]) { diff --git a/src/main/runtime/orchestration/crew/crew-source-inputs.ts b/src/main/runtime/orchestration/crew/crew-source-inputs.ts index 08d71330ce6..b88e8022165 100644 --- a/src/main/runtime/orchestration/crew/crew-source-inputs.ts +++ b/src/main/runtime/orchestration/crew/crew-source-inputs.ts @@ -222,12 +222,9 @@ export function createCrewSourceInputs(db: OrchestrationDb | null, capacity = () const input = mailbox(aliases) return (input.questions ??= db ? readCrewQuestions(db, aliases) : []) } - // Closed approvals stay as receipts for as long as traffic counts as recent. - const approvals = (aliases: string[], now: number) => { + const approvals = (aliases: string[]) => { const input = mailbox(aliases) - return (input.approvals ??= db - ? readCrewApprovals(db, aliases, new Date(now - AGENT_STATUS_STALE_AFTER_MS).toISOString()) - : []) + return (input.approvals ??= db ? readCrewApprovals(db, aliases) : []) } const invalidateTraffic = (addresses?: ReadonlySet) => { for (const [key, input] of mail) { diff --git a/src/main/runtime/orchestration/crew/crew-worker-approvals.test.ts b/src/main/runtime/orchestration/crew/crew-worker-approvals.test.ts index e75243819e0..5ee01ca8dc0 100644 --- a/src/main/runtime/orchestration/crew/crew-worker-approvals.test.ts +++ b/src/main/runtime/orchestration/crew/crew-worker-approvals.test.ts @@ -3,7 +3,7 @@ import { fixture } from './crew-read-model.test-fixture' import { buildCrewSnapshot } from './crew-party-snapshot' import { approvalReportId } from '../workers/approvals/worker-approval-report' -it("puts each approval's newest report on its worker's row, drops stale receipts, and ignores rows Orca did not write", () => { +it("puts each approval's newest report on its worker's row, keeps old receipts, and ignores rows Orca did not write", () => { const { db, deps, run, assign } = fixture() const dispatch = assign('term_worker') const send = (approvalId: string, state: 'open' | 'answered', own = true) => @@ -43,7 +43,9 @@ it("puts each approval's newest report on its worker's row, drops stale receipts send('apr_open', 'answered', false) const [row] = buildCrewSnapshot('term_coord', deps).sections.managing + // Receipts are the chat's history: one closed hours ago stays. expect(row.approvals?.map(({ approval }) => [approval.approvalId, approval.state])).toEqual([ + ['apr_old', 'answered'], ['apr_answered', 'answered'], ['apr_open', 'open'] ]) @@ -81,5 +83,72 @@ it('keeps showing an open approval behind more closed ones than the row bound', .run('apr_still_open') const [row] = buildCrewSnapshot('term_coord', deps).sections.managing - expect(row.approvals?.map(({ approval }) => approval.approvalId)).toEqual(['apr_still_open']) + const ids = row.approvals?.map(({ approval }) => approval.approvalId) + expect(ids).toHaveLength(100) + expect(ids?.[0]).toBe('apr_still_open') + expect(ids?.at(-1)).toBe('apr_149') +}) + +it('closes an open approval once its Dispatch stops running, at the time it ended', () => { + const { db, deps, run, assign } = fixture() + const dispatch = assign('term_worker') + db.insertMessage({ + id: approvalReportId(dispatch.id, 'apr_open', 'open'), + from: 'term_worker', + to: `run:${run.id}`, + subject: 'apr_open', + type: 'escalation', + runId: run.id, + payload: JSON.stringify({ + approval: { + v: 1, + approvalId: 'apr_open', + state: 'open', + worker: { handle: 'term_worker', dispatchId: dispatch.id, taskId: dispatch.task_id }, + summary: { title: 'Allow Bash?', detail: null, reason: null }, + allowedActions: ['allow', 'deny'], + expiresAt: '2099-01-01T00:00:00.000Z' + } + }) + }) + db.completeDispatch(dispatch.id) + + const [row] = buildCrewSnapshot('term_coord', deps).sections.managing + expect(row.approvals?.map(({ approval }) => approval)).toEqual([ + expect.objectContaining({ + approvalId: 'apr_open', + state: 'answered', + allowedActions: [], + outcome: { by: 'worker-ended', decision: null, reason: null, reasonDelivered: false } + }) + ]) + expect(row.approvals?.[0].approval.expiresAt).toBeUndefined() +}) + +it('reads a close no one named, after its Dispatch ended, as the worker ending', () => { + const { db, deps, run, assign } = fixture() + const dispatch = assign('term_worker') + db.insertMessage({ + id: approvalReportId(dispatch.id, 'apr_unnamed', 'closed'), + from: 'term_worker', + to: `run:${run.id}`, + subject: 'apr_unnamed', + type: 'status', + runId: run.id, + payload: JSON.stringify({ + approval: { + v: 1, + approvalId: 'apr_unnamed', + state: 'answered', + worker: { handle: 'term_worker', dispatchId: dispatch.id, taskId: dispatch.task_id }, + summary: { title: 'Allow Bash?', detail: null, reason: null }, + allowedActions: [], + outcome: { by: 'unknown', decision: null, reason: null, reasonDelivered: false } + } + }) + }) + db.completeDispatch(dispatch.id) + + const [row] = buildCrewSnapshot('term_coord', deps).sections.managing + expect(row.approvals?.map(({ approval }) => approval.outcome?.by)).toEqual(['worker-ended']) }) diff --git a/src/main/runtime/orchestration/crew/worker-approval-stream.test.ts b/src/main/runtime/orchestration/crew/worker-approval-stream.test.ts new file mode 100644 index 00000000000..13ce7e6913d --- /dev/null +++ b/src/main/runtime/orchestration/crew/worker-approval-stream.test.ts @@ -0,0 +1,58 @@ +import { expect, it } from 'vitest' +import { subscribeWorkerApprovals } from './worker-approval-stream' +import type { CrewInvalidation } from './crew-changes' +import type { + OrchestrationCrewRow, + OrchestrationWorkerApprovalsFrame +} from '../../../../shared/orchestration/orchestration-crew' + +const approval = { + v: 1 as const, + approvalId: 'apr_1', + state: 'open' as const, + worker: { handle: 'term_w', dispatchId: 'ctx_1', taskId: 'task_1' }, + summary: { title: 'Allow Bash?', detail: null, reason: null }, + allowedActions: ['allow' as const, 'deny' as const] +} + +it("delivers a worker's prompt mailed to a Run the chat started coordinating after it subscribed", async () => { + const runs = ['run:a'] + const mail = new Map() + const worker: OrchestrationCrewRow = { + partyKey: 'w', + role: 'worker', + label: 'try-claude', + agentKind: 'claude', + status: 'blocked' + } + let wake: (facets: CrewInvalidation) => void = () => {} + const frames: OrchestrationWorkerApprovalsFrame[] = [] + subscribeWorkerApprovals( + { + mailboxes: () => ['orca_session_id:chat', ...runs], + approvals: (mailboxes) => mailboxes.flatMap((mailbox) => mail.get(mailbox) ?? []), + workers: () => (mail.size ? [{ ...worker, approvals: [{ approval, at: 't1' }] }] : []), + watch: (listener) => { + wake = listener + return () => {} + } + }, + (frame) => frames.push(frame) + ) + const settle = () => new Promise((resolve) => setImmediate(resolve)) + + runs.push('run:b') + wake(new Set(['topology'])) + await settle() + mail.set('run:b', [approval]) + wake(Object.assign(new Set(['traffic'] as const), { trafficAddresses: new Set(['run:b']) })) + await settle() + + expect(frames).toEqual([ + { type: 'begin' }, + { type: 'complete' }, + { type: 'begin' }, + { type: 'approval', entry: { approval, at: 't1', worker } }, + { type: 'complete' } + ]) +}) diff --git a/src/main/runtime/orchestration/crew/worker-approval-stream.ts b/src/main/runtime/orchestration/crew/worker-approval-stream.ts new file mode 100644 index 00000000000..d71e8b53815 --- /dev/null +++ b/src/main/runtime/orchestration/crew/worker-approval-stream.ts @@ -0,0 +1,102 @@ +import type { CrewInvalidation } from './crew-changes' +import type { + OrchestrationCrewRow, + OrchestrationWorkerApprovalEntry, + OrchestrationWorkerApprovalsFrame +} from '../../../../shared/orchestration/orchestration-crew' + +export type WorkerApprovalStreamSources = { + /** The mailboxes the party's workers report to; re-read only when topology changes. */ + mailboxes: () => string[] + /** The approval rows in those mailboxes, compared to tell whether anything changed. */ + approvals: (mailboxes: string[]) => unknown[] + /** The party's workers, each with its approvals; read only once the approval rows changed. */ + workers: () => readonly OrchestrationCrewRow[] + watch: (wake: (facets: CrewInvalidation) => void) => () => void +} + +/** A chat's worker approvals: woken by its own mail and Run changes, never by agent status, so an + * agent's turn costs a chat nothing; the crew is read only when the approvals themselves change. */ +export function subscribeWorkerApprovals( + sources: WorkerApprovalStreamSources, + emit: (frame: OrchestrationWorkerApprovalsFrame) => void +): () => void { + let alive = true + let queued = false + let mailboxes: Set | undefined + // Mail arrived for the party since the last read; a first read has everything to read. + let mailed = true + let previous: string | undefined + let readMailboxes: string | undefined + const publish = () => { + if (!alive) { + return + } + let entries: OrchestrationWorkerApprovalEntry[] + try { + mailboxes ??= new Set(sources.mailboxes()) + const key = [...mailboxes].join('\n') + // A Run or Dispatch change matters only to listed approvals or to the mailboxes it moves; + // new approvals arrive as mail. + if (!mailed && key === readMailboxes && previous === '[]') { + return + } + mailed = false + readMailboxes = key + const rows = mailboxes.size ? sources.approvals([...mailboxes]) : [] + const serialized = JSON.stringify(rows) + if (serialized === previous) { + return + } + previous = serialized + entries = rows.length ? approvalEntries(sources.workers()) : [] + } catch { + // Read again on the next change rather than show a partial list. + mailboxes = undefined + mailed = true + previous = undefined + readMailboxes = undefined + return + } + emit({ type: 'begin' }) + for (const entry of entries) { + emit({ type: 'approval', entry }) + } + emit({ type: 'complete' }) + } + const unwatch = sources.watch((facets) => { + const addressed = facets.has('traffic') ? facets.trafficAddresses : undefined + if (addressed) { + if (mailboxes && ![...addressed].some((address) => mailboxes!.has(address))) { + return + } + mailed = true + } else if (facets.has('topology') || facets.has('traffic')) { + // Runs, Dispatches or routing moved: Orca's approval reports are only ever inserted, addressed. + mailboxes = undefined + } else { + return + } + if (queued) { + return + } + queued = true + queueMicrotask(() => { + queued = false + publish() + }) + }) + publish() + return () => { + alive = false + unwatch() + } +} + +function approvalEntries( + workers: readonly OrchestrationCrewRow[] +): OrchestrationWorkerApprovalEntry[] { + return workers + .flatMap(({ approvals, ...worker }) => (approvals ?? []).map((entry) => ({ ...entry, worker }))) + .sort((a, b) => (a.askedAt ?? a.at).localeCompare(b.askedAt ?? b.at)) +} diff --git a/src/main/runtime/orchestration/workers/approvals/claude-tool-result-close.test.ts b/src/main/runtime/orchestration/workers/approvals/claude-tool-result-close.test.ts new file mode 100644 index 00000000000..d956e5ad6b0 --- /dev/null +++ b/src/main/runtime/orchestration/workers/approvals/claude-tool-result-close.test.ts @@ -0,0 +1,36 @@ +import { mkdtemp, rm, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import path from 'node:path' +import { afterEach, expect, it } from 'vitest' +import { claudeTookHookAnswer, readClaudeToolRecord } from './claude-tool-result-close' + +let dir: string | null = null +afterEach(async () => { + if (dir) { + await rm(dir, { recursive: true, force: true }) + } + dir = null +}) + +it("takes an allowed call whose command then failed as Orca's allow, from Claude's own transcript", async () => { + dir = await mkdtemp(path.join(tmpdir(), 'claude-tool-record-')) + const transcript = path.join(dir, 'session.jsonl') + // The lines Claude 2.1.322 wrote for the owner's live case (2026-11-11), trimmed to what is read. + await writeFile( + transcript, + [ + '{"type":"attachment","attachment":{"type":"hook_permission_decision","decision":"allow","toolUseID":"toolu_live","hookEvent":"PermissionRequest"}}', + '{"type":"attachment","attachment":{"type":"hook_success","hookEvent":"PostToolUseFailure","toolUseID":"toolu_live"}}', + '{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"toolu_live","is_error":true,"content":"Exit code 1\\n(eval):14: parse error near `\\\\n\'"}]}}' + ].join('\n') + ) + + const record = await readClaudeToolRecord(transcript, 'toolu_live') + expect(record).toEqual({ + hookDecision: 'allow', + result: { isError: true, text: "Exit code 1\n(eval):14: parse error near `\\n'" } + }) + expect(claudeTookHookAnswer(record!, 'allow', 'use a script file')).toBe(true) + expect(claudeTookHookAnswer(record!, 'deny', 'use a script file')).toBe(false) + expect(await readClaudeToolRecord(transcript, 'toolu_other')).toBeNull() +}) diff --git a/src/main/runtime/orchestration/workers/approvals/claude-tool-result-close.ts b/src/main/runtime/orchestration/workers/approvals/claude-tool-result-close.ts index 87917fd77b6..a7d84e5c37d 100644 --- a/src/main/runtime/orchestration/workers/approvals/claude-tool-result-close.ts +++ b/src/main/runtime/orchestration/workers/approvals/claude-tool-result-close.ts @@ -1,10 +1,17 @@ -/** How Claude closed a permission prompt, from the tool_result its transcript records for that tool - * call (probe 2026-11-10, Claude 2.1.322): a hook's deny message verbatim, the user's No, the 2:00 - * safety-check block, or the command's own output. Hook events do not say this: a deny or a No - * fires no PostToolUse or PostToolUseFailure. */ +/** How Claude closed a permission prompt, from what its transcript records for that tool call + * (probes 2026-11-10/11, Claude 2.1.322): the hook decision it took, written as soon as it takes + * it, and the tool_result: a hook's deny message verbatim, the user's No, the 2:00 safety-check + * block, or the command's own output, which is an error when an allowed command fails. Hook events + * do not say this: a deny or a No fires no PostToolUse or PostToolUseFailure. */ import { open, stat, type FileHandle } from 'node:fs/promises' +import type { WorkerApprovalOutcome } from '../../../../../shared/orchestration/approvals/worker-approval-payload' export type ClaudeToolResult = { isError: boolean; text: string } +/** What the transcript holds for one call so far: the hook decision Claude took, then its result. */ +export type ClaudeToolRecord = { + hookDecision: 'allow' | 'deny' | null + result: ClaudeToolResult | null +} export type ClaudeToolClose = 'hook-denied' | 'user-denied' | 'auto-denied' | 'ran' | 'other' // Why a tail: the newest tool call's result is at the end of a transcript that can be many MB. @@ -12,11 +19,12 @@ const TAIL_BYTES = 512 * 1024 const USER_DENIED = "The user doesn't want to proceed with this tool use" const AUTO_DENIED = 'denied by a built-in Claude Code safety check' -/** Null unless the path is a regular file: a FIFO or device would never finish a read. */ -export async function readClaudeToolResult( +/** Null until the transcript holds either for this call, or unless the path is a regular file: a FIFO + * or device would never finish a read. */ +export async function readClaudeToolRecord( transcriptPath: string, toolUseId: string -): Promise { +): Promise { let file: FileHandle | null = null try { // Why stat before open: opening a FIFO waits for a writer. @@ -32,14 +40,13 @@ export async function readClaudeToolResult( length, stats.size - length ) - const lines = buffer.subarray(0, bytesRead).toString('utf8').split('\n') - for (const line of lines.toReversed()) { - const result = line.includes(toolUseId) ? toolResultIn(line, toolUseId) : null - if (result) { - return result - } + const record: ClaudeToolRecord = { hookDecision: null, result: null } + for (const line of buffer.subarray(0, bytesRead).toString('utf8').split('\n')) { + const entry = line.includes(toolUseId) ? parseLine(line) : null + record.hookDecision ??= hookDecisionIn(entry, toolUseId) + record.result ??= toolResultIn(entry, toolUseId) } - return null + return record.hookDecision || record.result ? record : null } catch { return null } finally { @@ -47,13 +54,28 @@ export async function readClaudeToolResult( } } -function toolResultIn(line: string, toolUseId: string): ClaudeToolResult | null { - let entry: unknown +function parseLine(line: string): unknown { try { - entry = JSON.parse(line) + return JSON.parse(line) } catch { return null } +} + +/** `{type: 'attachment', attachment: {type: 'hook_permission_decision', decision, toolUseID}}`. */ +function hookDecisionIn(entry: unknown, toolUseId: string): 'allow' | 'deny' | null { + const attachment = isRecord(entry) && isRecord(entry.attachment) ? entry.attachment : null + if ( + attachment?.type !== 'hook_permission_decision' || + attachment.toolUseID !== toolUseId || + (attachment.decision !== 'allow' && attachment.decision !== 'deny') + ) { + return null + } + return attachment.decision +} + +function toolResultIn(entry: unknown, toolUseId: string): ClaudeToolResult | null { const content = isRecord(entry) && isRecord(entry.message) ? entry.message.content : null if (!Array.isArray(content)) { return null @@ -94,3 +116,38 @@ export function claudeToolClose(result: ClaudeToolResult, ourDeny: string | null } return result.text.includes(AUTO_DENIED) ? 'auto-denied' : 'other' } + +/** Whether Claude took Orca's hook answer for this call. Its record of the hook decision says so + * outright, before the tool even runs; without one (an older Claude), only a result that answer + * alone gives: our deny text, or, after an allow, anything but a person's No or the auto-block, + * since an allowed command that fails records an error result too. */ +export function claudeTookHookAnswer( + record: ClaudeToolRecord, + decision: 'allow' | 'deny', + denyMessage: string +): boolean { + if (record.hookDecision) { + return record.hookDecision === decision + } + if (!record.result) { + return false + } + const close = claudeToolClose(record.result, decision === 'deny' ? denyMessage : null) + return decision === 'deny' ? close === 'hook-denied' : close === 'ran' || close === 'other' +} + +// How each tool_result names a close Orca did not make; null says no more than "closed". +const CLOSE_HOW: Record | null> = { + ran: { by: 'worker-terminal', decision: 'allow' }, + 'user-denied': { by: 'worker-terminal', decision: 'deny' }, + 'auto-denied': { by: 'auto', decision: 'deny' }, + 'hook-denied': null, + other: null +} + +/** Who closed a prompt Orca did not answer, from this call's result; null when it names no one. */ +export function claudeToolCloseHow( + result: ClaudeToolResult | null +): Pick | null { + return result ? CLOSE_HOW[claudeToolClose(result, null)] : null +} diff --git a/src/main/runtime/orchestration/workers/approvals/terminal-worker-approval-hold.ts b/src/main/runtime/orchestration/workers/approvals/terminal-worker-approval-hold.ts index 0b8e9f992d9..c1d9750a09e 100644 --- a/src/main/runtime/orchestration/workers/approvals/terminal-worker-approval-hold.ts +++ b/src/main/runtime/orchestration/workers/approvals/terminal-worker-approval-hold.ts @@ -3,7 +3,7 @@ import type { ClaudePermissionHookChannel } from '../../../../agent-hooks/server import type { OrchestrationDb } from '../../db/orchestration-db' import type { DispatchContextRow } from '../../db/orchestration-records' import type { WorkerTurnStopReportDeps } from '../turn-stops/worker-turn-stop-report' -import type { ClaudeToolResult } from './claude-tool-result-close' +import type { ClaudeToolRecord } from './claude-tool-result-close' import type { WorkerApprovalOutcome, WorkerApprovalPayload @@ -20,11 +20,11 @@ export type TerminalWorkerApprovalHoldsDeps = Pick string | null /** The pane's screen once it has applied every PTY chunk; null while it lags or is unreadable. */ readScreen: (paneKey: string) => readonly string[] | null - /** The tool_result Claude's transcript records for this tool call, once written. */ - readToolResult: (call: { + /** The hook decision and tool_result Claude's transcript records for this tool call, once written. */ + readToolRecord: (call: { transcriptPath: string toolUseId: string - }) => Promise + }) => Promise now: () => number setTimer: (run: () => void, delayMs: number) => { cancel: () => void } } @@ -45,7 +45,7 @@ export type TerminalWorkerApprovalHold = { dialogSeen: boolean /** Its card already closed; the tool's result may still name how, without waking anyone. */ refinable: boolean - /** Its PostToolUse arrived while an answer was in flight: the tool ran. */ + /** Its PostToolUse or PostToolUseFailure arrived while an answer was in flight: the tool ran. */ ranSeen: boolean expiresAt?: string /** The coordinator was told about it, so it is owed one closing line. */ diff --git a/src/main/runtime/orchestration/workers/approvals/terminal-worker-approval-holds.test.ts b/src/main/runtime/orchestration/workers/approvals/terminal-worker-approval-holds.test.ts index 4537b496549..9b61f0b8767 100644 --- a/src/main/runtime/orchestration/workers/approvals/terminal-worker-approval-holds.test.ts +++ b/src/main/runtime/orchestration/workers/approvals/terminal-worker-approval-holds.test.ts @@ -14,7 +14,7 @@ import { createRootDispatch } from '../../db/root-dispatch-test-fixture' import { TerminalWorkerApprovalHolds } from './terminal-worker-approval-holds' import { closeOrphanedTerminalApprovals } from './terminal-approval-orphans' import { approvalReportId } from './worker-approval-report' -import type { ClaudeToolResult } from './claude-tool-result-close' +import type { ClaudeToolRecord, ClaudeToolResult } from './claude-tool-result-close' const PANE = makePaneKey('tab-worker', '11111111-1111-4111-8111-111111111111') const HANDLE = 'term_worker' @@ -43,6 +43,21 @@ const USER_NO: ClaudeToolResult = { isError: true, text: "The user doesn't want to proceed with this tool use. The tool use was rejected." } +const AUTO_BLOCK: ClaudeToolResult = { + isError: true, + text: 'Permission for this command was denied by a built-in Claude Code safety check, not by the user.' +} +// An allowed command that then fails (probe 2026-11-11, the owner's live case). +const FAILED: ClaudeToolResult = { + isError: true, + text: "Exit code 1\n(eval):14: parse error near `\\n'" +} +const RAN: ClaudeToolResult = { isError: false, text: '59' } +/** What the transcript holds: the hook decision Claude took, then the tool's result. */ +const record = ( + result: ClaudeToolResult | null, + hookDecision: ClaudeToolRecord['hookDecision'] = null +): ClaudeToolRecord => ({ hookDecision, result }) function setup(options: { canAnswer?: boolean } = {}) { const db = new OrchestrationDb(':memory:') @@ -56,8 +71,8 @@ function setup(options: { canAnswer?: boolean } = {}) { const screen: { lines: readonly string[] | null incarnation: string - result: ClaudeToolResult | null - } = { lines: DIALOG, incarnation: 'run-1', result: null } + record: ClaudeToolRecord | null + } = { lines: DIALOG, incarnation: 'run-1', record: null } const timers: { run: () => void; cancelled: boolean }[] = [] const holds = new TerminalWorkerApprovalHolds({ notify: vi.fn(), @@ -65,8 +80,8 @@ function setup(options: { canAnswer?: boolean } = {}) { canAnswerPane: () => options.canAnswer ?? true, processIncarnation: () => screen.incarnation, readScreen: () => screen.lines, - readToolResult: async ({ transcriptPath, toolUseId }) => - transcriptPath === '/t/session.jsonl' && toolUseId === 'tool-1' ? screen.result : null, + readToolRecord: async ({ transcriptPath, toolUseId }) => + transcriptPath === '/t/session.jsonl' && toolUseId === 'tool-1' ? screen.record : null, now: () => Date.UTC(2026, 10, 10, 12, 0, 0), setTimer: (run) => { const timer = { run, cancelled: false } @@ -90,7 +105,12 @@ function setup(options: { canAnswer?: boolean } = {}) { .getUnreadRunMailbox(run.id, 100) .filter((message) => message.subject.startsWith('Worker approval ')) const closing = () => closings().map((message) => message.body) - return { db, dispatch, screen, holds, tick, closing, closings } + const closedWith = () => + closings().map((message) => { + const { approval } = JSON.parse(message.payload ?? '{}') + return { state: approval.state, ...approval.outcome } + }) + return { db, dispatch, screen, holds, tick, closing, closings, closedWith } } function hook( @@ -127,11 +147,14 @@ function hook( } } -function postToolUse(toolUseId: string): AgentHookEventPayload { +function postToolUse( + toolUseId: string, + hookEventName: 'PostToolUse' | 'PostToolUseFailure' = 'PostToolUse' +): AgentHookEventPayload { return { paneKey: PANE, connectionId: null, - hookEventName: 'PostToolUse', + hookEventName, toolUseId, payload: { state: 'working', prompt: '', agentType: 'claude' } } @@ -140,23 +163,40 @@ function postToolUse(toolUseId: string): AgentHookEventPayload { async function opened(ctx: ReturnType, asked: ReturnType) { ctx.holds.admit(asked.request) await ctx.tick() - return ctx.holds.takeOpenApproval(PANE, ctx.dispatch.id)!.approvalId + return (await ctx.holds.takeOpenApproval(PANE, ctx.dispatch.id))!.approvalId } -const deny = (ctx: ReturnType, approvalId: string) => - ctx.holds.answer({ - dispatchId: ctx.dispatch.id, - approvalId, - decision: 'deny', - message: REASON +const answer = ( + ctx: ReturnType, + approvalId: string, + decision: 'allow' | 'deny' = 'deny' +) => ctx.holds.answer({ dispatchId: ctx.dispatch.id, approvalId, decision, message: REASON }) +const deny = (ctx: ReturnType, approvalId: string) => answer(ctx, approvalId) + +/** The dialog leaves without Orca's answer, then the lead's turn ends with `result` written. */ +async function closedInTerminal(ctx: ReturnType, result: ClaudeToolResult) { + const approvalId = await opened(ctx, hook('tool-1')) + ctx.screen.lines = AFTER + // Only until it closes awaiting a result: further ticks would fire its 10-minute fallback. + for (let i = 0; i < 80 && ctx.holds.isHeld(approvalId); i++) { + await ctx.tick() + } + ctx.screen.record = record(result) + ctx.holds.observe({ + paneKey: PANE, + connectionId: null, + hookEventName: 'Stop', + payload: { state: 'done', prompt: '', agentType: 'claude' } }) + await vi.waitFor(() => expect(ctx.closing()).toHaveLength(2)) +} describe('terminal worker approval holds', () => { it("claims a deny only from this call's tool_result, despite an older deny line on screen", async () => { const ctx = setup() const asked = hook('tool-1', () => { ctx.screen.lines = AFTER - ctx.screen.result = OURS + ctx.screen.record = record(OURS, 'deny') }) const approvalId = await opened(ctx, asked) @@ -181,32 +221,158 @@ describe('terminal worker approval holds', () => { it("closes the card when the dialog leaves, and names it from a result read on the lead's Stop", async () => { const ctx = setup() - await opened(ctx, hook('tool-1')) - ctx.screen.lines = AFTER - // Only until it closes awaiting a result: further ticks would fire its 10-minute fallback. - for (let i = 0; i < 80 && ctx.holds.takeOpenApproval(PANE, ctx.dispatch.id); i++) { - await ctx.tick() - } - ctx.screen.result = USER_NO - ctx.holds.observe({ - paneKey: PANE, - connectionId: null, - hookEventName: 'Stop', - payload: { state: 'done', prompt: '', agentType: 'claude' } - }) - await vi.waitFor(() => expect(ctx.closing()).toHaveLength(2)) + await closedInTerminal(ctx, USER_NO) // The card closed when the dialog left; the late result only names how. expect(ctx.closing()).toEqual([ expect.stringContaining('Closed without an answer Orca can name'), expect.stringContaining("Denied in the worker's terminal") ]) + // Not an expiry: only the agent's own timeout is one. + expect(ctx.closedWith()[0]).toMatchObject({ state: 'answered', by: 'unknown' }) }) - it('closes a prompt left open by an earlier run, once, when the database opens', () => { + it.each([ + ['allowed, and the command succeeds', record(RAN, 'allow')], + ['allowed, and the command fails', record(FAILED, 'allow')], + ['allowed, and the command is still running', record(null, 'allow')], + ['allowed by a Claude that records no hook decision, and the command fails', record(FAILED)] + ])("takes Orca's allow when %s", async (_, written) => { + const ctx = setup() + const asked = hook('tool-1', () => { + ctx.screen.lines = AFTER + ctx.screen.record = written + }) + const approvalId = await opened(ctx, asked) + + expect(await answer(ctx, approvalId, 'allow')).toMatchObject({ ok: true }) + expect(asked.replies).toEqual([{ behavior: 'allow' }]) + }) + + it("doesn't take Orca's allow when the person's No won the race", async () => { + const ctx = setup() + const approvalId = await opened( + ctx, + hook('tool-1', () => { + ctx.screen.lines = AFTER + ctx.screen.record = record(USER_NO) + }) + ) + + expect(await answer(ctx, approvalId, 'allow')).toMatchObject({ code: 'approval_not_open' }) + expect(ctx.closedWith()).toEqual([ + { + state: 'answered', + by: 'worker-terminal', + decision: 'deny', + reason: null, + reasonDelivered: false + } + ]) + }) + + it("names a Yes in the terminal whose command failed as allowed in the worker's terminal", async () => { + const ctx = setup() + await opened(ctx, hook('tool-1')) + ctx.screen.lines = AFTER + ctx.holds.observe(postToolUse('tool-1', 'PostToolUseFailure')) + + expect(ctx.closedWith()).toEqual([ + { + state: 'answered', + by: 'worker-terminal', + decision: 'allow', + reason: null, + reasonDelivered: false + } + ]) + }) + + it("names Claude's 2:00 auto-block as an expiry", async () => { + const ctx = setup() + await closedInTerminal(ctx, AUTO_BLOCK) + + expect(ctx.closedWith()[1]).toEqual({ + state: 'expired', + by: 'auto', + decision: 'deny', + reason: null, + reasonDelivered: false + }) + }) + + it("tells the coordinator to send the user to the terminal when the hook is gone but the dialog isn't", async () => { + const ctx = setup() + const asked = hook('tool-1') + await opened(ctx, asked) + asked.end('hook-gone') + await ctx.tick(40) + + expect(ctx.closings()).toEqual([ + expect.objectContaining({ + type: 'escalation', + body: expect.stringContaining("Tell the user to answer it in the worker's terminal") + }) + ]) + }) + + it('closes as worker ended, not "answer it in the terminal", when the worker is stopped at the prompt', async () => { + const ctx = setup() + const asked = hook('tool-1') + await opened(ctx, asked) + // A stop kills the process; its last screen still shows the dialog. + ctx.screen.incarnation = 'run-2' + asked.end('hook-gone') + await ctx.tick(40) + + expect(ctx.closedWith()).toEqual([ + { + state: 'answered', + by: 'worker-ended', + decision: null, + reason: null, + reasonDelivered: false + } + ]) + }) + + it("escalates with Claude's reason once the dialog paints, though a long command hides its box's top", async () => { + const ctx = setup() + // The live case (2026-11-11): the escalation came before the paint, and the command was so long + // that only the rule closing its box was on screen. + ctx.screen.lines = null + ctx.holds.admit(hook('tool-1').request) + const escalating = ctx.holds.takeOpenApproval(PANE, ctx.dispatch.id) + ctx.screen.lines = [ + ...Array.from({ length: 30 }, (_, line) => ` │ s=s.replace("import ${line}")`), + ' │ fs.writeFileSync(p,s)\'; rg -n "ComputerBots" BotSettingsGroups.tsx', + ' ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌', + ' │ Dangerous rm operation not ruled out — the shell may read this command differently than it was parsed', + ...DIALOG.slice(2) + ] + await ctx.tick(2) + + expect((await escalating)?.summary.reason).toBe( + 'Dangerous rm operation not ruled out — the shell may read this command differently than it was parsed' + ) + }) + + it('owes no closing line to a prompt whose escalation never went out', async () => { + const ctx = setup() + const asked = hook('tool-1') + ctx.holds.admit(asked.request) + // The worker resumed while the escalation waited for the dialog, so no report was sent. + expect(await ctx.holds.takeOpenApproval(PANE, ctx.dispatch.id, () => false)).toBeNull() + asked.end('hook-gone') + await ctx.tick(40) + + expect(ctx.closings()).toEqual([]) + }) + + it('closes a prompt left open by an earlier run, once, when the database opens', async () => { const ctx = setup() ctx.holds.admit(hook('tool-1').request) - const approval = ctx.holds.takeOpenApproval(PANE, ctx.dispatch.id)! + const approval = (await ctx.holds.takeOpenApproval(PANE, ctx.dispatch.id))! const escalate = (id: string | undefined, carried: typeof approval) => ctx.db.insertMessage({ ...(id ? { id } : {}), diff --git a/src/main/runtime/orchestration/workers/approvals/terminal-worker-approval-holds.ts b/src/main/runtime/orchestration/workers/approvals/terminal-worker-approval-holds.ts index 4a703a89d2e..6ae36876c4f 100644 --- a/src/main/runtime/orchestration/workers/approvals/terminal-worker-approval-holds.ts +++ b/src/main/runtime/orchestration/workers/approvals/terminal-worker-approval-holds.ts @@ -13,8 +13,11 @@ import { claudeDialogWarning, showsClaudeDialog } from '../../../terminal/wait/claude-open-dialog-hold' -import { claudeToolClose } from './claude-tool-result-close' -import type { ClaudeToolClose, ClaudeToolResult } from './claude-tool-result-close' +import { + claudeTookHookAnswer, + claudeToolCloseHow, + type ClaudeToolRecord +} from './claude-tool-result-close' import { firstWithin } from './first-within' import type { TerminalWorkerApprovalAnswer, @@ -23,29 +26,23 @@ import type { TerminalWorkerApprovalHoldsDeps } from './terminal-worker-approval-hold' import { reportWorkerApprovalClosed } from '../turn-stops/worker-turn-stop-report' -import { closedApproval } from './worker-approval' -import type { - WorkerApprovalDecision, - WorkerApprovalOutcome, - WorkerApprovalPayload +import { + closedApproval, + type WorkerApprovalDecision, + type WorkerApprovalOutcome, + type WorkerApprovalPayload } from '../../../../../shared/orchestration/approvals/worker-approval-payload' import { TERMINAL_APPROVAL_ID_PREFIX } from './worker-approval-report' // Why 500 ms: Esc posts no hook, so only the screen says the dialog left; a click is refused within it. const DIALOG_POLL_MS = 500 -// How each tool_result names a close Orca did not make; null says no more than "closed". -const CLOSE_OF: Record = { - ran: { by: 'worker-terminal', decision: 'allow' }, - 'user-denied': { by: 'worker-terminal', decision: 'deny' }, - 'auto-denied': { by: 'auto', decision: 'deny' }, - 'hook-denied': null, - other: null -} // A closed prompt waits this long for its tool's result before its closing line says no more than "closed". const CLOSE_EVIDENCE_MS = 10 * 60_000 type Hold = TerminalWorkerApprovalHold type CloseHow = TerminalWorkerApprovalCloseHow +// Its tool ran, failed or not: it was allowed in the terminal. +const RAN: CloseHow = { by: 'worker-terminal', decision: 'allow' } export class TerminalWorkerApprovalHolds implements ClaudePermissionHolds { private readonly byApprovalId = new Map() @@ -107,7 +104,10 @@ export class TerminalWorkerApprovalHolds implements ClaudePermissionHolds { /** Every accepted Claude event: a tool's result says how a dialog closed. */ observe(event: AgentHookEventPayload): void { - if (event.hookEventName === 'PostToolUse' && event.toolUseId) { + // A failed command ran too: it was allowed. + const ran = + event.hookEventName === 'PostToolUse' || event.hookEventName === 'PostToolUseFailure' + if (ran && event.toolUseId) { const open = this.openByPane.get(event.paneKey) const hold = open?.toolUseId === event.toolUseId ? open : this.closingByToolUseId.get(event.toolUseId) @@ -116,7 +116,7 @@ export class TerminalWorkerApprovalHolds implements ClaudePermissionHolds { } hold.ranSeen = true if (hold.state !== 'answering') { - this.close(hold, { by: 'worker-terminal', decision: 'allow' }) + this.close(hold, RAN) } return } @@ -129,8 +129,8 @@ export class TerminalWorkerApprovalHolds implements ClaudePermissionHolds { if (hold.paneKey === event.paneKey) { // One last read: a result written late still names the close. void this.deps - .readToolResult(hold) - .then((result) => this.close(hold, result && CLOSE_OF[claudeToolClose(result, null)])) + .readToolRecord(hold) + .then((record) => this.close(hold, claudeToolCloseHow(record?.result ?? null))) } } } @@ -142,14 +142,27 @@ export class TerminalWorkerApprovalHolds implements ClaudePermissionHolds { return this.byApprovalId.has(approvalId) } - takeOpenApproval(paneKey: string, dispatchId: string): WorkerApprovalPayload | null { + /** `reporting`: whether the caller still sends its report, read last, so a close owes a closing + * line only to an approval whose escalation went out. */ + async takeOpenApproval( + paneKey: string, + dispatchId: string, + reporting: () => boolean = () => true + ): Promise { const hold = this.openByPane.get(paneKey) if (hold?.state !== 'open' || hold.dispatch.id !== dispatchId) { return null } + // The escalation can go out before the dialog paints: wait for it, for its countdown and reason. + const lines = await firstWithin(this.deps.setTimer, () => { + const screen = this.deps.readScreen(paneKey) + return screen && showsClaudeDialog(screen) ? screen : null + }) + if (hold.state !== 'open' || this.openByPane.get(paneKey) !== hold || !reporting()) { + return null + } hold.reported = true - // The escalation usually goes out before the first poll, so read the dialog here too. - this.readDialog(hold, this.deps.readScreen(paneKey)) + this.readDialog(hold, lines) return this.payload(hold) } @@ -182,13 +195,13 @@ export class TerminalWorkerApprovalHolds implements ClaudePermissionHolds { ? { behavior: 'allow' } : { behavior: 'deny', message: input.message } ) - const result = written ? await this.toolResult(hold) : null - const ours = input.decision === 'deny' ? 'hook-denied' : 'ran' - if (!result || claudeToolClose(result, input.message) !== ours || hold.state !== 'answering') { + const record = written ? await this.toolRecord(hold) : null + const taken = record ? claudeTookHookAnswer(record, input.decision, input.message) : false + if (!taken || hold.state !== 'answering') { // A quit or budget end that closed it meanwhile stays closed: the state only moves forward. if (hold.state === 'answering') { hold.state = 'open' - await this.settle(hold, result) + await this.settle(hold, record) } return notOpen } @@ -205,7 +218,7 @@ export class TerminalWorkerApprovalHolds implements ClaudePermissionHolds { const lines = this.deps.readScreen(hold.paneKey) const shown = lines ? showsClaudeDialog(lines) : null if (shown === false && hold.dialogSeen) { - void this.toolResult(hold).then((result) => this.settle(hold, result)) + void this.toolRecord(hold).then((record) => this.settle(hold, record)) return } hold.dialogSeen ||= shown === true @@ -220,24 +233,27 @@ export class TerminalWorkerApprovalHolds implements ClaudePermissionHolds { this.close(hold, null) return } - await this.settle(hold, await this.toolResult(hold)) + await this.settle(hold, await this.toolRecord(hold)) } /** Names a close from this call's tool_result; with none yet, from whether the dialog is still up. */ - private async settle(hold: Hold, result: ClaudeToolResult | null): Promise { + private async settle(hold: Hold, record: ClaudeToolRecord | null): Promise { if (hold.state !== 'open') { return } - const close = hold.ranSeen ? 'ran' : result && claudeToolClose(result, null) - if (close) { - this.close(hold, CLOSE_OF[close]) + const how = hold.ranSeen ? RAN : claudeToolCloseHow(record?.result ?? null) + if (how) { + this.close(hold, how) return } const lines = await firstWithin(this.deps.setTimer, () => this.deps.readScreen(hold.paneKey)) if (hold.state !== 'open') { return } - if (!lines || showsClaudeDialog(lines)) { + if (!this.stillBound(hold)) { + // Stopped, exited or handed on: no terminal is left to answer it in. + this.close(hold, { by: 'worker-ended', decision: null }) + } else if (!lines || showsClaudeDialog(lines)) { // The dialog is up but Orca can no longer answer it: a person must, in the terminal. this.close(hold, { by: 'terminal-only', decision: null }) } else { @@ -287,7 +303,7 @@ export class TerminalWorkerApprovalHolds implements ClaudePermissionHolds { by: how?.by ?? 'unknown', decision: how?.decision ?? null, reason: null, - reasonDelivered: true + reasonDelivered: false }) }, this.deps, @@ -314,8 +330,8 @@ export class TerminalWorkerApprovalHolds implements ClaudePermissionHolds { ) } - private toolResult(hold: Hold): Promise { - return firstWithin(this.deps.setTimer, () => this.deps.readToolResult(hold)) + private toolRecord(hold: Hold): Promise { + return firstWithin(this.deps.setTimer, () => this.deps.readToolRecord(hold)) } private payload(hold: Hold, outcome?: WorkerApprovalOutcome): WorkerApprovalPayload { diff --git a/src/main/runtime/orchestration/workers/approvals/worker-approval-report.ts b/src/main/runtime/orchestration/workers/approvals/worker-approval-report.ts index ba920641bcb..9c49dacf6c5 100644 --- a/src/main/runtime/orchestration/workers/approvals/worker-approval-report.ts +++ b/src/main/runtime/orchestration/workers/approvals/worker-approval-report.ts @@ -3,6 +3,7 @@ import { z } from 'zod' import { WorkerApprovalPayloadSchema, + closedApproval, type WorkerApprovalOutcome, type WorkerApprovalPayload } from '../../../../../shared/orchestration/approvals/worker-approval-payload' @@ -13,7 +14,6 @@ import { stopReportId, type WorkerTurnStopReportDeps } from '../turn-stops/worker-turn-stop-report' -import { closedApproval } from './worker-approval' /** A Claude terminal worker's approval id; a chat worker's is its journal item id. */ export const TERMINAL_APPROVAL_ID_PREFIX = 'apr_' diff --git a/src/main/runtime/orchestration/workers/approvals/worker-approval.ts b/src/main/runtime/orchestration/workers/approvals/worker-approval.ts index 360afdf23fb..39ae9eb75dd 100644 --- a/src/main/runtime/orchestration/workers/approvals/worker-approval.ts +++ b/src/main/runtime/orchestration/workers/approvals/worker-approval.ts @@ -5,11 +5,12 @@ import type { AgentJournalPromptOption } from '../../../../../shared/agent-session/journal/agent-session-journal-types' -import type { - WorkerApprovalAnswerer, - WorkerApprovalDecision, - WorkerApprovalOutcome, - WorkerApprovalPayload +import { + closedApproval, + type WorkerApprovalAnswerer, + type WorkerApprovalDecision, + type WorkerApprovalOutcome, + type WorkerApprovalPayload } from '../../../../../shared/orchestration/approvals/worker-approval-payload' /** The outcome of a chat prompt Orca answered: its reason is told only when it went to the worker as mail. */ @@ -90,19 +91,3 @@ export function workerApprovalPayload(input: { } return outcome ? closedApproval(open, outcome) : open } - -/** The same approval once closed: nothing left to answer, and how it closed. */ -export function closedApproval( - open: WorkerApprovalPayload, - outcome: WorkerApprovalOutcome -): WorkerApprovalPayload { - const closed: WorkerApprovalPayload = { - ...open, - state: outcome.decision === null ? 'expired' : 'answered', - allowedActions: [], - outcome - } - // A countdown means nothing once the prompt is closed. - delete closed.expiresAt - return closed -} diff --git a/src/main/runtime/orchestration/workers/turn-stops/terminal-worker-turn-stops.ts b/src/main/runtime/orchestration/workers/turn-stops/terminal-worker-turn-stops.ts index 90c5f1e54be..7e3286365f7 100644 --- a/src/main/runtime/orchestration/workers/turn-stops/terminal-worker-turn-stops.ts +++ b/src/main/runtime/orchestration/workers/turn-stops/terminal-worker-turn-stops.ts @@ -25,7 +25,12 @@ export type TerminalWorkerTurnStopsDeps = WorkerTurnStopReportDeps & { getProcessIncarnation: (handle: string) => string | null readScreen: (handle: string) => Promise /** The pane's open approval Orca can answer; taking it marks it reported. */ - takeOpenApproval: (paneKey: string, dispatchId: string) => WorkerApprovalPayload | null + /** `reporting` is read after the wait; the approval is marked reported only when it holds. */ + takeOpenApproval: ( + paneKey: string, + dispatchId: string, + reporting: () => boolean + ) => Promise } /** Report a terminal worker whose turn ended (or stopped at a prompt) while its Dispatch is open. */ @@ -71,16 +76,22 @@ export class TerminalWorkerTurnStops { .readScreen(stopped.handle) .then((view) => redactWorkerTerminalView(view).tail.join('\n')) .catch(() => undefined)) - // The read awaited: the worker may have resumed, reported, or been handed a new Dispatch since. + const before = this.stillStopped(stop) + // One report per approval; the screen shows Claude's own reason for asking. + const approval = + reason === 'needs-input' && before?.target.kind === 'local' + ? await this.deps.takeOpenApproval( + stop.paneKey, + before.target.dispatch.id, + // Read at the end of the dialog wait; a resume after it is caught by the re-read below. + () => this.stillStopped(stop) !== null + ) + : null + // Both reads awaited: the worker may have resumed, reported, or been handed a new Dispatch since. const resolved = this.stillStopped(stop) if (!resolved) { return } - // One report per approval; the screen shows Claude's own reason for asking. - const approval = - reason === 'needs-input' && resolved.target.kind === 'local' - ? this.deps.takeOpenApproval(stop.paneKey, resolved.target.dispatch.id) - : null reportWorkerTurnStop( resolved.db, resolved.target, diff --git a/src/main/runtime/orchestration/workers/turn-stops/worker-turn-stop-report.ts b/src/main/runtime/orchestration/workers/turn-stops/worker-turn-stop-report.ts index 1ca69657885..234e8dc4289 100644 --- a/src/main/runtime/orchestration/workers/turn-stops/worker-turn-stop-report.ts +++ b/src/main/runtime/orchestration/workers/turn-stops/worker-turn-stop-report.ts @@ -282,6 +282,7 @@ const CLOSED_BY: Record['by'], str 'worker-terminal': "in the worker's terminal", auto: "by the worker's agent on its own (its 2:00 timeout)", 'terminal-only': "for Orca; a person must answer it in the worker's terminal", + 'worker-ended': 'because its worker ended', unknown: 'without an answer Orca can name' } @@ -317,6 +318,12 @@ export function reportWorkerApprovalClosed( refines = false ): void { const { approval } = closed + const status = db.getDispatchContextById(dispatch.id)?.status + // Unanswered, and its worker already ended: the card reads that on its own, and the coordinator + // was told the worker ended; a second notice adds nothing. + if (!approval.outcome?.decision && status !== 'pending' && status !== 'dispatched') { + return + } escalateWorkerFailure( db, dispatch, @@ -331,12 +338,7 @@ export function reportWorkerApprovalClosed( subject: approval.outcome?.decision ? 'Worker approval answered' : 'Worker approval closed', body: describeApprovalClosed(approval) }), - payload: { - taskId: dispatch.task_id, - dispatchId: dispatch.id, - handle: closed.from, - approval - }, + payload: { taskId: dispatch.task_id, dispatchId: dispatch.id, handle: closed.from, approval }, // Only a person at the worker's terminal can answer it now: that needs the coordinator to act. ...(approval.outcome?.by === 'terminal-only' ? {} : { notice: true as const }) }, diff --git a/src/main/runtime/orchestration/workers/turn-stops/worker-turn-stops.test.ts b/src/main/runtime/orchestration/workers/turn-stops/worker-turn-stops.test.ts index 0dbd7e8cadd..013cca49ea0 100644 --- a/src/main/runtime/orchestration/workers/turn-stops/worker-turn-stops.test.ts +++ b/src/main/runtime/orchestration/workers/turn-stops/worker-turn-stops.test.ts @@ -76,7 +76,7 @@ function terminal(ctx: ReturnType, current: { row: AgentStatusIpcP }, getHandle: () => HANDLE, getProcessIncarnation: () => null, - takeOpenApproval: () => null, + takeOpenApproval: async () => null, readScreen: async () => ({ handle: HANDLE, status: 'running', diff --git a/src/main/runtime/rpc/methods/orchestration/crew-methods.ts b/src/main/runtime/rpc/methods/orchestration/crew-methods.ts index bb25a26a26a..82a962ea96c 100644 --- a/src/main/runtime/rpc/methods/orchestration/crew-methods.ts +++ b/src/main/runtime/rpc/methods/orchestration/crew-methods.ts @@ -1,45 +1,77 @@ -import { CrewSubscribeParams } from '../../../../../shared/orchestration/orchestration-crew' +import { + CrewSubscribeParams, + WorkerApprovalsSubscribeParams +} from '../../../../../shared/orchestration/orchestration-crew' import { subscribeCrew } from '../../../orchestration/crew/crew-stream' +import type { RpcContext } from '../../core' import { defineOrchestrationStreamingMethod } from './access/orchestration-method-access' let sequence = 0 +/** Run a stream until its client leaves; `start` returns the stream's stop. */ +async function streamUntilClosed( + kind: string, + { runtime, signal, connectionId }: RpcContext, + emitEnd: () => void, + start: () => () => void +): Promise { + if (signal?.aborted) { + return + } + await runtime.openAgentSessionRecordStore() + if (signal?.aborted) { + return + } + await new Promise((resolve) => { + const key = `${kind}:${connectionId ?? 'local'}:${++sequence}` + const release = () => runtime.cleanupSubscription(key) + const stop = start() + runtime.registerSubscriptionCleanup( + key, + () => { + stop() + signal?.removeEventListener('abort', release) + emitEnd() + resolve() + }, + connectionId + ) + signal?.addEventListener('abort', release, { once: true }) + if (signal?.aborted) { + release() + } + }) +} + export const ORCHESTRATION_CREW_METHODS = [ defineOrchestrationStreamingMethod({ name: 'orchestration.crewSubscribe', access: { kind: 'localOnly', targets: { party: 'party' } }, permission: 'workspace', params: CrewSubscribeParams, - handler: async ({ party }, { runtime, signal, connectionId }, emit) => { - if (signal?.aborted) { - return - } - await runtime.openAgentSessionRecordStore() - if (signal?.aborted) { - return - } - await new Promise((resolve) => { - const key = `crew:${connectionId ?? 'local'}:${++sequence}` - const release = () => runtime.cleanupSubscription(key) - const stop = subscribeCrew( - () => runtime.getOrchestrationCrewSnapshot(party), - runtime.watchOrchestrationCrew, - emit - ) - runtime.registerSubscriptionCleanup( - key, - () => { - stop() - signal?.removeEventListener('abort', release) - emit({ type: 'end' }) - resolve() - }, - connectionId - ) - signal?.addEventListener('abort', release, { once: true }) - if (signal?.aborted) { - release() - } - }) - } + handler: ({ party }, context, emit) => + streamUntilClosed( + 'crew', + context, + () => emit({ type: 'end' }), + () => + subscribeCrew( + () => context.runtime.getOrchestrationCrewSnapshot(party), + context.runtime.watchOrchestrationCrew, + emit + ) + ) + }), + defineOrchestrationStreamingMethod({ + name: 'orchestration.workerApprovalsSubscribe', + access: { kind: 'localOnly', targets: { party: 'party' } }, + permission: 'workspace', + params: WorkerApprovalsSubscribeParams, + handler: ({ party }, context, emit) => + streamUntilClosed( + 'worker-approvals', + context, + () => emit({ type: 'end' }), + () => context.runtime.subscribeOrchestrationWorkerApprovals(party, emit) + ) }) ] diff --git a/src/main/runtime/rpc/methods/orchestration/worker/worker-approval-answer.ts b/src/main/runtime/rpc/methods/orchestration/worker/worker-approval-answer.ts index 3819ce598b8..84cafe7b835 100644 --- a/src/main/runtime/rpc/methods/orchestration/worker/worker-approval-answer.ts +++ b/src/main/runtime/rpc/methods/orchestration/worker/worker-approval-answer.ts @@ -9,9 +9,9 @@ import { } from '../../../../orchestration/workers/approvals/chat-worker-approval-prompt' import { chatAnswerOutcome, - closedApproval, workerApprovalPayload } from '../../../../orchestration/workers/approvals/worker-approval' +import { closedApproval } from '../../../../../../shared/orchestration/approvals/worker-approval-payload' import { closeReportedApproval } from '../../../../orchestration/workers/approvals/worker-approval-report' import { reportWorkerApprovalClosed, diff --git a/src/main/runtime/terminal/wait/claude-open-dialog-hold.ts b/src/main/runtime/terminal/wait/claude-open-dialog-hold.ts index 8ed7a680508..c1e6226e4b1 100644 --- a/src/main/runtime/terminal/wait/claude-open-dialog-hold.ts +++ b/src/main/runtime/terminal/wait/claude-open-dialog-hold.ts @@ -74,8 +74,9 @@ export function claudeDialogWarning(lines: readonly string[] | null): string | n const rules = region .slice(0, Math.max(proceed, 0)) .flatMap((line, index) => (DASHED_RULE_RE.test(line) ? [index] : [])) - // The first rule opens the command's box, the second closes it; a warning follows the second. - if (proceed === -1 || rules.length < 2) { + // A warning follows the rule that closes the command's box: the last one. A long command + // scrolls the rule that opens the box off the screen, so only the closing one may show. + if (proceed === -1 || rules.length === 0) { return null } const warning = region diff --git a/src/main/runtime/workspaces/persisted-surfaces/crew-operations.ts b/src/main/runtime/workspaces/persisted-surfaces/crew-operations.ts index ae8621abbf0..bae2ce39d92 100644 --- a/src/main/runtime/workspaces/persisted-surfaces/crew-operations.ts +++ b/src/main/runtime/workspaces/persisted-surfaces/crew-operations.ts @@ -7,16 +7,31 @@ import { CrewReadModel } from '../../orchestration/crew/crew-read-model' import { getPublishedHostDescriptor } from '../../hosts/platform-probe/host-descriptor' import { existsSync } from 'node:fs' import type { OrchestrationDb } from '../../orchestration/db/orchestration-db' +import { CrewChanges } from '../../orchestration/crew/crew-changes' import { OrcaRuntimeWithOrchestrationDatabaseBinding } from './orchestration-database-binding' +import { subscribeWorkerApprovals } from '../../orchestration/crew/worker-approval-stream' +import { readCrewApprovals } from '../../orchestration/crew/crew-query' +import { parseOrcaSessionAddress } from '../../../../shared/orca-session-address' +import type { OrchestrationWorkerApprovalsFrame } from '../../../../shared/orchestration/orchestration-crew' export abstract class OrcaRuntimeWithCrewOperations extends OrcaRuntimeWithOrchestrationDatabaseBinding { abstract readonly agentTransitions: Pick private unwatchCrewDb: (() => void) | undefined + // Not a field initializer: a base constructor can bind the database before this class's fields run. + declare private orchestrationDbChangesSlot: CrewChanges | undefined + /** The orchestration database's own changes (Runs, Dispatches, mail), without terminal identity's. */ + private get orchestrationDbChanges(): CrewChanges { + return (this.orchestrationDbChangesSlot ??= new CrewChanges()) + } protected bindCrewChanges(db: OrchestrationDb): void { this.unwatchCrewDb?.() - this.unwatchCrewDb = db.crewChanges.subscribe(this.crewChanges.notify) + this.unwatchCrewDb = db.crewChanges.subscribe((facets) => { + this.orchestrationDbChanges.notify(facets) + this.crewChanges.notify(facets) + }) + this.orchestrationDbChanges.notify() this.crewChanges.notify() } @@ -46,4 +61,35 @@ export abstract class OrcaRuntimeWithCrewOperations extends OrcaRuntimeWithOrche } watchOrchestrationCrew = (wake: () => void) => this.crewReadModel.subscribe(wake) + + /** A chat coordinator's worker approvals: its own mailbox and its Runs', read only on their changes. */ + subscribeOrchestrationWorkerApprovals( + party: string, + emit: (frame: OrchestrationWorkerApprovalsFrame) => void + ): () => void { + const orcaSessionId = parseOrcaSessionAddress(party) + return subscribeWorkerApprovals( + { + mailboxes: () => { + const db = this._orchestrationDb + return db && orcaSessionId + ? [ + party, + ...db + .runsBoundToCoordinator({ orcaSessionId, paneKey: null, terminalHandle: null }) + .map((run) => `run:${run.id}`) + ] + : [] + }, + approvals: (mailboxes) => { + const db = this._orchestrationDb + return db ? readCrewApprovals(db, mailboxes) : [] + }, + workers: () => this.crewReadModel.read(party).sections.managing, + // Terminal identity notices (every agent status or title change) say nothing about approvals. + watch: this.orchestrationDbChanges.subscribe + }, + emit + ) + } } diff --git a/src/main/runtime/workspaces/persisted-surfaces/worker-approval-stream-wakes.test.ts b/src/main/runtime/workspaces/persisted-surfaces/worker-approval-stream-wakes.test.ts new file mode 100644 index 00000000000..c2218aac4a7 --- /dev/null +++ b/src/main/runtime/workspaces/persisted-surfaces/worker-approval-stream-wakes.test.ts @@ -0,0 +1,36 @@ +import { expect, it, vi } from 'vitest' +import { OrcaRuntimeService } from '../../orca-runtime' +import { OrchestrationDb } from '../../orchestration/db/orchestration-db' +import { isOrcaSessionId } from '../../../../shared/orca-session-address' + +const CHAT = 'claude_11111111_1111_4111_8111_111111111111' + +it("reads a chat's approvals on its own Run's changes, never on terminal identity notices", async () => { + if (!isOrcaSessionId(CHAT)) { + throw new Error('fixture id') + } + const runtime = new OrcaRuntimeService() + const db = new OrchestrationDb(':memory:') + runtime.setOrchestrationDb(db) + const runs = vi.spyOn(db, 'runsBoundToCoordinator') + const stop = runtime.subscribeOrchestrationWorkerApprovals(`orca_session_id:${CHAT}`, () => {}) + const settle = () => new Promise((resolve) => setImmediate(resolve)) + const reads = runs.mock.calls.length + + // What every agent status or tab title change sends: terminal identity's default topology notice. + for (let i = 0; i < 50; i++) { + runtime.crewChanges.notify() + await settle() + } + expect(runs.mock.calls.length - reads).toBe(0) + + db.createRun({ + objective: 'Coordinate', + coordinatorHandle: null, + coordinatorPaneKey: null, + coordinatorOrcaSessionId: CHAT + }) + await settle() + expect(runs.mock.calls.length - reads).toBe(1) + stop() +}) diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx index ceaa522136b..91f07967fda 100644 --- a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx +++ b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx @@ -38,6 +38,7 @@ import type { StructuredAgentSessionHostWork } from './session/structured/use-st import type { NativeChatDeliveryNotice } from './messages/rows/NativeChatMessageRow' import { splitNativeChatSlotsWaitingBehindLiveTurn } from './conversation/slots/native-chat-transcript-slot-selection' import { useNativeChatTranscriptSlots } from './conversation/slots/use-native-chat-transcript-slots' +import type { NativeChatTimedRow } from './conversation/slots/native-chat-timed-rows' import { useNativeChatTranscriptWindow } from './viewport/virtualization/use-native-chat-transcript-window' import { useNativeChatHistoryRetention } from './viewport/history/use-native-chat-history-retention' import { useNativeChatSubagentSections } from './subagents/use-native-chat-subagent-sections' @@ -89,7 +90,7 @@ export function NativeChatMessageList({ workingStartedAt, settledTurns, deliveryNotices, - trailing, + timedRows, awaitingInput = null, turnActivity, stopping = false, @@ -118,8 +119,8 @@ export function NativeChatMessageList({ /** Host durations by prompt id; otherwise fall back to a duration observed locally. */ settledTurns?: NativeChatSettledTurns deliveryNotices?: ReadonlyMap - /** Rows after the conversation that are not part of it, such as workers' open approvals. */ - trailing?: React.ReactNode + /** Rows that are not part of the conversation but happened during it, such as workers' approvals. */ + timedRows?: readonly NativeChatTimedRow[] /** Set while the turn waits on the reader; the live activity line yields to it. */ awaitingInput?: NativeChatAwaitingInput | null turnActivity?: NativeChatTurnActivity | null @@ -390,6 +391,7 @@ export function NativeChatMessageList({ > ) : null} - {trailing} diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx index c8adbdf51ab..deaf0714d6b 100644 --- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx +++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx @@ -75,7 +75,11 @@ import { useNativeChatHostSendGate } from '@/components/native-chat/host-access/ import { useStructuredAgentSessionStartFailureFacts } from '@/components/native-chat/messages/notices/use-structured-agent-session-start-failure-facts' import { pendingPromptsAllUnanswerableHere } from '../../../../shared/agent-session/agent-session-approval-subject' import { NativeChatHostSetupContext } from '@/components/native-chat/host-access/native-chat-host-setup' -import { useNativeChatWorkerApprovalSlots } from '@/components/native-chat/worker-approvals/NativeChatWorkerApprovals' +import { + NativeChatPartyWorkerApprovalStack, + NativeChatWorkerApprovalTimeline, + nativeChatWorkerApprovalParty +} from '@/components/native-chat/worker-approvals/NativeChatWorkerApprovals' export function NativeChatStructuredSession(props: Omit) { const ownerWorktreeId = useNativeChatTabOwnerWorktreeId(props.tabId) @@ -112,7 +116,6 @@ export function NativeChatStructuredSession(props: Omit(null) const rootRef = useRef(null) - const workerApprovals = useNativeChatWorkerApprovalSlots(props, rootRef) const historyPhase = structuredChatHistoryPhase(provisionalLaunch, controller.status) const hostOutage = useNativeChatHostOutage(props.target) const hostNotice = useNativeChatHostOutageNotice(hostOutage) @@ -127,6 +130,7 @@ export function NativeChatStructuredSession(props: Omit card.state === 'returned') || @@ -297,30 +301,34 @@ export function NativeChatStructuredSession(props: Omit - + + {(timedRows) => ( + + )} + @@ -346,8 +354,12 @@ export function NativeChatStructuredSession(props: Omit - {/* Workers' approvals stay findable even while this chat has its own prompt. */} - {workerApprovals.strip} + {/* Workers' open prompts stay pinned here, above this chat's own prompt. */} + {prompt ? null : ( + (await import('../../markdown/native-chat-unpaced-text-fixture')).unpacedTextModule( + importOriginal + ) +) + +let restore: (() => void)[] = [] +beforeEach(() => { + restore = [stubLayout({ scrollGeometry: true, offsetChain: true }), stubResizeObserver()] +}) +afterEach(() => { + cleanup() + for (const undo of restore.toReversed()) { + undo() + } + layout.measuredRowHeights = [] +}) + +it('draws a worker approval at its own time, with newer replies after it', () => { + // marker(i) is message `marker-i`, at time i + 1. + const messages = [0, 1, 2, 3].map(marker) + render( + Allow Bash? (open)

}, + { key: 'receipt', at: 1.5, node:

Allowed by you 3:11 PM

} + ]} + /> + ) + + const order = [ + 'marker-0', + 'Allowed by you 3:11 PM', + 'marker-1', + 'marker-2', + 'Allow Bash? (open)', + 'marker-3' + ].map((text) => screen.getByText(text)) + for (const [index, element] of order.slice(1).entries()) { + expect(order[index].compareDocumentPosition(element)).toBe(Node.DOCUMENT_POSITION_FOLLOWING) + } +}) diff --git a/src/renderer/src/components/native-chat/conversation/slots/native-chat-timed-rows.ts b/src/renderer/src/components/native-chat/conversation/slots/native-chat-timed-rows.ts new file mode 100644 index 00000000000..d134e0a97c1 --- /dev/null +++ b/src/renderer/src/components/native-chat/conversation/slots/native-chat-timed-rows.ts @@ -0,0 +1,65 @@ +/** Rows that are not part of the conversation but happened during it, such as a worker's approval: + * each draws after the newest message that came before it, so it stays at its own time. */ +import { useMemo } from 'react' +import type { NativeChatTranscriptSlot } from './native-chat-transcript-slots' + +export type NativeChatTimedRow = { key: string; at: number; node: React.ReactNode } + +export type NativeChatTimedRowPlacement = { + /** Keyed by message id: the rows drawn after that message, oldest first. */ + afterMessage: ReadonlyMap + /** Rows no loaded message precedes, drawn at the end of the conversation. */ + unplaced: readonly NativeChatTimedRow[] +} + +// Separators no key or message id contains. +const FIELD = '\u0000' +const ROW = '\u0001' + +/** The message each row follows: the last top-level message at or before its time; null for none. */ +function anchorNativeChatTimedRows( + slots: readonly NativeChatTranscriptSlot[], + rows: readonly NativeChatTimedRow[] +): [key: string, messageId: string | null][] { + const dated = slots.flatMap((slot) => + slot.kind === 'message' && slot.depth === 0 && slot.message.timestamp !== null + ? [{ id: slot.message.id, at: slot.message.timestamp }] + : [] + ) + return rows + .toSorted((a, b) => a.at - b.at) + .map((row) => [row.key, dated.findLast((message) => message.at <= row.at)?.id ?? null]) +} + +/** Stable while no row changes the message it follows, so streaming text does not redraw every row. */ +export function useNativeChatTimedRows( + slots: readonly NativeChatTranscriptSlot[], + rows: readonly NativeChatTimedRow[] | undefined +): NativeChatTimedRowPlacement | null { + // A string, so the memo below sees a change only when some row's anchor does. + const anchors = rows?.length + ? anchorNativeChatTimedRows(slots, rows) + .map(([key, messageId]) => `${key}${FIELD}${messageId ?? ''}`) + .join(ROW) + : '' + return useMemo(() => { + if (!rows?.length) { + return null + } + const byKey = new Map(rows.map((row) => [row.key, row])) + const afterMessage = new Map() + const unplaced: NativeChatTimedRow[] = [] + for (const [key, messageId] of anchors.split(ROW).map((entry) => entry.split(FIELD))) { + const row = byKey.get(key) + if (!row) { + continue + } + if (messageId) { + afterMessage.set(messageId, [...(afterMessage.get(messageId) ?? []), row]) + } else { + unplaced.push(row) + } + } + return { afterMessage, unplaced } + }, [anchors, rows]) +} diff --git a/src/renderer/src/components/native-chat/conversation/slots/use-native-chat-transcript-row-context.ts b/src/renderer/src/components/native-chat/conversation/slots/use-native-chat-transcript-row-context.ts index c7598b9cc21..012a58dbf12 100644 --- a/src/renderer/src/components/native-chat/conversation/slots/use-native-chat-transcript-row-context.ts +++ b/src/renderer/src/components/native-chat/conversation/slots/use-native-chat-transcript-row-context.ts @@ -6,7 +6,7 @@ import type { StructuredAgentSessionHostWork } from '../../session/structured/us type NativeChatTranscriptRowContextInput = Omit< NativeChatTranscriptRowContext, - 'agentName' | 'actionablePromptIds' + 'agentName' | 'actionablePromptIds' | 'timedRows' > & { agent: NativeChatLiveSession['agent'] hostWork: StructuredAgentSessionHostWork | undefined diff --git a/src/renderer/src/components/native-chat/messages/rows/NativeChatTranscriptRow.tsx b/src/renderer/src/components/native-chat/messages/rows/NativeChatTranscriptRow.tsx index d9064f87608..0b8694affa9 100644 --- a/src/renderer/src/components/native-chat/messages/rows/NativeChatTranscriptRow.tsx +++ b/src/renderer/src/components/native-chat/messages/rows/NativeChatTranscriptRow.tsx @@ -11,6 +11,7 @@ import { NativeChatSubagentEntries } from '../../subagents/NativeChatSubagentRun import type { NativeChatSubagentDisclosure } from '../../subagents/native-chat-subagent-sections' import type { NativeChatTaskListPredecessors } from '../../../../../../shared/native-chat/input/native-chat-task-list-history' import type { NativeChatTranscriptSlot } from '../../conversation/slots/native-chat-transcript-slots' +import type { NativeChatTimedRow } from '../../conversation/slots/native-chat-timed-rows' import type { NativeChatDiffReveal, NativeChatDiffTarget @@ -36,6 +37,8 @@ export type NativeChatTranscriptRowContext = { latestTurnKey?: string /** Keyed by message id: the user messages that did not go through, each with its own words. */ deliveryNotices?: ReadonlyMap + /** Keyed by message id: rows from outside the conversation that came right after that message. */ + timedRows?: ReadonlyMap structuredAttachments?: boolean runtimeContext?: RuntimeFileOperationArgs | null onToggleExpandedTurn: (turnKey: string) => void @@ -175,6 +178,9 @@ export const NativeChatTranscriptRow = memo(function NativeChatTranscriptRow({ {openedPullRequests ? ( ) : null} + {context.timedRows?.get(message.id)?.map(({ key, node }) => ( +
{node}
+ ))} ) }) diff --git a/src/renderer/src/components/native-chat/prompts/NativeChatApprovalCard.tsx b/src/renderer/src/components/native-chat/prompts/NativeChatApprovalCard.tsx index b94353ce45c..8b5f706db02 100644 --- a/src/renderer/src/components/native-chat/prompts/NativeChatApprovalCard.tsx +++ b/src/renderer/src/components/native-chat/prompts/NativeChatApprovalCard.tsx @@ -1,6 +1,6 @@ import { SecuritySurface } from '@/components/ui/security-surface' import { useRef, useState } from 'react' -import { ChevronDown, ShieldQuestion, X } from 'lucide-react' +import { ChevronDown, Loader2, ShieldQuestion, X } from 'lucide-react' import { Collapsible, CollapsibleContent, CollapsibleTrigger } from '@/components/ui/collapsible' import { approvalDetailPreview } from '../../../../../shared/agent-session/agent-session-approval-detail-preview' import { cn } from '@/lib/class-names' @@ -26,6 +26,8 @@ export type NativeChatApprovalCardProps = { onCollapse?: () => void /** A choice is being delivered: the options wait for its answer. */ isSubmitting?: boolean + /** The option being sent, while `isSubmitting`: its button shows that it is working. */ + submittingOption?: string shouldFocus?: boolean /** Shown when the card has no options: only the terminal can answer it. */ onOpenTerminal?: () => void @@ -33,8 +35,8 @@ export type NativeChatApprovalCardProps = { worker?: { name: string; onOpen: () => void } /** Live time left before the agent decides on its own, shown only when its screen shows it. */ countdown?: string - /** `transcript`: a row in the message list, not the composer slot (no slot height, no focus). */ - placement?: 'composer' | 'transcript' + /** `stacked`: one of several cards above the composer, not the chat's own slot (no slot height, no focus). */ + placement?: 'composer' | 'stacked' } /** PTY options are literal replies; structured options are journal ids. The first option is primary unless the options are neutral. */ @@ -44,6 +46,7 @@ export function NativeChatApprovalCard({ onCancel, onCollapse, isSubmitting = false, + submittingOption, shouldFocus = false, onOpenTerminal, worker, @@ -56,7 +59,7 @@ export function NativeChatApprovalCard({ const neededPath = approvalBlockedPathToShow(approval) // A newer Orca's subject: its detail is shown, and only the card's cancel answers. const newerSubject = isNewerApprovalSubject(approval.subject) - const inTranscript = placement === 'transcript' + const stacked = placement === 'stacked' const hasContext = Boolean( countdown || approval.description || @@ -65,18 +68,16 @@ export function NativeChatApprovalCard({ approval.subject || approval.detail ) - useNativeChatPromptCardFocus(cardRef, shouldFocus && !inTranscript) + useNativeChatPromptCardFocus(cardRef, shouldFocus && !stacked) const escape = onCancel ?? (isSubmitting ? undefined : onCollapse) return ( -
+
- {opt.label} + {isSubmitting && opt.send === submittingOption ? ( + + + {opt.label} + + ) : ( + opt.label + )} ))} {approval.options.length === 0 && onOpenTerminal ? ( diff --git a/src/renderer/src/components/native-chat/viewport/virtualization/NativeChatTranscriptItems.tsx b/src/renderer/src/components/native-chat/viewport/virtualization/NativeChatTranscriptItems.tsx index ba383132503..f32dd64ab84 100644 --- a/src/renderer/src/components/native-chat/viewport/virtualization/NativeChatTranscriptItems.tsx +++ b/src/renderer/src/components/native-chat/viewport/virtualization/NativeChatTranscriptItems.tsx @@ -5,6 +5,10 @@ import { } from '../../messages/rows/NativeChatTranscriptRow' import { nativeChatSlotKey } from '../../conversation/slots/native-chat-transcript-slot-selection' import type { NativeChatTranscriptSlot } from '../../conversation/slots/native-chat-transcript-slots' +import { + useNativeChatTimedRows, + type NativeChatTimedRow +} from '../../conversation/slots/native-chat-timed-rows' import type { NativeChatTranscriptWindow } from './use-native-chat-transcript-window' import type { ReaderGesture } from '../scroll/native-chat-autoscroll' import { NativeChatForwardedGestureContext } from '../scroll/native-chat-reader-scroll-input' @@ -17,6 +21,7 @@ import { /** Mounted rows own their height; only unloaded gaps use cached measurements. */ export function NativeChatTranscriptItems({ slots, + timedRows, loadedMessageIds, context, window, @@ -24,6 +29,8 @@ export function NativeChatTranscriptItems({ forwardGesture }: { slots: readonly NativeChatTranscriptSlot[] + /** Rows from outside the conversation, each drawn after the message it followed in time. */ + timedRows?: readonly NativeChatTimedRow[] loadedMessageIds: ReadonlySet context: NativeChatTranscriptRowContext window: NativeChatTranscriptWindow @@ -33,6 +40,11 @@ export function NativeChatTranscriptItems({ }): React.JSX.Element { const rowKeys = useMemo(() => slots.map(nativeChatSlotKey), [slots]) const replyReveals = useNativeChatReplyReveals(rowKeys, loadedMessageIds) + const placed = useNativeChatTimedRows(slots, timedRows) + const rowContext = useMemo( + () => (placed ? { ...context, timedRows: placed.afterMessage } : context), + [context, placed] + ) return ( @@ -49,7 +61,7 @@ export function NativeChatTranscriptItems({
+ {placed?.unplaced.map(({ key, node }) => ( +
{node}
+ ))}
) diff --git a/src/renderer/src/components/native-chat/worker-approvals/NativeChatWorkerApprovals.fixture.tsx b/src/renderer/src/components/native-chat/worker-approvals/NativeChatWorkerApprovals.fixture.tsx index 380684f38eb..3032182b178 100644 --- a/src/renderer/src/components/native-chat/worker-approvals/NativeChatWorkerApprovals.fixture.tsx +++ b/src/renderer/src/components/native-chat/worker-approvals/NativeChatWorkerApprovals.fixture.tsx @@ -1,10 +1,13 @@ import { defineFixture } from '../../../component-fixtures/component-fixture' +import { NativeChatMessageList } from '../NativeChatMessageList' +import type { NativeChatLiveSession } from '../session/terminal/read/native-chat-live-session-contract' +import type { NativeChatMessage } from '../../../../../shared/native-chat/native-chat-types' import { NativeChatApprovalCard } from '../prompts/NativeChatApprovalCard' import { - NativeChatWorkerApprovalRows, - NativeChatWorkerApprovalStrip, - type NativeChatWorkerApproval + NativeChatWorkerApprovalReceipt, + NativeChatWorkerApprovalStack } from './NativeChatWorkerApprovals' +import type { NativeChatWorkerApproval } from './native-chat-worker-approval-feed' import type { OrchestrationCrewRow } from '../../../../../shared/orchestration/orchestration-crew' import type { WorkerApprovalOutcome, @@ -68,7 +71,6 @@ const openDocs: NativeChatWorkerApproval = { worker: docs } const target = { kind: 'local' } as const -const root = { current: null } const composer = (
@@ -78,47 +80,6 @@ const composer = (
) -export const open = defineFixture({ - width: 760, - render: () => ( -
- -
- ) -}) - -export const several = defineFixture({ - width: 760, - render: () => ( -
- - - {composer} -
- ) -}) - -export const coordinatorBusy = defineFixture({ - width: 760, - render: () => ( -
- - {}} - onCancel={() => {}} - /> -
- ) -}) - function closed( id: string, outcome: WorkerApprovalOutcome, @@ -126,7 +87,7 @@ function closed( ): NativeChatWorkerApproval { return { approval: approval(id, bash, { - state: outcome.decision ? 'answered' : 'expired', + state: outcome.by === 'auto' ? 'expired' : 'answered', allowedActions: [], outcome }), @@ -139,50 +100,153 @@ export const answered = defineFixture({ width: 760, render: () => (
- + {[ + closed('a', { by: 'person', decision: 'allow', reason: null, reasonDelivered: false }), + closed('b', { + by: 'person', + decision: 'deny', + reason: 'Denied by the owner.', + reasonDelivered: true + }), + closed('c', { + by: 'coordinator', + decision: 'deny', + reason: + 'Write the script to scripts/dialog_title.py and run it with python3 instead of a heredoc.', + reasonDelivered: true + }), + closed('d', { + by: 'worker-terminal', + decision: 'allow', + reason: null, + reasonDelivered: false + }), + closed('e', { + by: 'worker-terminal', + decision: 'deny', + reason: null, + reasonDelivered: false + }), + closed( + 'f', + { by: 'worker-chat', decision: 'allow', reason: null, reasonDelivered: false }, + docs + ), + closed('g', { by: 'auto', decision: 'deny', reason: null, reasonDelivered: false }), + closed('h', { + by: 'terminal-only', + decision: null, + reason: null, + reasonDelivered: false + }), + closed('i', { by: 'unknown', decision: null, reason: null, reasonDelivered: false }) + ].map((entry) => ( + + ))}
) }) + +// A coordinator chat that kept replying after a worker asked twice: each card sits at its own time. +const CHAT_START = Date.parse('2026-11-11T20:09:00.000Z') +function reply(id: string, role: NativeChatMessage['role'], minute: number, text: string) { + const message: NativeChatMessage = { + id, + role, + source: 'transcript', + timestamp: CHAT_START + minute * 60_000, + blocks: [{ type: 'text', text }] + } + return message +} +const transcript: NativeChatLiveSession = { + messages: [ + reply('ask', 'user', 0, 'Have a worker build the bot settings page.'), + reply('started', 'assistant', 1, 'A worker is on it in dungeness.'), + reply('status', 'user', 4, 'How is it going?'), + reply('answer', 'assistant', 5, 'It finished the settings rows and is wiring the avatar now.'), + reply('next', 'user', 7, 'Also check the tree spacing.'), + reply('ack', 'assistant', 8, 'Added it to the worker task.') + ], + agent: 'claude', + sessionId: 'fixture', + status: 'ready', + readPhase: 'ready', + hasMore: false, + loadingEarlier: false, + olderHistoryGeneration: 0, + loadEarlier: async () => 'applied' +} +const allowedAt = new Date(CHAT_START + 2.5 * 60_000).toISOString() + +const allowed = { + ...closed('allowed', { by: 'person', decision: 'allow', reason: null, reasonDelivered: false }), + at: allowedAt +} + +/** The coordinator chat as the pane lays it out: transcript with receipts, then the pinned stack, + * the chat's own prompt, and the composer. */ +function pane( + stack: readonly NativeChatWorkerApproval[], + ownPrompt = false, + height = 'h-[760px]' +): React.JSX.Element { + return ( +
+ + } + ]} + /> + + {ownPrompt ? ( + {}} + onCancel={() => {}} + /> + ) : null} + {composer} +
+ ) +} + +export const oneOpen = defineFixture({ width: 760, render: () => pane([openBash]) }) + +export const twoOpen = defineFixture({ width: 760, render: () => pane([openBash, openDocs]) }) + +export const openWithOwnPrompt = defineFixture({ + width: 760, + render: () => pane([openBash], true) +}) + +// A short split pane: the stack gives way first, so the chat's own prompt keeps its buttons. +export const twoOpenWithOwnPromptShort = defineFixture({ + width: 760, + render: () => pane([openBash, openDocs], true, 'h-[520px]') +}) + +// The click's outcome where the card was, for the moment before it moves into the transcript. +export const settling = defineFixture({ + width: 760, + render: () => + pane([ + closed('settled', { by: 'person', decision: 'allow', reason: null, reasonDelivered: false }) + ]) +}) + +export const receiptInPlace = defineFixture({ width: 760, render: () => pane([]) }) diff --git a/src/renderer/src/components/native-chat/worker-approvals/NativeChatWorkerApprovals.test.tsx b/src/renderer/src/components/native-chat/worker-approvals/NativeChatWorkerApprovals.test.tsx new file mode 100644 index 00000000000..208f91bceae --- /dev/null +++ b/src/renderer/src/components/native-chat/worker-approvals/NativeChatWorkerApprovals.test.tsx @@ -0,0 +1,86 @@ +// @vitest-environment happy-dom + +import '@testing-library/jest-dom/vitest' + +import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react' +import { afterEach, expect, it, vi } from 'vitest' +import type { OrchestrationCrewRow } from '../../../../../shared/orchestration/orchestration-crew' + +const rpc = vi.hoisted(() => ({ call: vi.fn() })) +const toast = vi.hoisted(() => ({ success: vi.fn(), info: vi.fn(), error: vi.fn() })) +vi.mock('@/runtime/rpc/calls/runtime-rpc-call', () => ({ callRuntimeRpc: rpc.call })) +vi.mock('sonner', () => ({ toast })) + +const { RuntimeRpcCallError } = await import('@/runtime/rpc/calls/runtime-rpc-result') +const { NativeChatWorkerApprovalStack } = await import('./NativeChatWorkerApprovals') + +afterEach(() => { + cleanup() + vi.clearAllMocks() +}) + +const worker: OrchestrationCrewRow = { + partyKey: 'w', + role: 'worker', + label: 'try-claude', + agentKind: 'claude', + status: 'blocked' +} +const entry = { + approval: { + v: 1 as const, + approvalId: 'apr_1', + state: 'open' as const, + worker: { handle: 'term_w', dispatchId: 'ctx_1', taskId: 'task_1' }, + summary: { title: 'Allow Bash?', detail: 'rg -n x', reason: null }, + allowedActions: ['allow' as const, 'deny' as const] + }, + at: '2026-11-11T20:11:30.000Z', + askedAt: '2026-11-11T20:11:24.000Z', + worker +} + +const reject = (code: string) => + rpc.call.mockRejectedValueOnce( + new RuntimeRpcCallError({ + id: '1', + ok: false, + error: { code, message: code }, + _meta: { runtimeId: 'r' } + }) + ) + +function renderStack() { + render() +} + +it('waits on the host after a click: both buttons off, the clicked one working, no toast when it lands', async () => { + renderStack() + let land: (value: unknown) => void = () => {} + rpc.call.mockReturnValueOnce(new Promise((resolve) => (land = resolve))) + fireEvent.click(screen.getByRole('button', { name: 'Allow' })) + expect(screen.getByRole('button', { name: 'Allow' })).toBeDisabled() + expect(screen.getByRole('button', { name: 'Deny' })).toBeDisabled() + expect( + screen.getByRole('button', { name: 'Allow' }).querySelector('.animate-spin') + ).not.toBeNull() + expect(screen.getByRole('button', { name: 'Deny' }).querySelector('.animate-spin')).toBeNull() + land({}) + await waitFor(() => expect(screen.getByRole('button', { name: 'Allow' })).toBeEnabled()) + expect(toast.success).not.toHaveBeenCalled() + expect(toast.info).not.toHaveBeenCalled() +}) + +it('leaves the card to the host list when the answer was not applied', async () => { + renderStack() + reject('approval_not_open') + fireEvent.click(screen.getByRole('button', { name: 'Allow' })) + await waitFor(() => expect(toast.info).toHaveBeenCalledTimes(1)) + // Still open as far as this card knows: answerable again until the host's list says otherwise. + expect(screen.getByRole('button', { name: 'Allow' })).toBeEnabled() + + reject('internal_error') + fireEvent.click(screen.getByRole('button', { name: 'Deny' })) + await waitFor(() => expect(toast.error).toHaveBeenCalledTimes(1)) + expect(screen.getByRole('button', { name: 'Deny' })).toBeEnabled() +}) diff --git a/src/renderer/src/components/native-chat/worker-approvals/NativeChatWorkerApprovals.tsx b/src/renderer/src/components/native-chat/worker-approvals/NativeChatWorkerApprovals.tsx index dc935a1ad18..0c3fd1602c6 100644 --- a/src/renderer/src/components/native-chat/worker-approvals/NativeChatWorkerApprovals.tsx +++ b/src/renderer/src/components/native-chat/worker-approvals/NativeChatWorkerApprovals.tsx @@ -1,132 +1,145 @@ -import { useCallback, useEffect, useMemo, useState } from 'react' +import { useEffect, useMemo, useState } from 'react' import { toast } from 'sonner' import { useTranslate } from '@/i18n/use-translate' import { callRuntimeRpc } from '@/runtime/rpc/calls/runtime-rpc-call' +import { RuntimeRpcCallError } from '@/runtime/rpc/calls/runtime-rpc-result' import { installWindowVisibilityInterval } from '@/lib/window-activity/window-visibility-interval' import { openOrchestrationCrewAgent } from '@/lib/agent-session/open/open-agent-message-sender' -import { useOrchestrationCrew } from '@/components/orchestration-crew/use-orchestration-crew' import { NativeChatApprovalCard } from '../prompts/NativeChatApprovalCard' import { NativeChatResolutionReceipt } from '../prompts/NativeChatResolutionReceipt' -import { NativeChatWorkerLifetimeStrip } from '../worker-lifetime/NativeChatWorkerLifetimeStrip' import { isWorkerApprovalDecision, workerApprovalCard, workerApprovalReceiptBody, workerApprovalReceiptReason, workerApprovalReceiptText, - workerApprovalLapsesAt, workerApprovalTimeLeft } from './worker-approval-card-model' +import { + useNativeChatPinnedWorkerApprovals, + useNativeChatWorkerApprovalReceipts, + type NativeChatWorkerApproval +} from './native-chat-worker-approval-feed' import type { RuntimeClientTarget } from '../../../../../shared/runtime-client-target' +import type { NativeChatTimedRow } from '../conversation/slots/native-chat-timed-rows' import { formatOrcaSessionAddress, isOrcaSessionId } from '../../../../../shared/orca-session-address' -import type { OrchestrationCrewRow } from '../../../../../shared/orchestration/orchestration-crew' -import type { - WorkerApprovalDecision, - WorkerApprovalPayload -} from '../../../../../shared/orchestration/approvals/worker-approval-payload' - -export type NativeChatWorkerApproval = { - approval: WorkerApprovalPayload - at: string - worker: OrchestrationCrewRow -} +import type { WorkerApprovalDecision } from '../../../../../shared/orchestration/approvals/worker-approval-payload' // The person's own Deny: the worker gets this, word for word where its agent takes a message. const OWNER_DENY_REASON = 'Denied by the owner.' -/** This chat's workers' approvals, from its crew's mailbox rows as soon as they are stored; local only in v1. */ -export function useNativeChatWorkerApprovals( - target: RuntimeClientTarget | null, - party: string | null -): NativeChatWorkerApproval[] { - const crew = useOrchestrationCrew(target?.kind === 'local' ? target : null, party) - const all = useMemo( - () => - crew.sections.managing - .flatMap((worker) => (worker.approvals ?? []).map((entry) => ({ ...entry, worker }))) - .sort((a, b) => a.at.localeCompare(b.at)), - [crew] - ) - const [now, setNow] = useState(Date.now) - const nextLapse = Math.min( - ...all.map(({ approval }) => workerApprovalLapsesAt(approval)).filter((at) => at > now) - ) - useEffect(() => { - if (!Number.isFinite(nextLapse)) { - return - } - const timer = setTimeout(() => setNow(Date.now()), nextLapse - Date.now()) - return () => clearTimeout(timer) - }, [nextLapse]) - return useMemo( - () => all.filter(({ approval }) => workerApprovalLapsesAt(approval) > now), - [all, now] +/** A worker's answered or lapsed prompt, in the transcript where the worker first asked. */ +export function NativeChatWorkerApprovalReceipt({ + entry +}: { + entry: NativeChatWorkerApproval +}): React.JSX.Element { + const t = useTranslate() + const { approval } = entry + return ( +
+ +
) } -const cardSelector = (approvalId: string) => - `[data-native-chat-worker-approval="${CSS.escape(approvalId)}"]` - -/** Open cards and receipts at the end of the conversation; a card here never takes focus or cancels the chat's turn. */ -export function NativeChatWorkerApprovalRows({ +/** Workers' prompts pinned above the composer, oldest first: open ones as cards, and ones just + * closed as their receipt. A card here never takes focus or cancels the chat's turn. */ +export function NativeChatWorkerApprovalStack({ approvals, - target + target, + isVisible = true }: { approvals: readonly NativeChatWorkerApproval[] target: RuntimeClientTarget + /** A hidden pane's countdown stands still; it shows the time again once visible. */ + isVisible?: boolean }): React.JSX.Element | null { const t = useTranslate() - const [submitting, setSubmitting] = useState>(new Set()) - const now = useSecondClock(approvals.some(({ approval }) => approval.expiresAt)) - const answer = useCallback( - (entry: NativeChatWorkerApproval, decision: WorkerApprovalDecision) => { - const { approvalId, worker } = entry.approval - setSubmitting((current) => new Set(current).add(approvalId)) - callRuntimeRpc(target, 'orchestration.approvalAnswer', { - dispatch: worker.dispatchId, - prompt: approvalId, - decision, - ...(decision === 'deny' ? { reason: OWNER_DENY_REASON } : {}) - }) - .catch((error: unknown) => - toast.error( - t('components.native-chat.approval.answerFailed', '{{name}}: {{detail}}', { - name: entry.worker.label, - detail: error instanceof Error ? error.message : String(error) - }) + const open = approvals.filter(({ approval }) => approval.state === 'open') + // Each prompt being answered here, and with which decision: the card waits on the host's outcome. + const [submitting, setSubmitting] = useState>( + new Map() + ) + const now = useSecondClock(isVisible && open.some(({ approval }) => approval.expiresAt)) + const answer = (entry: NativeChatWorkerApproval, decision: WorkerApprovalDecision): void => { + const { approvalId, worker } = entry.approval + setSubmitting((current) => new Map(current).set(approvalId, decision)) + const name = entry.worker.label + callRuntimeRpc(target, 'orchestration.approvalAnswer', { + dispatch: worker.dispatchId, + prompt: approvalId, + decision, + ...(decision === 'deny' ? { reason: OWNER_DENY_REASON } : {}) + }) + // A landed answer needs no toast: the host's list turns the card into its receipt. + .catch((error: unknown) => { + // Not applied: the host's list decides. A prompt that closed meanwhile (its worker ended, + // or it was answered elsewhere) turns into its receipt from that; one still open stays answerable. + const code = error instanceof RuntimeRpcCallError ? error.code : null + if (code === 'dispatch_inactive' || code === 'approval_not_open') { + toast.info( + code === 'dispatch_inactive' + ? t( + 'components.native-chat.approval.answerWorkerEnded', + '{{name}} has ended, so this prompt is closed', + { name } + ) + : t( + 'components.native-chat.approval.answerNotApplied', + '{{name}}: the answer did not reach this prompt', + { name } + ) ) - ) - .finally(() => - setSubmitting((current) => { - const next = new Set(current) - next.delete(approvalId) - return next + return + } + toast.error( + t('components.native-chat.approval.answerFailed', '{{name}}: {{detail}}', { + name, + detail: error instanceof Error ? error.message : String(error) }) ) - }, - [t, target] - ) + }) + .finally(() => + setSubmitting((current) => { + const next = new Map(current) + next.delete(approvalId) + return next + }) + ) + } if (approvals.length === 0) { return null } return ( -
+ // Bounded by the pane, and the first to give way, so the chat's own prompt card keeps its room. +
{approvals.map((entry) => { const { approval } = entry if (approval.state !== 'open') { + // Settling, or only the worker's terminal can answer it: the outcome stays where the card was. return ( -
- +
+
) } @@ -141,6 +154,7 @@ export function NativeChatWorkerApprovalRows({ } }} isSubmitting={submitting.has(approval.approvalId)} + submittingOption={submitting.get(approval.approvalId)} worker={{ name: entry.worker.label, onOpen: () => void openOrchestrationCrewAgent(entry.worker, target) @@ -154,7 +168,7 @@ export function NativeChatWorkerApprovalRows({ ) } : {})} - placement="transcript" + placement="stacked" />
) @@ -163,31 +177,17 @@ export function NativeChatWorkerApprovalRows({ ) } -/** "N approvals · Show": counts open approvals, and stays up even while the chat has its own prompt. */ -export function NativeChatWorkerApprovalStrip({ - approvals, - rootRef -}: { - approvals: readonly NativeChatWorkerApproval[] - rootRef: React.RefObject +/** The pinned stack for a chat's own party; it holds the approvals itself, so the pane does not redraw for them. */ +export function NativeChatPartyWorkerApprovalStack({ + party, + ...stack +}: Omit[0], 'approvals'> & { + party: string | null }): React.JSX.Element | null { - const t = useTranslate() - const open = approvals.filter(({ approval }) => approval.state === 'open') - if (open.length === 0) { - return null - } return ( - - rootRef.current - ?.querySelector(cardSelector(open[0].approval.approvalId)) - ?.scrollIntoView({ block: 'center' }) - } + ) } @@ -206,17 +206,34 @@ function useSecondClock(active: boolean): number { return now } -/** A coordinator chat's worker approvals: card rows for its transcript, and the strip above its composer. */ -export function useNativeChatWorkerApprovalSlots( - pane: { target: RuntimeClientTarget; sessionId: string }, - rootRef: React.RefObject -): { rows: React.ReactNode; strip: React.ReactNode } { - const approvals = useNativeChatWorkerApprovals( - pane.target, - isOrcaSessionId(pane.sessionId) ? formatOrcaSessionAddress(pane.sessionId) : null +/** The chat's address its workers report to, when it can coordinate: a local Orca session (v1). */ +export function nativeChatWorkerApprovalParty(pane: { + target: RuntimeClientTarget + sessionId: string +}): string | null { + return pane.target.kind === 'local' && isOrcaSessionId(pane.sessionId) + ? formatOrcaSessionAddress(pane.sessionId) + : null +} + +/** A coordinator chat's closed worker prompts, each in its transcript at the time the worker + * asked. Holds them itself, so only the transcript redraws, and only when a receipt changes. */ +export function NativeChatWorkerApprovalTimeline({ + party, + children +}: { + party: string | null + children: (timedRows: readonly NativeChatTimedRow[]) => React.ReactNode +}): React.ReactNode { + const receipts = useNativeChatWorkerApprovalReceipts(party) + const timedRows = useMemo( + () => + receipts.map((entry) => ({ + key: `worker-approval:${entry.approval.approvalId}`, + at: Date.parse(entry.askedAt ?? entry.at), + node: + })), + [receipts] ) - return { - rows: , - strip: - } + return children(timedRows) } diff --git a/src/renderer/src/components/native-chat/worker-approvals/native-chat-worker-approval-feed.test.ts b/src/renderer/src/components/native-chat/worker-approvals/native-chat-worker-approval-feed.test.ts new file mode 100644 index 00000000000..4b5df1e6238 --- /dev/null +++ b/src/renderer/src/components/native-chat/worker-approvals/native-chat-worker-approval-feed.test.ts @@ -0,0 +1,93 @@ +// @vitest-environment happy-dom + +import { act, renderHook } from '@testing-library/react' +import { afterEach, expect, it, vi } from 'vitest' +import type { OrchestrationWorkerApprovalEntry } from '../../../../../shared/orchestration/orchestration-crew' + +const stream = vi.hoisted(() => ({ emit: (_frame: unknown): void => {} })) +vi.mock('@/runtime/rpc/subscriptions/runtime-rpc-subscribe', () => ({ + subscribeRuntimeRpc: ( + _target: unknown, + _method: string, + _params: unknown, + handlers: { onEvent: (frame: unknown) => void } + ) => { + stream.emit = handlers.onEvent + return Promise.resolve({ unsubscribe: () => {} }) + } +})) + +const feed = await import('./native-chat-worker-approval-feed') + +afterEach(() => { + vi.useRealTimers() +}) + +const PARTY = 'orca_session_id:chat' +function approval( + approvalId: string, + state: 'open' | 'answered', + by?: 'person' | 'terminal-only' +): OrchestrationWorkerApprovalEntry { + return { + approval: { + v: 1, + approvalId, + state, + worker: { handle: 'term_w', dispatchId: 'ctx_1', taskId: 'task_1' }, + summary: { title: 'Allow Bash?', detail: null, reason: null }, + allowedActions: state === 'open' ? ['allow', 'deny'] : [], + ...(by + ? { + outcome: { + by, + decision: by === 'person' ? 'allow' : null, + reason: null, + reasonDelivered: false + } + } + : {}) + }, + at: '2026-11-11T20:00:00.000Z', + worker: { partyKey: 'w', role: 'worker', label: 'w', agentKind: 'claude', status: 'blocked' } + } +} +function send(...entries: OrchestrationWorkerApprovalEntry[]): void { + act(() => { + stream.emit({ type: 'begin' }) + for (const entry of entries) { + stream.emit({ type: 'approval', entry }) + } + stream.emit({ type: 'complete' }) + }) +} + +it('keeps a prompt that closed while shown pinned as its receipt for a moment, then moves it to the transcript', async () => { + vi.useFakeTimers() + const pinned = renderHook(() => feed.useNativeChatPinnedWorkerApprovals(PARTY)) + const receipts = renderHook(() => feed.useNativeChatWorkerApprovalReceipts(PARTY)) + await act(async () => {}) + send(approval('apr_old', 'answered', 'person'), approval('apr_1', 'open')) + expect(pinned.result.current.map((e) => e.approval.approvalId)).toEqual(['apr_1']) + const history = receipts.result.current + + // The host closes it: its receipt stays where the card was for a moment. + send(approval('apr_old', 'answered', 'person'), approval('apr_1', 'answered', 'person')) + expect(pinned.result.current.map((e) => [e.approval.approvalId, e.approval.state])).toEqual([ + ['apr_1', 'answered'] + ]) + // Only a pinned prompt changed: the transcript's receipts are the same array. + expect(receipts.result.current).toBe(history) + act(() => vi.advanceTimersByTime(4_000)) + expect(pinned.result.current).toEqual([]) + expect(receipts.result.current.map((e) => e.approval.approvalId)).toEqual(['apr_old', 'apr_1']) +}) + +it('keeps a prompt only the worker terminal can answer pinned', async () => { + vi.useFakeTimers() + const pinned = renderHook(() => feed.useNativeChatPinnedWorkerApprovals('orca_session_id:other')) + await act(async () => {}) + send(approval('apr_t', 'answered', 'terminal-only')) + act(() => vi.advanceTimersByTime(60_000)) + expect(pinned.result.current.map((e) => e.approval.approvalId)).toEqual(['apr_t']) +}) diff --git a/src/renderer/src/components/native-chat/worker-approvals/native-chat-worker-approval-feed.ts b/src/renderer/src/components/native-chat/worker-approvals/native-chat-worker-approval-feed.ts new file mode 100644 index 00000000000..58cf306c83a --- /dev/null +++ b/src/renderer/src/components/native-chat/worker-approvals/native-chat-worker-approval-feed.ts @@ -0,0 +1,215 @@ +import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from 'react' +import { subscribeRuntimeRpc } from '@/runtime/rpc/subscriptions/runtime-rpc-subscribe' +import { + WorkerApprovalsFrame, + type OrchestrationWorkerApprovalEntry +} from '../../../../../shared/orchestration/orchestration-crew' +import { workerApprovalLapsesAt } from './worker-approval-card-model' + +export type NativeChatWorkerApproval = OrchestrationWorkerApprovalEntry + +type Feed = { + /** The host's list, as last received. */ + received: readonly NativeChatWorkerApproval[] + /** Prompts that closed while shown, kept pinned until then (epoch ms) so the outcome lands in view. */ + settling: Map + settleTimer?: ReturnType + /** Above the composer: open prompts, ones only the worker's terminal can answer, and settling ones. */ + pinned: readonly NativeChatWorkerApproval[] + /** In the transcript, at the time each was asked. */ + receipts: readonly NativeChatWorkerApproval[] + listeners: Set<() => void> + dispose: () => void +} + +const EMPTY: readonly NativeChatWorkerApproval[] = [] +// Why 5 s: a dropped local stream is rare; retry without hammering a host that refuses it. +const RETRY_MS = 5_000 +// Why 4 s: long enough to read the outcome where the card was, short enough not to crowd the composer. +const SETTLE_MS = 4_000 +const feeds = new Map() + +const signature = (entries: readonly NativeChatWorkerApproval[]): string => + entries + .map(({ approval, at }) => + [ + approval.approvalId, + approval.state, + approval.outcome?.by, + approval.outcome?.decision, + at + ].join('\u0000') + ) + .join('\u0001') +const keep = ( + previous: readonly NativeChatWorkerApproval[], + next: NativeChatWorkerApproval[] +): readonly NativeChatWorkerApproval[] => + signature(previous) === signature(next) ? previous : next.length ? next : EMPTY + +function publish(feed: Feed): void { + const wasOpen = new Set( + feed.pinned.flatMap(({ approval }) => (approval.state === 'open' ? [approval.approvalId] : [])) + ) + const entries = feed.received + const now = Date.now() + for (const { approval } of entries) { + if (approval.state !== 'open' && wasOpen.has(approval.approvalId)) { + feed.settling.set(approval.approvalId, now + SETTLE_MS) + } + } + for (const [approvalId, until] of feed.settling) { + if (until <= now || !entries.some(({ approval }) => approval.approvalId === approvalId)) { + feed.settling.delete(approvalId) + } + } + const pinned = (entry: NativeChatWorkerApproval): boolean => + entry.approval.state === 'open' || + entry.approval.outcome?.by === 'terminal-only' || + feed.settling.has(entry.approval.approvalId) + feed.pinned = keep(feed.pinned, entries.filter(pinned)) + feed.receipts = keep( + feed.receipts, + entries.filter((entry) => !pinned(entry)) + ) + clearTimeout(feed.settleTimer) + if (feed.settling.size) { + feed.settleTimer = setTimeout(() => publish(feed), Math.min(...feed.settling.values()) - now) + } + feed.listeners.forEach((notify) => notify()) +} + +/** One stream per chat party, shared by its transcript rows and its strip; local hosts only (v1). + * Not parked while hidden: a hidden coordinator tab still needs its workers' prompts. */ +function observeWorkerApprovals(party: string, listener: () => void): () => void { + let feed = feeds.get(party) + if (!feed) { + const held: Feed = { + received: EMPTY, + settling: new Map(), + pinned: EMPTY, + receipts: EMPTY, + listeners: new Set(), + dispose: () => {} + } + feed = held + feeds.set(party, held) + let close: (() => void) | undefined + let retry: ReturnType | undefined + let generation = 0 + const open = (): void => { + const attempt = ++generation + const live = () => feeds.get(party) === held && generation === attempt + let pending: NativeChatWorkerApproval[] | undefined + // Keeps the cards it has: the next stream sends the current list as soon as it opens. + const lose = (error?: unknown): void => { + if (!live()) { + return + } + generation += 1 + close?.() + close = undefined + const code = + typeof error === 'object' && error !== null && 'code' in error ? error.code : undefined + if (code !== 'method_not_found' && code !== 'forbidden') { + retry = setTimeout(open, RETRY_MS) + } + } + void subscribeRuntimeRpc( + { kind: 'local' }, + 'orchestration.workerApprovalsSubscribe', + { party }, + { + onEvent: (value) => { + const parsed = WorkerApprovalsFrame.safeParse(value) + if (!live() || !parsed.success) { + return + } + const frame = parsed.data + if (frame.type === 'begin') { + pending = [] + } else if (frame.type === 'approval') { + pending?.push(frame.entry) + } else if (frame.type === 'complete' && pending) { + held.received = pending.length ? pending : EMPTY + pending = undefined + publish(held) + } else if (frame.type === 'end') { + lose() + } + }, + onError: lose, + onClose: lose + } + ).then((handle) => { + if (live()) { + close = handle.unsubscribe + } else { + handle.unsubscribe() + } + }, lose) + } + held.dispose = () => { + generation += 1 + clearTimeout(held.settleTimer) + clearTimeout(retry) + close?.() + } + open() + } + const held = feed + held.listeners.add(listener) + return () => { + held.listeners.delete(listener) + // A remount in the same task keeps the stream. + queueMicrotask(() => { + if (held.listeners.size === 0 && feeds.get(party) === held) { + feeds.delete(party) + held.dispose() + } + }) + } +} + +/** A chat coordinator's workers' approvals for the pinned area, oldest first; an open one leaves + * once its countdown lapses with no closing report. None for no party. */ +export function useNativeChatPinnedWorkerApprovals( + party: string | null +): readonly NativeChatWorkerApproval[] { + const pinned = useFeedPart(party, 'pinned') + const [now, setNow] = useState(Date.now) + const nextLapse = Math.min( + ...pinned.map(({ approval }) => workerApprovalLapsesAt(approval)).filter((at) => at > now) + ) + useEffect(() => { + if (!Number.isFinite(nextLapse)) { + return + } + const timer = setTimeout(() => setNow(Date.now()), nextLapse - Date.now()) + return () => clearTimeout(timer) + }, [nextLapse]) + return useMemo( + () => pinned.filter(({ approval }) => workerApprovalLapsesAt(approval) > now), + [pinned, now] + ) +} + +/** A chat coordinator's closed worker approvals for its transcript; the same array until one changes. */ +export function useNativeChatWorkerApprovalReceipts( + party: string | null +): readonly NativeChatWorkerApproval[] { + return useFeedPart(party, 'receipts') +} + +function useFeedPart( + party: string | null, + part: 'pinned' | 'receipts' +): readonly NativeChatWorkerApproval[] { + const subscribe = useCallback( + (listener: () => void) => (party ? observeWorkerApprovals(party, listener) : () => {}), + [party] + ) + return useSyncExternalStore(subscribe, () => + party ? (feeds.get(party)?.[part] ?? EMPTY) : EMPTY + ) +} diff --git a/src/renderer/src/components/native-chat/worker-approvals/worker-approval-card-model.ts b/src/renderer/src/components/native-chat/worker-approvals/worker-approval-card-model.ts index 14022b42751..d46eebe8e7c 100644 --- a/src/renderer/src/components/native-chat/worker-approvals/worker-approval-card-model.ts +++ b/src/renderer/src/components/native-chat/worker-approvals/worker-approval-card-model.ts @@ -51,12 +51,12 @@ export function workerApprovalReceiptBody( } } -/** Who answered, from the closing message's evidence; anything it does not name is "No longer open". */ +/** Who answered, from the closing message's evidence; a close it does not name says only that. */ export function workerApprovalReceiptText(approval: WorkerApprovalPayload, t: Translate): string { const outcome = approval.outcome const decision = outcome?.decision ?? null const by = outcome?.by - switch (decision === null && by !== 'terminal-only' ? 'unknown' : by) { + switch (decision === null && by !== 'terminal-only' && by !== 'worker-ended' ? 'unknown' : by) { case 'person': return decision === 'allow' ? t('components.native-chat.approval.allowedByYou', 'Allowed by you') @@ -76,9 +76,11 @@ export function workerApprovalReceiptText(approval: WorkerApprovalPayload, t: Tr 'components.native-chat.approval.answerInTerminal', "Answer it in the worker's terminal" ) + case 'worker-ended': + return t('components.native-chat.approval.workerEnded', 'No longer open · worker ended') case 'unknown': case undefined: - return t('components.native-chat.approval.noLongerOpen', 'No longer open') + return t('components.native-chat.approval.closedUnnamed', 'Closed without a recorded answer') } } diff --git a/src/renderer/src/i18n/en-runtime-required.json b/src/renderer/src/i18n/en-runtime-required.json index 355a0e04e2d..1e9554a3668 100644 --- a/src/renderer/src/i18n/en-runtime-required.json +++ b/src/renderer/src/i18n/en-runtime-required.json @@ -1608,8 +1608,6 @@ "startupMenu": { "title": "{{value0}} is waiting for a choice in the terminal" }, - "strip_one": "{{count}} approval", - "strip_other": "{{count}} approvals", "title": "Allow {{value0}}?" }, "ask": { diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json index 81d81d275ed..17a0013fa1e 100644 --- a/src/renderer/src/i18n/locales/en.json +++ b/src/renderer/src/i18n/locales/en.json @@ -20961,18 +20961,18 @@ "worker": "Worker · {{name}}", "openWorker": "Open worker", "answerFailed": "{{name}}: {{detail}}", + "answerNotApplied": "{{name}}: the answer did not reach this prompt", + "answerWorkerEnded": "{{name}} has ended, so this prompt is closed", "countdown": "Claude denies it on its own in {{time}} if nobody answers.", - "strip_one": "{{count}} approval", - "strip_other": "{{count}} approvals", - "show": "Show", "allowedByYou": "Allowed by you", "deniedByYou": "Denied by you", "deniedByCoordinator": "Denied by coordinator", "allowedInTerminal": "Allowed in the worker's terminal", "deniedInTerminal": "Denied in the worker's terminal", "answeredInChat": "Answered in the worker's chat", - "noLongerOpen": "No longer open", + "closedUnnamed": "Closed without a recorded answer", "autoDenied": "Auto-denied by Claude after 2:00", + "workerEnded": "No longer open · worker ended", "answerInTerminal": "Answer it in the worker's terminal" }, "launchPromptNotDelivered": "Not delivered — check the terminal", diff --git a/src/shared/orchestration/approvals/worker-approval-payload.ts b/src/shared/orchestration/approvals/worker-approval-payload.ts index e2a52152b02..367af721720 100644 --- a/src/shared/orchestration/approvals/worker-approval-payload.ts +++ b/src/shared/orchestration/approvals/worker-approval-payload.ts @@ -7,7 +7,8 @@ export type WorkerApprovalDecision = z.infer @@ -48,3 +50,21 @@ export const WorkerApprovalPayloadSchema = z.object({ }) export type WorkerApprovalPayload = z.infer export type WorkerApprovalState = WorkerApprovalPayload['state'] + +/** The same approval once closed: nothing left to answer, and how it closed. */ +export function closedApproval( + open: WorkerApprovalPayload, + outcome: WorkerApprovalOutcome +): WorkerApprovalPayload { + const closed: WorkerApprovalPayload = { + ...open, + // Expired is the agent's own timeout alone; every other close, named or not, is not one. + state: outcome.by === 'auto' ? 'expired' : 'answered', + allowedActions: [], + // Only a reason can be delivered. + outcome: { ...outcome, reasonDelivered: outcome.reason !== null && outcome.reasonDelivered } + } + // A countdown means nothing once the prompt is closed. + delete closed.expiresAt + return closed +} diff --git a/src/shared/orchestration/orchestration-crew.ts b/src/shared/orchestration/orchestration-crew.ts index f01d885f596..d7039981733 100644 --- a/src/shared/orchestration/orchestration-crew.ts +++ b/src/shared/orchestration/orchestration-crew.ts @@ -1,9 +1,16 @@ import { z } from 'zod' import { isPublicOrchestrationAddress } from './mailbox/orchestration-agent-reference' import { WorkerApprovalPayloadSchema } from './approvals/worker-approval-payload' +import { parseOrcaSessionAddress } from '../orca-session-address' export const CrewParty = z.string().refine(isPublicOrchestrationAddress) export const CrewSubscribeParams = z.object({ party: CrewParty }) +const CrewRowApproval = z.object({ + approval: WorkerApprovalPayloadSchema, + at: z.string(), + /** When the worker asked: where its card sits in the chat, open or answered. */ + askedAt: z.string().optional() +}) export const CrewRow = z.object({ partyKey: z.string(), role: z.enum(['manager', 'worker', 'peer']), @@ -23,9 +30,7 @@ export const CrewRow = z.object({ .optional(), pendingQuestion: z.object({ preview: z.string(), at: z.string() }).optional(), /** This worker's permission prompts addressed to the viewing party, each as its newest message: open ones, and recent receipts. */ - approvals: z - .array(z.object({ approval: WorkerApprovalPayloadSchema, at: z.string() })) - .optional(), + approvals: z.array(CrewRowApproval).optional(), sendAddress: CrewParty.optional(), openTarget: z .discriminatedUnion('kind', [ @@ -56,6 +61,23 @@ export const CrewFrame = z.discriminatedUnion('type', [ z.object({ type: z.literal('end') }) ]) export type OrchestrationCrewFrame = z.infer + +/** A chat coordinator's worker approvals alone, so a chat need not follow its whole crew. */ +export const WorkerApprovalsSubscribeParams = z.object({ + party: CrewParty.refine((party) => parseOrcaSessionAddress(party) !== null) +}) +export const WorkerApprovalEntry = CrewRowApproval.extend({ + worker: CrewRow.omit({ approvals: true }) +}) +export type OrchestrationWorkerApprovalEntry = z.infer +export const WorkerApprovalsFrame = z.discriminatedUnion('type', [ + z.object({ type: z.literal('begin') }), + // One approval per frame: a frame stays small whatever the count. + z.object({ type: z.literal('approval'), entry: WorkerApprovalEntry }), + z.object({ type: z.literal('complete') }), + z.object({ type: z.literal('end') }) +]) +export type OrchestrationWorkerApprovalsFrame = z.infer export function emptyCrew(status: 'ok' | 'unknown'): OrchestrationCrewSnapshot { return { status, sections: { managedBy: [], managing: [], talkingWith: [] } } } diff --git a/src/shared/rpc-contract/rpc-params-catalog.generated.ts b/src/shared/rpc-contract/rpc-params-catalog.generated.ts index 4eea7ebe2eb..7d58d1a15df 100644 --- a/src/shared/rpc-contract/rpc-params-catalog.generated.ts +++ b/src/shared/rpc-contract/rpc-params-catalog.generated.ts @@ -40,7 +40,10 @@ import { OrcadPeerDesktopsParamsSchema } from '../orcad-peer-desktops-contract' import { OrcadTerminalCensusParamsSchema } from '../orcad-terminal-census' -import { CrewSubscribeParams } from '../orchestration/orchestration-crew' +import { + CrewSubscribeParams, + WorkerApprovalsSubscribeParams +} from '../orchestration/orchestration-crew' import { PeerRunCancelParams } from '../orchestration/remote-owned-wire' import { RegisterDeviceKeyParamsSchema } from '../remote-runtime/pairing/device-key-registration-contract' import { PairingCreateOfferParamsSchema } from '../remote-runtime/pairing/pairing-create-offer-contract' @@ -1393,6 +1396,7 @@ export const RPC_PARAMS_BY_METHOD = { 'orchestration.taskCreate': TaskCreateParams, 'orchestration.taskList': TaskListParams, 'orchestration.workerAbandon': WorkerDispatchParams, + 'orchestration.workerApprovalsSubscribe': WorkerApprovalsSubscribeParams, 'orchestration.workerAutoClose': OrchestrationWorkerSubjectParams, 'orchestration.workerChatTouch': OrchestrationWorkerSubjectParams, 'orchestration.workerKeepOpen': OrchestrationWorkerKeepOpenParams,