diff --git a/src/main/native-chat/agent-session-journal/journal-domain-queue-reads.ts b/src/main/native-chat/agent-session-journal/journal-domain-queue-reads.ts new file mode 100644 index 00000000000..00e463a8f04 --- /dev/null +++ b/src/main/native-chat/agent-session-journal/journal-domain-queue-reads.ts @@ -0,0 +1,125 @@ +import type Database from '../../sqlite/sync-database' +import type { AgentJournalCursor } from '../../../shared/agent-session/journal/agent-session-journal-identity' +import type { AgentJournalSubmission } from '../../../shared/agent-session/journal/agent-session-journal-types' +import { isQueuedAgentJournalSubmission } from '../../../shared/agent-session/requests/agent-session-queued-submission' +import type { JournalLatestStop } from './context-epochs/journal-stop-turn-end' +import { compareQueuedRows } from './input-order/journal-queued-row-index' +import { + deriveQueuePauses, + journalUserStopInForce, + type DerivedQueuePause +} from './queued-messages/queued-message-pause' +import type { QueuedMessageRow } from './queued-messages/queued-message-table' +import { + readJournalDomainQueueRow, + SELECT_JOURNAL_DOMAIN_QUEUE_ROW +} from './journal-domain-queue-rows' +import { readJournalDomainQueuePauseContext } from './journal-domain-queue-pauses' + +type Target = { sessionId: string; epoch: string } + +function liveCards(db: Database.Database, target: Target): QueuedMessageRow[] { + return db + .prepare(`${SELECT_JOURNAL_DOMAIN_QUEUE_ROW} WHERE session_id=? AND epoch=? + AND state IN ('waiting','returned') ORDER BY position, message_id`) + .all(target.sessionId, target.epoch) + .map((row) => readJournalDomainQueueRow(target.sessionId, row).card) +} + +/** Dispatched cards whose current attempt is still owed delivery, from the finite recovery index. */ +function owedDispatchedCards( + db: Database.Database, + target: Target, + owed: (submission: AgentJournalSubmission) => boolean +): QueuedMessageRow[] { + return db + .prepare(`SELECT card.message_id, card.revision, card.state, card.position, card.payload_json, + attempt.message_id AS attempt_id, attempt.payload_json AS attempt_json + FROM journal_submission_attempts AS attempt INDEXED BY journal_submission_recovery + JOIN journal_queue_cards AS card ON card.session_id=attempt.session_id + AND card.epoch=attempt.epoch AND card.message_id=attempt.admission_family_id + WHERE attempt.session_id=? AND attempt.epoch=? AND attempt.current=1 + AND (attempt.dispatch_state='pending' OR (attempt.dispatch_state='unknown' AND attempt.recovered=0)) + AND card.state='dispatched'`) + .all(target.sessionId, target.epoch) + .flatMap((row) => { + const { card } = readJournalDomainQueueRow(target.sessionId, row) + const submission: AgentJournalSubmission = JSON.parse(String(row.attempt_json)) + return card.consumedAs === String(row.attempt_id) && owed(submission) ? [card] : [] + }) +} + +/** Membership outlives automatic eligibility until the card's handoff completes. */ +export function readJournalDomainQueueList( + db: Database.Database, + target: Target +): QueuedMessageRow[] { + return [ + ...liveCards(db, target), + ...owedDispatchedCards(db, target, isQueuedAgentJournalSubmission) + ].sort(compareQueuedRows) +} + +export function readJournalDomainQueueHead( + db: Database.Database, + target: Target +): { lastSequence: number; clearedThrough: number } { + const head = db + .prepare(`SELECT last_sequence, queue_clear_sequence, queue_clear_operation_id + FROM journal_chat_state WHERE session_id=? AND epoch=?`) + .get(target.sessionId, target.epoch) + if (!head) { + throw new Error('journal queue read targets a retired chat epoch') + } + return { + lastSequence: Number(head.last_sequence), + clearedThrough: + head.queue_clear_operation_id === null ? 0 : Number(head.queue_clear_sequence ?? 0) + } +} + +/** A recovered doubt outlived its writer: nothing brings that card back to waiting. */ +export function journalDomainQueueAwaitsReopen(db: Database.Database, target: Target): boolean { + const waiting = db + .prepare(`SELECT 1 FROM journal_queue_cards INDEXED BY journal_queue_order + WHERE session_id=? AND epoch=? AND state IN ('waiting','returned') AND state='waiting' LIMIT 1`) + .get(target.sessionId, target.epoch) + return waiting !== undefined || owedDispatchedCards(db, target, () => true).length > 0 +} + +/** Clear and reopen membership are listed only for cards a pause can hold. */ +export function readJournalDomainQueuePauses( + db: Database.Database, + target: Target, + reopenFloor: AgentJournalCursor | null +): DerivedQueuePause[] { + const cards = liveCards(db, target).filter( + (card) => card.state === 'waiting' && card.holdReason === null + ) + const context = readJournalDomainQueuePauseContext( + db, + target, + reopenFloor, + cards.map((card) => card.messageId) + ) + const { cleared } = context.marks + return deriveQueuePauses({ + ...context, + marks: { + ...context.marks, + ...(cleared ? { cleared: { ...cleared, messageIds: [...context.clearMembers] } } : {}) + }, + cards + }) +} + +export function readJournalDomainUserStopInForce( + db: Database.Database, + target: Target +): JournalLatestStop | null { + const context = readJournalDomainQueuePauseContext(db, target, null, []) + return journalUserStopInForce( + context.marks, + context.latestPersonAcceptedTurnSequence ?? context.latestAcceptedTurnSequence + ) +} diff --git a/src/main/native-chat/agent-session-journal/journal-domain-submission-consume.ts b/src/main/native-chat/agent-session-journal/journal-domain-submission-consume.ts index 1a6f35e634f..9ef1882c978 100644 --- a/src/main/native-chat/agent-session-journal/journal-domain-submission-consume.ts +++ b/src/main/native-chat/agent-session-journal/journal-domain-submission-consume.ts @@ -1,5 +1,9 @@ import type Database from '../../sqlite/sync-database' -import { orchestrationMailNotice } from '../../../shared/agent-session/agent-session-message-source' +import { + orchestrationMailNotice, + type AgentMessageSource +} from '../../../shared/agent-session/agent-session-message-source' +import type { AgentJournalCursor } from '../../../shared/agent-session/journal/agent-session-journal-identity' import { journalMailSenderKey } from './journal-writer-host-facts' import type { JournalWriterOperation } from './journal-writer-command' import type { @@ -19,14 +23,24 @@ import type { QueuedMessageRow } from './queued-messages/queued-message-table' type Submission = Extract -/** Current ordered cards and exact edit holds are selected on the same writer snapshot. */ -function nextJournalDomainSubmissionCard( +export type JournalDomainQueueSelection = { + reopenFloor: AgentJournalCursor | null + /** Wall-clock milliseconds that decide which persisted edit holds are live. */ + now: number + steer: boolean + /** Manual sends pass edit holds; automatic delivery waits behind them. */ + automatic: boolean + /** Asked only for the first eligible mail card; past unavailable mail, later mail is skipped. */ + mailUnavailable: (from: AgentMessageSource) => boolean +} + +/** Current ordered cards and exact edit holds are selected on one snapshot, a bounded page at a time. */ +export function nextJournalDomainQueueCard( db: Database.Database, target: JournalDomainSubmissionTarget, - facts: JournalDomainSubmissionFacts, - steer: boolean, - savedAt: number + selection: JournalDomainQueueSelection ): QueuedMessageRow | null { + const { steer, automatic } = selection let after: { position: number; messageId: string } | undefined let pastUnavailableMail = false for (;;) { @@ -41,7 +55,7 @@ function nextJournalDomainSubmissionCard( ${after ? 'AND (card.position,card.message_id)>(?,?)' : ''} ORDER BY card.position,card.message_id LIMIT 64`) .all( - savedAt, + selection.now, target.sessionId, target.epoch, ...(after ? [after.position, after.messageId] : []) @@ -52,11 +66,11 @@ function nextJournalDomainSubmissionCard( const context = readJournalDomainQueuePauseContext( db, target, - facts.reopenFloor ?? null, + selection.reopenFloor, rows.map((row) => String(row.message_id)) ) for (const row of rows) { - if (row.edit_held) { + if (automatic && row.edit_held) { return null } const { card } = readJournalDomainQueueRow(target.sessionId, row) @@ -75,16 +89,9 @@ function nextJournalDomainSubmissionCard( if (pastUnavailableMail && mail) { continue } - if (mail && card.body.from) { - const key = journalMailSenderKey(card.body.from) - const authority = facts.mail?.find(([sender]) => sender === key) - if (!authority) { - throw new Error('journal automatic mail selection requires supplied sender authority') - } - if (authority[1]) { - pastUnavailableMail = true - continue - } + if (mail && card.body.from && selection.mailUnavailable(card.body.from)) { + pastUnavailableMail = true + continue } return card } @@ -117,7 +124,21 @@ export function selectJournalDomainSubmissionCard( fingerprint: input.payloadFingerprint }, current?.card ?? null, - () => nextJournalDomainSubmissionCard(db, target, facts, consume.steer === true, savedAt) + () => + nextJournalDomainQueueCard(db, target, { + reopenFloor: facts.reopenFloor ?? null, + now: savedAt, + steer: consume.steer === true, + automatic: true, + mailUnavailable: (from) => { + const key = journalMailSenderKey(from) + const authority = facts.mail?.find(([sender]) => sender === key) + if (!authority) { + throw new Error('journal automatic mail selection requires supplied sender authority') + } + return authority[1] + } + }) ) const owed = consume.owed ? (facts.owed ?? 'unavailable') : 'owed' if (owed !== 'owed') { diff --git a/src/main/native-chat/agent-session-journal/journal-sql-queued-messages.test.ts b/src/main/native-chat/agent-session-journal/journal-sql-queued-messages.test.ts new file mode 100644 index 00000000000..686e05aa5f4 --- /dev/null +++ b/src/main/native-chat/agent-session-journal/journal-sql-queued-messages.test.ts @@ -0,0 +1,213 @@ +import { mkdtempSync, rmSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { afterEach, expect, it } from 'vitest' +import Database from '../../sqlite/sync-database' +import type { AgentJournalMessageItem } from '../../../shared/agent-session/journal/agent-session-journal-types' +import { codexProviderHandle } from '../../../shared/agent-session/lifecycle/agent-session-provider-handle-encoding' +import { agentSessionSendBodyFingerprint } from '../../../shared/agent-session/requests/structured-agent-session-send-mutation' +import { ensureAgentSessionAttachmentClaimTables } from '../agent-session-attachments/agent-session-attachment-claims' +import { migrateJournalDomainSchema } from './journal-domain-schema' +import { applyJournalDomainSubmission } from './journal-domain-submission-admission' +import { applyJournalDomainEditLease } from './journal-domain-edit-leases' +import { insertJournalDomainQueueRow } from './journal-domain-queue-rows' +import { journalMailSenderKey } from './journal-writer-host-facts' +import { JournalSqlScope } from './journal-sql-scope' +import { + readJournalSqlQueue, + type JournalSqlQueueFacts, + type JournalSqlQueueRead +} from './journal-sql-queued-messages' +import type { QueuedMessageRow } from './queued-messages/queued-message-table' + +type QueueRead = JournalSqlQueueRead extends infer R + ? R extends unknown + ? Omit + : never + : never +const target = { sessionId: 'chat', epoch: 'epoch' } +const cleanups: (() => void)[] = [] +const body = (text: string): AgentJournalMessageItem => ({ + kind: 'message', + role: 'user', + blocks: [{ type: 'text', text }] +}) +const from = { + kind: 'agent' as const, + senders: [], + orchestration: { + message: 'mail-notice' as const, + mailbox: 'owner', + dispatchId: null, + messages: [] + } +} + +afterEach(() => { + for (const cleanup of cleanups.splice(0)) { + cleanup() + } +}) + +function fixture() { + const db = new Database(':memory:') + const stateDirectory = mkdtempSync(join(tmpdir(), 'orca-queue-reader-')) + cleanups.push(() => { + db.close() + rmSync(stateDirectory, { recursive: true, force: true }) + }) + migrateJournalDomainSchema(db) + ensureAgentSessionAttachmentClaimTables(db) + db.prepare(`INSERT INTO journal_chat_state(workspace_id,session_id,epoch,last_sequence,highest_fence) + VALUES('workspace','chat','epoch',10,1)`).run() + const transaction = (write: () => T): T => { + db.exec('BEGIN IMMEDIATE') + try { + const value = write() + db.exec('COMMIT') + return value + } catch (error) { + db.exec('ROLLBACK') + throw error + } + } + const seed = (id: string, position: number, fields: Partial = {}) => { + const message = fields.body ?? body(id) + insertJournalDomainQueueRow(db, target, { + messageId: id, + body: message, + position, + fingerprint: agentSessionSendBodyFingerprint('chat', message), + state: 'waiting', + holdReason: null, + returnedReason: null, + returnedRejection: null, + consumedAs: null, + queuedAt: { epoch: 'epoch', sequence: 1 }, + ...fields + }) + } + const consume = (messageId: string, clientMessageId: string) => + transaction(() => + applyJournalDomainSubmission( + db, + stateDirectory, + target, + { + kind: 'submission', + input: { + clientMessageId, + body: body(messageId), + payloadFingerprint: agentSessionSendBodyFingerprint('chat', body(messageId)), + fence: 1, + handoverRecorded: true, + origin: 'client', + source: { kind: 'user' } + }, + consume: { messageId, expect: 'waiting' } + }, + { + identity: { + sessionId: 'chat', + workspaceId: 'workspace', + hostId: 'host', + agent: 'codex', + providerHandle: codexProviderHandle('thread') + } + }, + 1_800_000_000_000 + ) + ) + const hold = (messageId: string) => + transaction(() => + applyJournalDomainEditLease( + db, + target, + 'phone-handle', + { + kind: 'acquire', + callerKey: 'phone', + editId: 'edit', + messageId, + fingerprint: agentSessionSendBodyFingerprint('chat', body(messageId)) + }, + Date.now() + ) + ) + const read = (operation: QueueRead, facts: Partial = {}) => + readJournalSqlQueue(new JournalSqlScope(db, 'chat', 'epoch'), { + ...operation, + facts: { reopenFloor: null, ...facts } + }) + return { db, seed, consume, hold, read } +} + +const ids = (result: ReturnType) => + result.kind === 'list' ? result.cards.map((card) => card.messageId) : result + +it('lists current and still-owed handoff cards, and selects past persisted holds and mail', () => { + const f = fixture() + f.seed('withdrawn', 0, { state: 'withdrawn' }) + f.seed('sent', 1) + f.seed('mail', 2, { body: { ...body('mail'), from } }) + f.seed('next', 3) + f.consume('sent', 'send-1') + + expect(ids(f.read({ kind: 'list' }))).toEqual(['sent', 'mail', 'next']) + expect(f.read({ kind: 'get', messageId: 'withdrawn' })).toMatchObject({ + card: { messageId: 'withdrawn', state: 'withdrawn' } + }) + expect(f.read({ kind: 'revision' })).toEqual({ kind: 'revision', revision: 'epoch:11' }) + + const next = (automatic: boolean, unavailable?: boolean) => + f.read( + { kind: 'next-input-card', automatic, steer: false }, + unavailable === undefined ? {} : { mail: [[journalMailSenderKey(from), unavailable]] } + ) + expect(next(true)).toEqual({ kind: 'mail-needed', from }) + expect(next(true, false)).toMatchObject({ card: { messageId: 'mail' } }) + expect(next(true, true)).toMatchObject({ card: { messageId: 'next' } }) + + f.hold('mail') + expect(next(true, false)).toEqual({ kind: 'next-input-card', card: null }) + expect(next(false, false)).toMatchObject({ card: { messageId: 'mail' } }) +}) + +it('owes a reopen mark only for waiting cards or dispatched cards still awaiting delivery', () => { + const f = fixture() + f.seed('only', 1) + expect(f.read({ kind: 'reopen-mark' })).toEqual({ kind: 'reopen-mark', awaits: true, since: 11 }) + f.consume('only', 'send-1') + expect(f.read({ kind: 'reopen-mark' })).toEqual({ kind: 'reopen-mark', awaits: true, since: 12 }) + f.db.prepare(`UPDATE journal_submission_attempts SET dispatch_state='unknown', recovered=1`).run() + expect(f.read({ kind: 'reopen-mark' })).toEqual({ kind: 'reopen-mark', awaits: false, since: 12 }) + expect(ids(f.read({ kind: 'list' }))).toEqual([]) +}) + +it('derives Stop, clear and reopen pauses from head facts and exact clear membership', () => { + const f = fixture() + f.seed('cleared', 1) + f.seed('kept', 2) + f.db.exec(`UPDATE journal_chat_state SET queue_clear_sequence=8, queue_clear_operation_id='clear', + queue_latest_stop_json='{"sequence":9,"event":{"reason":"user-stop","at":5}}'; + INSERT INTO journal_queue_clear_members VALUES('chat','epoch','cleared')`) + const floor = { reopenFloor: { epoch: 'epoch', sequence: 7 } } + + expect(f.read({ kind: 'cleared-through' })).toEqual({ kind: 'cleared-through', sequence: 8 }) + expect(f.read({ kind: 'user-stop-in-force' })).toEqual({ + kind: 'user-stop-in-force', + stop: { sequence: 9, event: { reason: 'user-stop', at: 5 } } + }) + expect(f.read({ kind: 'pauses' }, floor)).toEqual({ + kind: 'pauses', + pauses: [ + { reason: 'stopped', since: { epoch: 'epoch', sequence: 9 } }, + { reason: 'cleared', since: { epoch: 'epoch', sequence: 8 }, messageIds: ['cleared'] }, + { + reason: 'restarted', + since: { epoch: 'epoch', sequence: 7 }, + messageIds: ['cleared', 'kept'] + } + ] + }) +}) diff --git a/src/main/native-chat/agent-session-journal/journal-sql-queued-messages.ts b/src/main/native-chat/agent-session-journal/journal-sql-queued-messages.ts index 4e3590d0711..1ce0a7e47e9 100644 --- a/src/main/native-chat/agent-session-journal/journal-sql-queued-messages.ts +++ b/src/main/native-chat/agent-session-journal/journal-sql-queued-messages.ts @@ -1,5 +1,4 @@ import type { AgentMessageSource } from '../../../shared/agent-session/agent-session-message-source' -import { orchestrationMailNotice } from '../../../shared/agent-session/agent-session-message-source' import type { AgentJournalCursor } from '../../../shared/agent-session/journal/agent-session-journal-identity' import type { AgentJournalMessageItem } from '../../../shared/agent-session/journal/agent-session-journal-types' import type { AgentSessionExecutionOptions } from '../../../shared/agent-session/options/agent-session-execution-options' @@ -9,27 +8,31 @@ import type { AgentSessionQueuedMessageUpdateResult } from '../../../shared/agent-session/requests/agent-session-queued-message-wire' import type { JournalLatestStop } from './context-epochs/journal-stop-turn-end' -import { JournalQueuedMessages } from './queued-messages/journal-queued-messages' import type { DerivedQueuePause } from './queued-messages/queued-message-pause' import type { QueuedMessageHoldReason, QueuedMessageRow } from './queued-messages/queued-message-table' import type { QueuedMessageUpdate } from './queued-messages/queued-message-update' -import type { JournalTransactionalDatabase } from './database/journal-host-database' -import { JournalSqlReducer } from './journal-sql-reducer' +import type { QueuedMessageEditLease } from './queued-messages/queued-message-edit-leases' +import { journalDomainQueueRow } from './journal-domain-queue-rows' +import { + journalDomainQueueAwaitsReopen, + readJournalDomainQueueHead, + readJournalDomainQueueList, + readJournalDomainQueuePauses, + readJournalDomainUserStopInForce +} from './journal-domain-queue-reads' +import { nextJournalDomainQueueCard } from './journal-domain-submission-consume' import type { JournalSqlScope } from './journal-sql-scope' import { journalMailSenderKey } from './journal-writer-host-facts' -import { JournalRowWriter, type JournalOperationReceipt } from './writing/journal-row-writer' -import { - queuedMessageEditLeaseHolds, - type QueuedMessageEditLease -} from './queued-messages/queued-message-edit-leases' +import type { JournalOperationReceipt } from './writing/journal-row-writer' import { SqlQueuedMessageEditLeases } from './journal-sql-edit-leases' /** Host-memory facts a queue read needs, sent as data like the writer's facts. */ export type JournalSqlQueueFacts = { reopenFloor: AgentJournalCursor | null + /** Writer-session transport only; reads select persisted holds. */ editLeases?: readonly QueuedMessageEditLease[] mail?: readonly (readonly [string, boolean])[] } @@ -64,78 +67,49 @@ class MailNeeded extends Error { } } -const refuse = (): never => { - throw new Error('a journal queue read cannot write') -} - -/** - * The writer's own queue procedures over a reducer shell of the caller's read snapshot. The shell - * is never flushed and its row writer refuses, so a read can only answer. - */ +/** Named queue reads on the current cards, typed head facts and persisted edit holds of one snapshot. */ export function readJournalSqlQueue( read: JournalSqlScope, operation: JournalSqlQueueRead ): JournalSqlQueueReadResult { - // Card selection records the host's reopen floor as a fact; a read keeps it to itself. - const scope = read.asSnapshot() - const reducer = new JournalSqlReducer(scope, scope.epoch) + const { db } = read + const target = { sessionId: read.sessionId, epoch: read.epoch } const { facts } = operation - const held = queuedMessageEditLeaseHolds(facts.editLeases ?? []) - const database: JournalTransactionalDatabase = { - db: scope.db, - readOnly: true, - stateDirectory: '', - transaction: refuse - } - const queue = new JournalQueuedMessages({ - sessionId: scope.sessionId, - serialize: refuse, - database: () => database, - readOnly: () => true, - state: () => reducer.state, - reopenFloor: () => facts.reopenFloor, - writer: new JournalRowWriter({ - sessionId: scope.sessionId, - now: Date.now, - serialize: refuse, - database: () => database, - readOnly: () => true, - highestFence: () => 0, - nextSequence: () => 0, - commit: refuse - }), - committed: () => {}, - claimAttachments: refuse, - editHeld: (messageId) => held(queue.get(messageId)) - }) - queue.mailUnavailable = (card) => { - const from = card.body.from - if (!from || !orchestrationMailNotice(from)) { - return false - } - const known = facts.mail?.find(([sender]) => sender === journalMailSenderKey(from)) - if (!known) { - throw new MailNeeded(from) - } - return known[1] - } - // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: untracking returns the decoded value the storage proxy wraps, of the same type. - const plain = (value: T): T => reducer.context.untracked('', value) as T - const card = (value: QueuedMessageRow | null) => (value ? detachCard(plain(value)) : null) switch (operation.kind) { case 'list': - return { kind: 'list', cards: queue.list().map((value) => detachCard(plain(value))) } + return { kind: 'list', cards: readJournalDomainQueueList(db, target) } case 'get': - return { kind: 'get', card: card(queue.get(operation.messageId)) } - case 'revision': - return { kind: 'revision', revision: queue.revision() } + return { + kind: 'get', + card: journalDomainQueueRow(db, target, operation.messageId)?.card ?? null + } + case 'revision': { + // Every queue command appends an event, so the head sequence moves whenever a card does. + const { lastSequence } = readJournalDomainQueueHead(db, target) + return { kind: 'revision', revision: `${target.epoch}:${lastSequence}` } + } case 'cleared-through': - return { kind: 'cleared-through', sequence: queue.clearedThrough() } + return { + kind: 'cleared-through', + sequence: readJournalDomainQueueHead(db, target).clearedThrough + } case 'next-input-card': try { return { kind: 'next-input-card', - card: card(queue.nextInputCard(operation.automatic, operation.steer)) + card: nextJournalDomainQueueCard(db, target, { + reopenFloor: facts.reopenFloor, + now: Date.now(), + steer: operation.steer, + automatic: operation.automatic, + mailUnavailable: (from) => { + const known = facts.mail?.find(([sender]) => sender === journalMailSenderKey(from)) + if (!known) { + throw new MailNeeded(from) + } + return known[1] + } + }) } } catch (error) { if (error instanceof MailNeeded) { @@ -146,19 +120,15 @@ export function readJournalSqlQueue( case 'pauses': return { kind: 'pauses', - pauses: queue.pauses().map((pause) => ({ - reason: pause.reason, - since: pause.since && { ...pause.since }, - ...(pause.messageIds ? { messageIds: [...pause.messageIds] } : {}) - })) + pauses: readJournalDomainQueuePauses(db, target, facts.reopenFloor) } case 'user-stop-in-force': - return { kind: 'user-stop-in-force', stop: detachJournalSqlStop(queue.userStopInForce()) } + return { kind: 'user-stop-in-force', stop: readJournalDomainUserStopInForce(db, target) } case 'reopen-mark': return { kind: 'reopen-mark', - awaits: queue.awaitReopenMark(), - since: reducer.state.lastSequence + 1 + awaits: journalDomainQueueAwaitsReopen(db, target), + since: readJournalDomainQueueHead(db, target).lastSequence + 1 } } } @@ -174,11 +144,6 @@ export function detachJournalSqlStop(stop: JournalLatestStop | null): JournalLat ) } -function detachCard(card: QueuedMessageRow): QueuedMessageRow { - // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the storage row is already typed; JSON detaches its lazy value proxies. - return JSON.parse(JSON.stringify(card)) as QueuedMessageRow -} - export type JournalSqlQueuePort = { read: ( operation: Extract @@ -254,6 +219,17 @@ export class SqlJournalQueuedMessages { return (await this.read({ kind: 'cleared-through' }, 'cleared-through')).sequence } + /** The one mail fact an automatic consume selection can ask, captured before its writer command. */ + async automaticMailFacts(steer = false): Promise<(readonly [string, boolean])[]> { + const result = await this.port.read({ + kind: 'next-input-card', + automatic: true, + steer, + facts: this.facts() + }) + return result.kind === 'mail-needed' ? this.answerMail([result.from]) : [] + } + async nextInputCard(automatic = true, steer = false): Promise { const mail: (readonly [string, boolean])[] = [] for (;;) {