Derive chat status from named indexed populations

This commit is contained in:
Brennan Benson
2026-11-07 14:41:49 -08:00
parent 345fccc0ab
commit f4e49275f1
18 changed files with 929 additions and 47 deletions
@@ -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())
@@ -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<JournalStatusState>
input: JournalInputReader
usageLimitCut(): Promise<NativeChatUsageLimitCut | null>
orcaStopCut(): Promise<NativeChatOrcaStopCut | null>
@@ -59,7 +61,7 @@ type FoldedJournalReads = {
[
K in Exclude<
keyof AgentSessionJournalReads,
'visitItems' | 'contextFloor' | 'input' | 'usageLimitCut' | 'orcaStopCut'
'visitItems' | 'contextFloor' | 'input' | 'usageLimitCut' | 'orcaStopCut' | 'statusState'
>
]: (
...args: Parameters<AgentSessionJournalReads[K]>
@@ -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())),
@@ -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)
@@ -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.
@@ -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,
@@ -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<AgentJournalRenderItem>('items', JSON.stringify(id)),
floor
)
},
statusItems(_state, selection) {
facts.flush()
return sqlJournalStatusItems(
@@ -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';
@@ -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
@@ -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<JournalStatusItem> {
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 }
}
}
}
@@ -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<JournalStatusItem>
statusItems: (
state: JournalReducerState,
selection: JournalStatusItemSelection
@@ -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'
@@ -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<JournalStatusItem> {
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))
}
@@ -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> = {}
): 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
})
}
)
@@ -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<JournalStatusItem>[]
): Iterable<JournalStatusItem> {
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<typeof state.queries.statusItems>[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 } : {})
}
}
@@ -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> = {}
): 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: []
})
}
)
@@ -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<typeof projectStructuredAgentSessionStatusState>
/** 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<typeof state.queries.statusItems>[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 } : {})
}
}
}
@@ -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<ReadonlySet<string>, '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(
@@ -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
}