From f4e49275f183d3dc9e06fbc164c8f26762552e91 Mon Sep 17 00:00:00 2001 From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com> Date: Sat, 7 Nov 2026 14:41:49 -0800 Subject: [PATCH] Derive chat status from named indexed populations --- .../journal-memory-state-queries.ts | 3 + .../agent-session-journal/journal-reads.ts | 5 +- .../journal-sql-point-read.ts | 10 + .../journal-sql-reads.test.ts | 3 +- .../journal-sql-reads.ts | 2 + .../journal-sql-state-queries.ts | 13 + .../journal-sql-status-item-schema.ts | 7 +- .../journal-sql-status-items.ts | 4 + .../journal-sql-status-request-items.ts | 90 +++++++ .../journal-state-queries.ts | 2 + .../journal-status-items.ts | 5 + .../journal-status-request-items.ts | 56 ++++ .../journal-status-requests.test.ts | 240 ++++++++++++++++++ .../journal-status-requests.ts | 125 +++++++++ .../journal-status-state.test.ts | 177 +++++++++++++ .../journal-status-state.ts | 123 +++++++++ ...structured-agent-session-latest-request.ts | 98 ++++--- .../native-chat/native-chat-orca-stop-cut.ts | 13 +- 18 files changed, 929 insertions(+), 47 deletions(-) create mode 100644 src/main/native-chat/agent-session-journal/journal-sql-status-request-items.ts create mode 100644 src/main/native-chat/agent-session-journal/journal-status-request-items.ts create mode 100644 src/main/native-chat/agent-session-journal/journal-status-requests.test.ts create mode 100644 src/main/native-chat/agent-session-journal/journal-status-requests.ts create mode 100644 src/main/native-chat/agent-session-journal/journal-status-state.test.ts create mode 100644 src/main/native-chat/agent-session-journal/journal-status-state.ts diff --git a/src/main/native-chat/agent-session-journal/journal-memory-state-queries.ts b/src/main/native-chat/agent-session-journal/journal-memory-state-queries.ts index ab86d8a8d09..db5ee08484c 100644 --- a/src/main/native-chat/agent-session-journal/journal-memory-state-queries.ts +++ b/src/main/native-chat/agent-session-journal/journal-memory-state-queries.ts @@ -7,9 +7,12 @@ import { memoryLatestAcceptedSendUnopened } from './context-epochs/journal-stop- import { readAgentJournalTurn } from '../../../shared/agent-session/lifecycle/agent-session-turn-record' import { compareAgentJournalItems } from '../../../shared/agent-session/journal/agent-session-journal-position' import { journalInputPresentationMember } from './input-order/journal-input-obligations' +import { memoryHasStatusRequestItem, memoryFailedStatusItems } from './journal-status-request-items' import { memoryJournalStatusItems } from './journal-status-items' export const memoryJournalStateQueries: JournalStateQueries = { + hasStatusRequestItem: memoryHasStatusRequestItem, + failedStatusItems: memoryFailedStatusItems, statusItems: memoryJournalStatusItems, latestContextClearSequence(state) { return latestAgentSessionContextClearSequence(memoryJournalMap(state.items).values()) diff --git a/src/main/native-chat/agent-session-journal/journal-reads.ts b/src/main/native-chat/agent-session-journal/journal-reads.ts index 847bc396f64..4137b5ab5e1 100644 --- a/src/main/native-chat/agent-session-journal/journal-reads.ts +++ b/src/main/native-chat/agent-session-journal/journal-reads.ts @@ -15,6 +15,7 @@ import type { JournalThreadGoalSource } from './projection/journal-thread-goal-s import { readJournalInput, type JournalInputReader } from './journal-input-reads' import { readJournalUsageLimitCut, readJournalOrcaStopCut } from './journal-status-cuts' import type { NativeChatUsageLimitCut } from '../../../shared/native-chat/native-chat-usage-limit-cut' +import { readJournalStatusState, type JournalStatusState } from './journal-status-state' import type { NativeChatOrcaStopCut } from '../../../shared/native-chat/native-chat-orca-stop-cut' /** Which items a visit decodes; a database serves only the named kinds, in sequence order. */ @@ -24,6 +25,7 @@ export type JournalItemFilter = { /** Reads a chat answers from its database; scans are filtered so none decodes the whole chat. */ export type AgentSessionJournalReads = { + statusState(currentFence?: number | null): Promise input: JournalInputReader usageLimitCut(): Promise orcaStopCut(): Promise @@ -59,7 +61,7 @@ type FoldedJournalReads = { [ K in Exclude< keyof AgentSessionJournalReads, - 'visitItems' | 'contextFloor' | 'input' | 'usageLimitCut' | 'orcaStopCut' + 'visitItems' | 'contextFloor' | 'input' | 'usageLimitCut' | 'orcaStopCut' | 'statusState' > ]: ( ...args: Parameters @@ -85,6 +87,7 @@ export function foldedJournalReads( } } return { + statusState: now((fence?: number | null) => readJournalStatusState(state(), fence)), input: async (operation) => readJournalInput(state(), operation), usageLimitCut: now(() => readJournalUsageLimitCut(state())), orcaStopCut: now(() => readJournalOrcaStopCut(state())), diff --git a/src/main/native-chat/agent-session-journal/journal-sql-point-read.ts b/src/main/native-chat/agent-session-journal/journal-sql-point-read.ts index 1cf06b0e924..132df027aec 100644 --- a/src/main/native-chat/agent-session-journal/journal-sql-point-read.ts +++ b/src/main/native-chat/agent-session-journal/journal-sql-point-read.ts @@ -21,6 +21,7 @@ import { readJournalSqlInput } from './journal-sql-input-reads' import { JournalSqlReducer } from './journal-sql-reducer' import { readJournalUsageLimitCut, readJournalOrcaStopCut } from './journal-status-cuts' import type { NativeChatUsageLimitCut } from '../../../shared/native-chat/native-chat-usage-limit-cut' +import { readJournalStatusState, type JournalStatusState } from './journal-status-state' import type { NativeChatOrcaStopCut } from '../../../shared/native-chat/native-chat-orca-stop-cut' import { readJournalSqlItems, @@ -31,6 +32,7 @@ import { export type JournalSqlPointRead = { sessionId: string operation: + | { kind: 'status-state'; currentFence?: number | null } | { kind: 'usage-limit-cut' } | { kind: 'orca-stop-cut' } | { kind: 'input-read'; operation: JournalInputRead } @@ -48,6 +50,7 @@ export type JournalSqlPointRead = { } export type JournalSqlPointReadResult = + | { kind: 'status-state'; status: JournalStatusState } | { kind: 'usage-limit-cut'; cut: NativeChatUsageLimitCut | null } | { kind: 'orca-stop-cut'; cut: NativeChatOrcaStopCut | null } | { kind: 'input-read'; result: JournalInputReadResult } @@ -99,6 +102,13 @@ function read( ) } switch (operation.kind) { + case 'status-state': { + const { state } = new JournalSqlReducer(scope, scope.epoch) + return { + kind: 'status-state', + status: readJournalStatusState(state, operation.currentFence) + } + } case 'usage-limit-cut': case 'orca-stop-cut': { const { state } = new JournalSqlReducer(scope, scope.epoch) diff --git a/src/main/native-chat/agent-session-journal/journal-sql-reads.test.ts b/src/main/native-chat/agent-session-journal/journal-sql-reads.test.ts index 656cc6337a5..b68853417b0 100644 --- a/src/main/native-chat/agent-session-journal/journal-sql-reads.test.ts +++ b/src/main/native-chat/agent-session-journal/journal-sql-reads.test.ts @@ -59,7 +59,8 @@ it('answers every database-shaped read exactly as the in-memory chat does', asyn reads.pendingSubmissions(), reads.newestTurn(), reads.usageLimitCut(), - reads.orcaStopCut() + reads.orcaStopCut(), + reads.statusState(1) ]) const expected = await answers(memory) // Spans more than one reader page. diff --git a/src/main/native-chat/agent-session-journal/journal-sql-reads.ts b/src/main/native-chat/agent-session-journal/journal-sql-reads.ts index 86e487d0b3f..c6914748fe0 100644 --- a/src/main/native-chat/agent-session-journal/journal-sql-reads.ts +++ b/src/main/native-chat/agent-session-journal/journal-sql-reads.ts @@ -49,6 +49,8 @@ export function journalSqlReads( const provenance = async (itemId: string) => (await read({ kind: 'item-provenance', itemId })).provenance return { + statusState: async (currentFence) => + (await read({ kind: 'status-state', currentFence })).status, input, usageLimitCut: async () => (await read({ kind: 'usage-limit-cut' })).cut, orcaStopCut: async () => (await read({ kind: 'orca-stop-cut' })).cut, diff --git a/src/main/native-chat/agent-session-journal/journal-sql-state-queries.ts b/src/main/native-chat/agent-session-journal/journal-sql-state-queries.ts index 2246c39f306..0b66adc7520 100644 --- a/src/main/native-chat/agent-session-journal/journal-sql-state-queries.ts +++ b/src/main/native-chat/agent-session-journal/journal-sql-state-queries.ts @@ -9,6 +9,7 @@ import type { JournalSqlValueContext } from './journal-sql-value-context' import type { JournalSqlQueryFacts } from './journal-sql-query-facts' import { journalSqlOrderedValues } from './journal-sql-keyed-values' import type { QueuedMessageRow } from './queued-messages/queued-message-table' +import { sqlHasStatusRequestItem, sqlFailedStatusItems } from './journal-sql-status-request-items' import { sqlJournalStatusItems } from './journal-sql-status-items' export function sqlJournalStateQueries( @@ -45,6 +46,18 @@ export function sqlJournalStateQueries( return Number(row?.sequence ?? 0) } return { + hasStatusRequestItem() { + facts.flush() + return sqlHasStatusRequestItem(scope) + }, + failedStatusItems(_state, floor) { + facts.flush() + return sqlFailedStatusItems( + scope, + (id) => context.read('items', JSON.stringify(id)), + floor + ) + }, statusItems(_state, selection) { facts.flush() return sqlJournalStatusItems( diff --git a/src/main/native-chat/agent-session-journal/journal-sql-status-item-schema.ts b/src/main/native-chat/agent-session-journal/journal-sql-status-item-schema.ts index c03239c09cf..55414a856c8 100644 --- a/src/main/native-chat/agent-session-journal/journal-sql-status-item-schema.ts +++ b/src/main/native-chat/agent-session-journal/journal-sql-status-item-schema.ts @@ -8,6 +8,9 @@ CREATE INDEX IF NOT EXISTS journal_proj_items_visible_clear CREATE INDEX IF NOT EXISTS journal_proj_items_visible_turn ON journal_proj_items(session_id, epoch, root, sequence, sequence_index, ordinal) WHERE hidden=0 AND turn_id IS NOT NULL; +CREATE INDEX IF NOT EXISTS journal_proj_items_visible_turn_position + ON journal_proj_items(session_id, epoch, sequence, sequence_index, ordinal) + WHERE hidden=0 AND turn_id IS NOT NULL; CREATE INDEX IF NOT EXISTS journal_proj_items_user ON journal_proj_items(session_id, epoch, sequence, sequence_index, ordinal) WHERE hidden=0 AND root=1 AND message_role='user' AND command_entry=0; @@ -17,8 +20,8 @@ CREATE INDEX IF NOT EXISTS journal_proj_items_unknown_user CREATE INDEX IF NOT EXISTS journal_proj_items_prose ON journal_proj_items(session_id, epoch, sequence, sequence_index, ordinal) WHERE hidden=0 AND root=1 AND message_role='assistant' AND command_entry=0 AND assistant_prose=1; -CREATE INDEX IF NOT EXISTS journal_proj_items_assistant - ON journal_proj_items(session_id, epoch) WHERE hidden=0 AND message_role='assistant'; +CREATE INDEX IF NOT EXISTS journal_proj_items_visible_role + ON journal_proj_items(session_id, epoch, message_role, entry_key) WHERE hidden=0; CREATE INDEX IF NOT EXISTS journal_proj_items_pending_prompt ON journal_proj_items(session_id, epoch, sequence, sequence_index, ordinal) WHERE hidden=0 AND kind IN ('approval','question') AND lifecycle_state='pending'; diff --git a/src/main/native-chat/agent-session-journal/journal-sql-status-items.ts b/src/main/native-chat/agent-session-journal/journal-sql-status-items.ts index 4ce74784487..ba59f7eb80a 100644 --- a/src/main/native-chat/agent-session-journal/journal-sql-status-items.ts +++ b/src/main/native-chat/agent-session-journal/journal-sql-status-items.ts @@ -17,6 +17,10 @@ export function* sqlJournalStatusItems( let single = false let unordered = false switch (selection.kind) { + case 'clear': + predicates.push('context_clear=1') + single = true + break case 'boundary': predicates.push('(turn_id IS NOT NULL OR context_clear=1)') single = true diff --git a/src/main/native-chat/agent-session-journal/journal-sql-status-request-items.ts b/src/main/native-chat/agent-session-journal/journal-sql-status-request-items.ts new file mode 100644 index 00000000000..bb7cb557c74 --- /dev/null +++ b/src/main/native-chat/agent-session-journal/journal-sql-status-request-items.ts @@ -0,0 +1,90 @@ +import type { JournalSqlScope } from './journal-sql-scope' +import type { AgentJournalRenderItem } from '../../../shared/agent-session/journal/agent-session-journal-types' +import { compareJournalStatusPositions, type JournalStatusItem } from './journal-status-items' + +const PAGE = 128 + +/** Existence needs no payload; count all reached user metadata, including associated rows. */ +export function sqlHasStatusRequestItem(scope: JournalSqlScope): boolean { + for (const predicate of ['turn_id IS NOT NULL', "message_role='assistant'"]) { + const found = scope.db + .prepare(`SELECT entry_key FROM journal_proj_items + WHERE session_id=? AND epoch=? AND hidden=0 AND ${predicate} LIMIT 1`) + .get(...scope.prefix) + if (found) { + scope.examined(found) + return true + } + } + let after = '' + for (;;) { + const rows = scope.db + .prepare(`SELECT i.entry_key, + EXISTS(SELECT 1 FROM journal_proj_submissions s WHERE s.session_id=i.session_id + AND s.epoch=i.epoch AND s.current=1 AND s.item_key=i.entry_key) AS submitted + FROM journal_proj_items i WHERE i.session_id=? AND i.epoch=? AND i.hidden=0 + AND i.message_role='user' AND i.entry_key>? ORDER BY i.entry_key LIMIT ?`) + .all(...scope.prefix, after, PAGE) + rows.forEach((row) => scope.examined(row)) + if (rows.some((row) => row.submitted === 0)) { + return true + } + const last = rows.at(-1) + if (rows.length < PAGE || !last) { + return false + } + after = String(last.entry_key) + } +} + +/** Failure evidence drives the join; only candidate metadata is sorted in render order. */ +export function* sqlFailedStatusItems( + scope: JournalSqlScope, + item: (id: string) => AgentJournalRenderItem | undefined, + floor: number +): Iterable { + const candidates: { key: string; position: JournalStatusItem['position'] }[] = [] + let after = '' + for (;;) { + const rows = scope.db + .prepare(`SELECT p.id, s.accepted_seq, i.entry_key, i.sequence, + i.sequence_index, i.ordinal, i.hidden, i.root + FROM journal_proj_places p + LEFT JOIN journal_proj_submissions s ON s.session_id=p.session_id AND s.epoch=p.epoch + AND s.client_message_id=p.id AND s.current=1 + LEFT JOIN journal_proj_items i ON i.session_id=s.session_id AND i.epoch=s.epoch AND i.entry_key=s.item_key + WHERE p.session_id=? AND p.epoch=? AND p.index_id='failed-requests' AND p.id>? + ORDER BY p.id LIMIT ?`) + .all(...scope.prefix, after, PAGE) + for (const row of rows) { + scope.examined(row) + if ( + typeof row.entry_key === 'string' && + row.hidden === 0 && + row.root === 1 && + (!floor || (Number(row.accepted_seq ?? 0) > floor && Number(row.sequence) > floor)) + ) { + candidates.push({ + key: row.entry_key, + position: { + sequence: Number(row.sequence), + sequenceIndex: Number(row.sequence_index), + ordinal: Number(row.ordinal) + } + }) + } + } + const last = rows.at(-1) + if (rows.length < PAGE || !last) { + break + } + after = String(last.id) + } + candidates.sort((a, b) => compareJournalStatusPositions(b.position, a.position)) + for (const candidate of candidates) { + const current = item(String(JSON.parse(candidate.key))) + if (current) { + yield { item: current, position: candidate.position } + } + } +} diff --git a/src/main/native-chat/agent-session-journal/journal-state-queries.ts b/src/main/native-chat/agent-session-journal/journal-state-queries.ts index 9af04b7cca2..9e05d28d41d 100644 --- a/src/main/native-chat/agent-session-journal/journal-state-queries.ts +++ b/src/main/native-chat/agent-session-journal/journal-state-queries.ts @@ -10,6 +10,8 @@ import type { JournalStatusItem, JournalStatusItemSelection } from './journal-st /** Each live range query names its population; whole-state restore/export remains memory-only. */ export type JournalStateQueries = { + hasStatusRequestItem: (state: JournalReducerState) => boolean + failedStatusItems: (state: JournalReducerState, floor: number) => Iterable statusItems: ( state: JournalReducerState, selection: JournalStatusItemSelection diff --git a/src/main/native-chat/agent-session-journal/journal-status-items.ts b/src/main/native-chat/agent-session-journal/journal-status-items.ts index 4233890d8dd..2a8b8be1692 100644 --- a/src/main/native-chat/agent-session-journal/journal-status-items.ts +++ b/src/main/native-chat/agent-session-journal/journal-status-items.ts @@ -11,6 +11,7 @@ export type JournalStatusPosition = { sequence: number; sequenceIndex: number; o export type JournalStatusItem = { item: AgentJournalRenderItem; position: JournalStatusPosition } export type JournalStatusItemSelection = | { kind: 'boundary'; raw?: true } + | { kind: 'clear' } | { kind: 'turns'; root?: true; floor?: number; direction?: 'asc' | 'desc' } | { kind: 'users'; floor?: number; unknown?: true } | { kind: 'assistant-prose'; floor?: number } @@ -52,6 +53,9 @@ export function* memoryJournalStatusItems( root && body.kind === 'message' && body.role === 'user' && body.command === undefined let matches: boolean switch (selection.kind) { + case 'clear': + matches = isAgentSessionContextClear(body) + break case 'boundary': matches = readAgentJournalTurn(body) !== null || isAgentSessionContextClear(body) break @@ -114,6 +118,7 @@ export function* memoryJournalStatusItems( }) const single = selection.kind === 'boundary' || + selection.kind === 'clear' || selection.kind === 'prompt' || selection.kind === 'tools' || selection.kind === 'assistant-exists' diff --git a/src/main/native-chat/agent-session-journal/journal-status-request-items.ts b/src/main/native-chat/agent-session-journal/journal-status-request-items.ts new file mode 100644 index 00000000000..50ed87d047a --- /dev/null +++ b/src/main/native-chat/agent-session-journal/journal-status-request-items.ts @@ -0,0 +1,56 @@ +import type { JournalReducerState } from './projection/journal-reducer' +import { memoryJournalMap } from './journal-memory-collections' +import { readAgentJournalTurn } from '../../../shared/agent-session/lifecycle/agent-session-turn-record' +import { agentJournalSubmissionKey } from '../../../shared/agent-session/journal/agent-session-journal-item-key' +import { journalInputPresentationMember } from './input-order/journal-input-obligations' +import { isRootAgentJournalItem } from '../../../shared/agent-session/journal/agent-session-journal-producer' +import { classifyDispatchRejection } from '../../../shared/agent-session/requests/structured-agent-session-dispatch-rejection' +import { compareJournalStatusPositions, type JournalStatusItem } from './journal-status-items' + +export function memoryHasStatusRequestItem(state: JournalReducerState): boolean { + const submitted = new Set( + [...memoryJournalMap(state.submissions).keys()].map(agentJournalSubmissionKey) + ) + return [...memoryJournalMap(state.items).values()].some( + (item) => + journalInputPresentationMember(state, item.itemId) && + (readAgentJournalTurn(item.body) !== null || + (item.body.kind === 'message' && + (item.body.role === 'assistant' || + (item.body.role === 'user' && !submitted.has(item.itemId))))) + ) +} + +export function memoryFailedStatusItems( + state: JournalReducerState, + floor: number +): Iterable { + const rejected = new Set( + [...memoryJournalMap(state.submissions).values()] + .filter( + (send) => + send.dispatchState === 'rejected' && + (!floor || (send.acceptedSequence ?? 0) > floor) && + classifyDispatchRejection(send).verdict === 'failure' + ) + .map((send) => agentJournalSubmissionKey(send.clientMessageId)) + ) + const rows: JournalStatusItem[] = [] + let ordinal = 0 + for (const item of memoryJournalMap(state.items).values()) { + const position = { + sequence: item.sequence, + sequenceIndex: item.sequenceIndex ?? 0, + ordinal: ordinal++ + } + if ( + rejected.has(item.itemId) && + (!floor || item.sequence > floor) && + journalInputPresentationMember(state, item.itemId) && + isRootAgentJournalItem(item) + ) { + rows.push({ item, position }) + } + } + return rows.sort((a, b) => compareJournalStatusPositions(b.position, a.position)) +} diff --git a/src/main/native-chat/agent-session-journal/journal-status-requests.test.ts b/src/main/native-chat/agent-session-journal/journal-status-requests.test.ts new file mode 100644 index 00000000000..268db9e8489 --- /dev/null +++ b/src/main/native-chat/agent-session-journal/journal-status-requests.test.ts @@ -0,0 +1,240 @@ +import { afterEach, expect, it } from 'vitest' +import type { + AgentJournalRenderItem, + AgentJournalSubmission +} from '../../../shared/agent-session/journal/agent-session-journal-types' +import Database from '../../sqlite/sync-database' +import { createJournalReducerState } from './projection/journal-reducer' +import { JournalSqlReducer } from './journal-sql-reducer' +import { JournalSqlScope } from './journal-sql-scope' +import { journalSqlProjectionSchema } from './journal-sql-projection-schema' +import { journalInputOrder } from './input-order/journal-input-order' +import { journalDispatchRowBuilder } from './writing/journal-row-builders' +import { readJournalRequestStatus } from './journal-status-requests' + +const databases: Database.Database[] = [] +afterEach(() => databases.splice(0).forEach((db) => db.close())) +function fixture(backend: 'memory' | 'sql') { + if (backend === 'memory') { + return createJournalReducerState('session', 'epoch') + } + const db = new Database(':memory:') + databases.push(db) + db.exec(journalSqlProjectionSchema()) + return new JournalSqlReducer(new JournalSqlScope(db, 'session', 'epoch'), 'epoch').state +} +function row( + itemId: string, + sequence: number, + body: AgentJournalRenderItem['body'], + extra: Partial = {} +): AgentJournalRenderItem { + return { itemId, sequence, revision: 1, observedAt: 1, body, ...extra } +} +const message = (role: 'user' | 'assistant', text: string): AgentJournalRenderItem['body'] => ({ + kind: 'message', + role, + blocks: [{ type: 'text', text }] +}) + +it.each(['memory', 'sql'] as const)( + 'selects request order, command dependencies and assistant barriers in %s', + (backend) => { + const state = fixture(backend) + state.items.set( + 'done', + row( + 'done', + 10, + { kind: 'turn', turnId: 'done', state: 'completed', outcome: 'success', completedAt: 100 }, + { sequenceIndex: 2 } + ) + ) + state.items.set( + 'legacy', + row( + 'legacy', + 10, + { + kind: 'status', + text: 'Legacy', + turnLifecycle: { turnId: 'legacy', state: 'interrupted' } + }, + { sequenceIndex: 1 } + ) + ) + const command = { + kind: 'message' as const, + role: 'assistant' as const, + command: { name: 'compact' as const }, + blocks: [] + } + state.items.set('opener', row('opener', 1, command)) + state.items.set( + 'compact', + row('compact', 11, { + kind: 'turn', + turnId: 'compact', + state: 'completed', + outcome: 'failure', + userItemId: 'opener', + completedAt: 110 + }) + ) + state.items.set('prose', row('prose', 12, message('assistant', 'Root reply'))) + state.items.set( + 'tool-only', + row('tool-only', 13, { kind: 'message', role: 'assistant', blocks: [] }) + ) + state.items.set( + 'command-result', + row('command-result', 14, message('assistant', 'Command result'), { + turnScope: { kind: 'turn', turnItemId: 'compact' } + }) + ) + state.items.set( + 'child', + row('child', 90, message('assistant', 'Child reply'), { agentId: 'child' }) + ) + expect(readJournalRequestStatus(state)).toEqual({ + hasRequest: true, + latestPrompt: '', + latestRequest: { + kind: 'turn', + id: 'done', + turnState: 'completed', + outcome: 'success', + settledAt: 100 + }, + lastAssistantMessage: 'Root reply' + }) + state.items.set('opener', row('opener', 1, message('user', 'Ordinary opener'))) + expect(readJournalRequestStatus(state)).toMatchObject({ + latestPrompt: 'Ordinary opener', + latestRequest: { id: 'compact', outcome: 'failure' }, + lastAssistantMessage: 'Command result' + }) + state.items.set( + 'steer', + row('steer', 15, message('user', 'Steered prompt'), { + turnScope: { kind: 'turn', turnItemId: 'done' } + }) + ) + expect(readJournalRequestStatus(state)).toEqual({ + hasRequest: true, + latestPrompt: 'Steered prompt', + latestRequest: { + kind: 'turn', + id: 'compact', + turnState: 'completed', + outcome: 'failure', + settledAt: 110 + } + }) + state.items.set( + 'barrier', + row('barrier', 16, message('user', 'Unknown request'), { turnScope: { kind: 'unknown' } }) + ) + expect(readJournalRequestStatus(state).latestRequest).toBeNull() + state.items.set( + 'barrier', + row('barrier', 16, message('user', 'Thread request'), { turnScope: { kind: 'thread' } }) + ) + expect(readJournalRequestStatus(state).latestRequest?.id).toBe('compact') + } +) + +it.each(['memory', 'sql'] as const)( + 'keeps pre-clear existence/prompt, strict acceptance cuts and nonmessage refusals in %s', + (backend) => { + const state = fixture(backend) + expect(readJournalRequestStatus(state)).toEqual({ + hasRequest: false, + latestPrompt: '', + latestRequest: null + }) + state.items.set('prompt', row('prompt', 1, message('user', 'Keep the prompt'))) + state.items.set( + 'self', + row('self', 2, { + kind: 'turn', + turnId: 'self', + state: 'completed', + userItemId: 'self', + completedAt: 20 + }) + ) + expect(readJournalRequestStatus(state).latestRequest).toMatchObject({ + id: 'self', + selfStarted: true + }) + const refusal: AgentJournalSubmission = { + clientMessageId: 'refused', + fence: 1, + payloadFingerprint: 'fp', + dispatchState: 'rejected', + providerItemId: null, + reason: null, + submittedAt: 3, + resolvedAt: 30, + acceptedSequence: 3, + rejection: { kind: 'writeFailed' } + } + state.submissions.set('refused', refusal) + state.items.set('orca:refused', row('orca:refused', 4, { kind: 'status', text: 'Refused' })) + const order = journalInputOrder(state) + const refresh = () => + order.afterRow( + state, + journalDispatchRowBuilder(() => state, { + clientMessageId: 'refused', + state: 'unknown', + fence: 1 + })(4, 4) + ) + refresh() + expect(readJournalRequestStatus(state).latestRequest).toEqual({ + kind: 'refused-send', + id: 'orca:refused', + turnState: null, + outcome: 'failure', + settledAt: 30 + }) + const clear = { + kind: 'status' as const, + text: 'Cleared', + contextClear: { operationId: 'clear', afterFence: 1, clearedAt: 5 } + } + state.items.set('clear', row('clear', 5, clear)) + state.items.set( + 'orca:refused', + row('orca:refused', 6, { kind: 'status', text: 'Refused after clear' }) + ) + state.submissions.set('refused', { ...refusal, acceptedSequence: 5 }) + refresh() + expect(readJournalRequestStatus(state)).toEqual({ + hasRequest: true, + latestPrompt: 'Keep the prompt', + latestRequest: null + }) + state.submissions.set('refused', { ...refusal, acceptedSequence: 6 }) + refresh() + expect(readJournalRequestStatus(state).latestRequest?.id).toBe('orca:refused') + state.items.set('orca:hidden-clear', row('orca:hidden-clear', 7, clear)) + state.inputs.rejections.set('hidden-clear', { ...refusal, clientMessageId: 'hidden-clear' }) + expect(readJournalRequestStatus(state).latestRequest?.id).toBe('orca:refused') + state.items.delete('prompt') + state.items.delete('self') + state.items.delete('orca:refused') + state.submissions.delete('refused') + state.items.set( + 'child-user', + row('child-user', 8, message('user', 'Provider child'), { agentId: 'child' }) + ) + expect(readJournalRequestStatus(state)).toEqual({ + hasRequest: true, + latestPrompt: '', + latestRequest: null + }) + } +) diff --git a/src/main/native-chat/agent-session-journal/journal-status-requests.ts b/src/main/native-chat/agent-session-journal/journal-status-requests.ts new file mode 100644 index 00000000000..2e18321cc99 --- /dev/null +++ b/src/main/native-chat/agent-session-journal/journal-status-requests.ts @@ -0,0 +1,125 @@ +import { + hasStructuredAgentSessionRequest, + latestStructuredAgentSessionAssistantMessage, + latestStructuredAgentSessionPrompt, + structuredAgentSessionRequestFromItem, + type StructuredAgentSessionLatestRequest +} from '../../../shared/agent-session/requests/structured-agent-session-latest-request' +import { + commandTurnsByBody, + isStructuredAgentSessionCommandRow +} from '../../../shared/agent-session/structured-agent-session-command-entry' +import { + AGENT_STATUS_MAX_FIELD_LENGTH, + normalizeOptionalField, + normalizePromptField +} from '../../../shared/agent-status/contracts/agent-status-field-normalization' +import type { JournalReducerState } from './projection/journal-reducer' +import { renderJournalStatusItem } from './projection/journal-public-read' +import { journalInputOrder } from './input-order/journal-input-order' +import { compareJournalStatusPositions, type JournalStatusItem } from './journal-status-items' + +export type JournalRequestStatus = { + hasRequest: boolean + latestPrompt: string + latestRequest: StructuredAgentSessionLatestRequest | null + lastAssistantMessage?: string +} + +function* newestCandidates( + ...populations: Iterable[] +): Iterable { + const iterators = populations.map((items) => items[Symbol.iterator]()) + const next = iterators.map((iterator) => iterator.next()) + for (;;) { + let winner = -1 + next.forEach((candidate, index) => { + if ( + !candidate.done && + (winner === -1 || + compareJournalStatusPositions(candidate.value.position, next[winner]!.value!.position) > + 0) + ) { + winner = index + } + }) + if (winner === -1) { + return + } + yield next[winner]!.value! + next[winner] = iterators[winner]!.next() + } +} + +/** Named populations preserve whole-history existence/prompt and strict current-context verdicts. */ +export function readJournalRequestStatus( + state: JournalReducerState, + currentFence?: number | null +): JournalRequestStatus { + const order = journalInputOrder(state) + const selects = (selection: Parameters[1]) => + state.queries.statusItems(state, selection) + const hasRequest = + state.queries.hasStatusRequestItem(state) || + hasStructuredAgentSessionRequest([], order.statusInputs(state, []), currentFence) + if (!hasRequest) { + return { hasRequest: false, latestPrompt: '', latestRequest: null } + } + const prompt = selects({ kind: 'prompt' })[Symbol.iterator]().next().value?.item + const floor = selects({ kind: 'clear' })[Symbol.iterator]().next().value?.item.sequence ?? 0 + const bodyOf = (id: string) => { + const item = renderJournalStatusItem(state, id) + return item && (!floor || item.sequence > floor) ? item.body : null + } + const commands = commandTurnsByBody(bodyOf) + let latestRequest: StructuredAgentSessionLatestRequest | null = null + for (const { item } of newestCandidates( + selects({ kind: 'turns', root: true, floor }), + selects({ kind: 'users', unknown: true, floor }), + state.queries.failedStatusItems(state, floor) + )) { + const submission = order.inputForItem(item.itemId) + const current = + submission && (!floor || (submission.acceptedSequence ?? 0) > floor) ? submission : undefined + const displayed = renderJournalStatusItem(state, item.itemId) + if (!displayed) { + continue + } + const candidate = structuredAgentSessionRequestFromItem( + displayed, + current, + (id) => + order + .statusInputs(state, [item]) + .some( + (send) => + send.answeredInTurn?.via === 'steer' && + send.answeredInTurn.turnItemId === id && + (!floor || (send.acceptedSequence ?? 0) > floor) + ), + commands + ) + if (candidate !== undefined) { + latestRequest = candidate + break + } + } + let assistant = '' + for (const { item } of newestCandidates( + selects({ kind: 'assistant-prose', floor }), + selects({ kind: 'users', floor }) + )) { + if (isStructuredAgentSessionCommandRow(item, commands)) { + continue + } + assistant = latestStructuredAgentSessionAssistantMessage([item], bodyOf) + break + } + const lastAssistantMessage = normalizeOptionalField(assistant, AGENT_STATUS_MAX_FIELD_LENGTH) + return { + hasRequest: true, + latestPrompt: normalizePromptField(prompt ? latestStructuredAgentSessionPrompt([prompt]) : ''), + latestRequest, + ...(lastAssistantMessage ? { lastAssistantMessage } : {}) + } +} diff --git a/src/main/native-chat/agent-session-journal/journal-status-state.test.ts b/src/main/native-chat/agent-session-journal/journal-status-state.test.ts new file mode 100644 index 00000000000..b265acfe5ad --- /dev/null +++ b/src/main/native-chat/agent-session-journal/journal-status-state.test.ts @@ -0,0 +1,177 @@ +import { afterEach, expect, it } from 'vitest' +import type { AgentJournalRenderItem } from '../../../shared/agent-session/journal/agent-session-journal-types' +import Database from '../../sqlite/sync-database' +import { createJournalReducerState } from './projection/journal-reducer' +import { JournalSqlReducer } from './journal-sql-reducer' +import { JournalSqlScope } from './journal-sql-scope' +import { journalSqlProjectionSchema } from './journal-sql-projection-schema' +import { readJournalStatusState } from './journal-status-state' + +const databases: Database.Database[] = [] +afterEach(() => databases.splice(0).forEach((db) => db.close())) +function fixture(backend: 'memory' | 'sql') { + if (backend === 'memory') { + return createJournalReducerState('session', 'epoch') + } + const db = new Database(':memory:') + databases.push(db) + db.exec(journalSqlProjectionSchema()) + return new JournalSqlReducer(new JournalSqlScope(db, 'session', 'epoch'), 'epoch').state +} +function row( + itemId: string, + sequence: number, + body: AgentJournalRenderItem['body'], + extra: Partial = {} +): AgentJournalRenderItem { + return { itemId, sequence, revision: 1, observedAt: sequence * 10, body, ...extra } +} + +it.each(['memory', 'sql'] as const)( + 'uses the current boundary and positional tools, then dates the settled verdict in %s', + (backend) => { + const state = fixture(backend) + state.items.set( + 'ask', + row('ask', 1, { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'Go' }] }) + ) + const running = { + kind: 'turn' as const, + turnId: 'turn', + state: 'running' as const, + requestedAt: 100 + } + state.items.set('turn', row('turn', 2, running)) + state.items.set( + 'call', + row( + 'call', + 3, + { kind: 'tool-call', name: 'Read', state: 'running', input: { file_path: 'src/a.ts' } }, + { turnScope: { kind: 'turn', turnItemId: 'other-turn' } } + ) + ) + state.items.set( + 'diff', + row('diff', 4, { + kind: 'diff', + path: 'src/b.ts', + patch: { head: '@@\n+x', byteLength: 5, digest: 'd', truncated: false } + }) + ) + expect(readJournalStatusState(state)).toEqual({ + summary: { + status: 'working', + latestPrompt: 'Go', + toolName: 'Read', + toolInput: 'src/a.ts', + statusStartedAt: 100 + }, + latestRequest: { + kind: 'turn', + id: 'turn', + turnState: 'running', + outcome: null, + settledAt: undefined + }, + owesWork: true, + pendingPromptIds: [] + }) + state.items.set( + 'call', + row('call', 3, { + kind: 'tool-call', + name: 'Read', + state: 'completed', + input: { file_path: 'src/a.ts' } + }) + ) + expect(readJournalStatusState(state).summary).toMatchObject({ + toolName: 'Diff', + toolInput: 'src/b.ts' + }) + state.items.set( + 'turn', + row('turn', 5, { ...running, state: 'completed', outcome: 'success', completedAt: 500 }) + ) + expect(readJournalStatusState(state)).toEqual({ + summary: { status: 'idle', latestPrompt: 'Go', turnOutcome: 'success', statusStartedAt: 500 }, + latestRequest: { + kind: 'turn', + id: 'turn', + turnState: 'completed', + outcome: 'success', + settledAt: 500 + }, + owesWork: false, + pendingPromptIds: [] + }) + state.items.set('turn', row('turn', 5, { ...running, state: 'interrupted', completedAt: 500 })) + state.items.set( + 'quit', + row( + 'quit', + 6, + { kind: 'status', text: 'Quit', orcaStop: { cause: 'quit' } }, + { turnScope: { kind: 'turn', turnItemId: 'turn' }, agentId: 'child' } + ) + ) + expect(readJournalStatusState(state).summary).toEqual({ + status: 'idle', + latestPrompt: 'Go', + turnOutcome: 'cancellation', + statusStartedAt: 500 + }) + } +) + +it.each(['memory', 'sql'] as const)( + 'keeps pending timestamps independent of scope and rereads row-free live authority in %s', + (backend) => { + const state = fixture(backend) + state.items.set( + 'turn', + row('turn', 1, { kind: 'turn', turnId: 'turn', state: 'running', requestedAt: 100 }) + ) + const question = { + kind: 'question' as const, + question: 'Continue?', + options: [], + resolution: { + state: 'pending' as const, + selectedOptionId: null, + resolvedBy: null, + resolvedAt: null + } + } + state.items.set('root-first', row('root-first', 3, question, { observedAt: 30 })) + state.items.set('child', row('child', 4, question, { observedAt: 10, agentId: 'child' })) + state.items.set('root-second', row('root-second', 5, question, { observedAt: 20 })) + const current = new Set(['child']) + const scope = { isCurrentItem: (id: string) => current.has(id), owesSend: () => false } + expect(readJournalStatusState(state, 1, scope)).toEqual({ + summary: { status: 'attention', latestPrompt: '', statusStartedAt: 20 }, + latestRequest: { + kind: 'turn', + id: 'turn', + turnState: 'running', + outcome: null, + settledAt: undefined + }, + owesWork: false, + pendingPromptIds: ['child'] + }) + current.clear() + expect(readJournalStatusState(state, 1, scope)).toMatchObject({ + summary: { status: 'idle' }, + owesWork: false, + pendingPromptIds: [] + }) + current.add('turn') + expect(readJournalStatusState(state, 1, scope)).toMatchObject({ + summary: { status: 'working', statusStartedAt: 100 }, + owesWork: true, + pendingPromptIds: [] + }) + } +) diff --git a/src/main/native-chat/agent-session-journal/journal-status-state.ts b/src/main/native-chat/agent-session-journal/journal-status-state.ts new file mode 100644 index 00000000000..ab019759817 --- /dev/null +++ b/src/main/native-chat/agent-session-journal/journal-status-state.ts @@ -0,0 +1,123 @@ +import type { AgentJournalRenderItem } from '../../../shared/agent-session/journal/agent-session-journal-types' +import type { StructuredAgentSessionWorkScope } from '../../../shared/agent-session/view/structured-agent-session-main-agent-working' +import { isStructuredAgentSessionMainAgentWorking } from '../../../shared/agent-session/view/structured-agent-session-main-agent-working' +import { activeStructuredAgentSessionTurnId } from '../../../shared/agent-session/view/structured-agent-session-live-turn' +import { readAgentJournalTurn } from '../../../shared/agent-session/lifecycle/agent-session-turn-record' +import { + isStructuredAgentSessionToolAction, + structuredAgentSessionToolCallBlock +} from '../../../shared/agent-session/structured-agent-session-tool-call-block' +import { nativeChatStatusRequestOutcome } from '../../../shared/native-chat/native-chat-orca-stop-cut' +import { structuredAgentSessionStatusStartedAt } from '../../../shared/agent-session/view/structured-agent-session-status-started-at' +import type { projectStructuredAgentSessionStatusState } from '../../../shared/agent-session/view/structured-agent-session-projection' +import { + AGENT_STATUS_TOOL_INPUT_MAX_LENGTH, + normalizeOptionalField +} from '../../../shared/agent-status/contracts/agent-status-field-normalization' +import { AGENT_STATUS_TOOL_NAME_MAX_LENGTH } from '../../../shared/agent-status/contracts/agent-status-types' +import { describeToolInput } from '../../../shared/native-chat/tools/native-chat-tool-summary' +import type { JournalReducerState } from './projection/journal-reducer' +import { journalInputOrder } from './input-order/journal-input-order' +import { renderJournalStatusItem } from './projection/journal-public-read' +import { readJournalOrcaStopCut } from './journal-status-cuts' +import { readJournalRequestStatus } from './journal-status-requests' + +export type JournalStatusState = ReturnType + +/** Compose named facts in one snapshot; scope remains the caller's live execution authority. */ +export function readJournalStatusState( + state: JournalReducerState, + currentFence?: number | null, + scope?: StructuredAgentSessionWorkScope +): JournalStatusState { + const requests = readJournalRequestStatus(state, currentFence) + if (!requests.hasRequest) { + return { + summary: { status: null, latestPrompt: '' }, + latestRequest: null, + owesWork: false, + pendingPromptIds: [] + } + } + const selects = (selection: Parameters[1]) => + state.queries.statusItems(state, selection) + const floor = selects({ kind: 'clear' })[Symbol.iterator]().next().value?.item.sequence ?? 0 + const pending = [...selects({ kind: 'pending-prompts', floor })].flatMap(({ item }) => { + const displayed = renderJournalStatusItem(state, item.itemId) + return displayed ? [displayed] : [] + }) + const actionable = pending.filter((item) => !scope || scope.isCurrentItem(item.itemId)) + const boundary = selects({ kind: 'boundary' })[Symbol.iterator]().next().value + const currentBoundary = + boundary && (!floor || boundary.item.sequence > floor) ? boundary : undefined + const active = activeStructuredAgentSessionTurnId( + currentBoundary ? [currentBoundary.item] : [], + scope && ((item) => scope.isCurrentItem(item.itemId)) + ) + const submissions = journalInputOrder(state) + .statusInputs(state, []) + .filter((send) => !floor || (send.acceptedSequence ?? 0) > floor) + const owesWork = isStructuredAgentSessionMainAgentWorking( + active, + submissions, + currentFence, + scope + ) + const status = actionable.length > 0 ? 'attention' : owesWork ? 'working' : 'idle' + let tool: AgentJournalRenderItem | null = null + if ( + status === 'working' && + currentBoundary && + readAgentJournalTurn(currentBoundary.item.body)?.state === 'running' + ) { + const selected = + selects({ kind: 'tools', after: currentBoundary.position, running: true }) + [Symbol.iterator]() + .next().value ?? + selects({ kind: 'tools', after: currentBoundary.position })[Symbol.iterator]().next().value + tool = selected ? renderJournalStatusItem(state, selected.item.itemId) : null + } + const block = + tool && isStructuredAgentSessionToolAction(tool.body) + ? structuredAgentSessionToolCallBlock(tool.body, tool.itemId) + : null + const toolName = block + ? normalizeOptionalField(block.name, AGENT_STATUS_TOOL_NAME_MAX_LENGTH) + : undefined + const toolInput = block + ? normalizeOptionalField(describeToolInput(block.input), AGENT_STATUS_TOOL_INPUT_MAX_LENGTH) + : undefined + const request = status === 'idle' ? requests.latestRequest : null + const turnOutcome = nativeChatStatusRequestOutcome( + request, + request ? readJournalOrcaStopCut(state, floor) : null + ) + const latestTurn = + status === 'working' + ? selects({ kind: 'turns', floor })[Symbol.iterator]().next().value?.item + : undefined + const timestampItems = status === 'attention' ? pending : latestTurn ? [latestTurn] : [] + const statusStartedAt = structuredAgentSessionStatusStartedAt( + status, + timestampItems, + submissions, + currentFence, + request + ) + return { + latestRequest: requests.latestRequest, + owesWork: status !== 'idle' && owesWork, + pendingPromptIds: status === 'attention' ? actionable.map((item) => item.itemId) : [], + summary: { + status, + latestPrompt: requests.latestPrompt, + ...(toolName ? { toolName } : {}), + ...(toolInput ? { toolInput } : {}), + ...(requests.lastAssistantMessage + ? { lastAssistantMessage: requests.lastAssistantMessage } + : {}), + ...(turnOutcome ? { turnOutcome } : {}), + ...(statusStartedAt !== undefined ? { statusStartedAt } : {}) + } + } +} diff --git a/src/shared/agent-session/requests/structured-agent-session-latest-request.ts b/src/shared/agent-session/requests/structured-agent-session-latest-request.ts index c19c23fbb78..c0680662d00 100644 --- a/src/shared/agent-session/requests/structured-agent-session-latest-request.ts +++ b/src/shared/agent-session/requests/structured-agent-session-latest-request.ts @@ -61,53 +61,67 @@ export function latestStructuredAgentSessionRequest( const commandTurns = commandTurnsOf(items, bodyOf) for (let index = items.length - 1; index >= 0; index -= 1) { const item = items[index] - // Commands retain the last real request’s verdict. - if ( - !item || - !isRootAgentJournalItem(item) || - isStructuredAgentSessionNonRequestRow(item, commandTurns) - ) { - continue - } - if ( - item.body.kind === 'message' && - item.body.role === 'user' && - item.turnScope?.kind === 'unknown' - ) { - return null - } - const turn = readAgentJournalTurn(item.body) - if (turn) { - return { - kind: 'turn', - id: turn.turnId, - turnState: turn.state, - outcome: readAgentJournalTurnOutcome(turn), - settledAt: turn.state === 'running' ? undefined : turnEndedAt(item, turn), - ...(turn.userItemId === item.itemId && !steeredInto(submissions, item.itemId) - ? { selfStarted: true as const } - : {}) - } - } - const submission = rejected.get(item.itemId) - // Rejection relocates a refused steer to the thread, but its turn remains the request. - if ( - submission && - submission.answeredInTurn?.via !== 'steer' && - classifyDispatchRejection(submission).verdict === 'failure' - ) { - return { - kind: 'refused-send', - id: item.itemId, - turnState: null, - outcome: 'failure', - settledAt: submission.resolvedAt ?? submission.submittedAt - } + const request = + item && + structuredAgentSessionRequestFromItem( + item, + rejected.get(item.itemId), + (turnItemId) => steeredInto(submissions, turnItemId), + commandTurns + ) + if (request !== undefined) { + return request } } return null } +/** Undefined skips a candidate; null is the unknown-user barrier that clears the verdict. */ +export function structuredAgentSessionRequestFromItem( + item: AgentJournalRenderItem, + rejected: AgentJournalSubmission | undefined, + steered: (turnItemId: string) => boolean, + commandTurns: Pick, 'has'> +): StructuredAgentSessionLatestRequest | null | undefined { + if (!isRootAgentJournalItem(item) || isStructuredAgentSessionNonRequestRow(item, commandTurns)) { + return undefined + } + if ( + item.body.kind === 'message' && + item.body.role === 'user' && + item.turnScope?.kind === 'unknown' + ) { + return null + } + const turn = readAgentJournalTurn(item.body) + if (turn) { + return { + kind: 'turn', + id: turn.turnId, + turnState: turn.state, + outcome: readAgentJournalTurnOutcome(turn), + settledAt: turn.state === 'running' ? undefined : turnEndedAt(item, turn), + ...(turn.userItemId === item.itemId && !steered(item.itemId) + ? { selfStarted: true as const } + : {}) + } + } + if ( + rejected?.dispatchState === 'rejected' && + rejected.answeredInTurn?.via !== 'steer' && + classifyDispatchRejection(rejected).verdict === 'failure' + ) { + return { + kind: 'refused-send', + id: item.itemId, + turnState: null, + outcome: 'failure', + settledAt: rejected.resolvedAt ?? rejected.submittedAt + } + } + return undefined +} + /** A user message steered into a turn the agent started makes it the user's turn too. */ function steeredInto(submissions: readonly AgentJournalSubmission[], turnItemId: string): boolean { return submissions.some( diff --git a/src/shared/native-chat/native-chat-orca-stop-cut.ts b/src/shared/native-chat/native-chat-orca-stop-cut.ts index a115585f9fb..61487a7e47a 100644 --- a/src/shared/native-chat/native-chat-orca-stop-cut.ts +++ b/src/shared/native-chat/native-chat-orca-stop-cut.ts @@ -121,5 +121,16 @@ export function nativeChatStatusTurnOutcome( : null const stop = verdict === 'interruption' ? latestNativeChatOrcaStopCut(items, submissions, bodyOf) : null - return stop && stop.cause !== 'crash' ? 'cancellation' : verdict + return nativeChatStatusRequestOutcome(request, stop) +} + +/** Named database readers supply the same selected cut without rendering the chat. */ +export function nativeChatStatusRequestOutcome( + request: StructuredAgentSessionLatestRequest | null, + stop: NativeChatOrcaStopCut | null +): AgentTurnOutcome | null { + const verdict = request + ? agentTurnVerdict({ state: request.turnState, outcome: request.outcome }) + : null + return verdict === 'interruption' && stop && stop.cause !== 'crash' ? 'cancellation' : verdict }