@meistrari/agent-core 0.2.0-experimental.0 → 0.2.0-experimental.1

package/README.md

@@ -48,6 +48,38 @@ Use `--loopback-tcp` for local and image-build probes. Production images default
 
 Publishing runs from `main` through `.github/workflows/publish.yml` (conventional commits decide the bump).
 
+## Command transports
+
+`session.bootstrap` carries an optional `commandTransport`. Both modes share the same wire frames, ES256
+control authority, durable event ACK floor, reverse RPC and SQLite journal.
+
+- **Omitted (legacy, background-coding-agent).** The bootstrap embeds command 1, the journal requires a
+  contiguous `commandSeq`, and the worker pump advances a cumulative cursor through `CommandSource.next`.
+- **`'wss-v1'` (agent-api v5).** The bootstrap carries no command and rejects one. The supervisor attaches
+  the provider immediately, the journal accepts gaps and a delivery order different from admission while
+  keeping identity/hash deduplication, and `runtime.state.sourceId` announces a journal identity persisted
+  in SQLite and preserved across reopen. The worker passes that identity to
+  `ConnectionAuthorityStore.markConnectionReady`; the store pins it on first readiness and answers a
+  `ConnectionReadinessRejection` when a later supervisor announces a different journal, which fails the
+  session deterministically instead of resuming from a stale cursor. Durable events replayed after
+  `runtime.state` are persisted only after the store accepted the readiness. The worker pump selects work
+  through `CommandSource.pending` and persists each receipt through `CommandSource.received` before
+  selecting again; `next` is never called. A command the supervisor will never accept (invalid body,
+  sequence already journaled under another identity) is answered with a `rejected` ACK
+  (`supervisor.command.invalid-body`, `supervisor.command.conflicting-duplicate`) instead of a socket
+  close; the pump persists it through `CommandSource.rejected` and keeps delivering the session's other
+  work. The pump also accepts `ackTimeoutMs`, `onFailure` and an awaitable `close()`.
+
+The product-owned `pending` selection decides priority: withdrawn commands leave gaps, and cancel or steer
+may be delivered ahead of a queued message. The resident supervisor executes commands in arrival order;
+a `next` prompt dispatched while a turn is active may be refused by the adapter (Codex defers it), so the
+selection must hold such messages back until the turn ends.
+
+`e2e/loopback.test.ts` covers the legacy mode. `e2e/wss-v1-loopback.test.ts` covers `wss-v1` through
+`createSandboxConnectionRuntime` and through the exported helpers agent-api's worker composes directly:
+`openSupervisorConnectionBeforeDeadline`, `sendSupervisorBootstrap`, `createOrderedSupervisorInbox`,
+`routeSupervisorFrame`, `SessionCommandPump` and `drainSupervisorConnection`.
+
 ## Durable command outcomes
 
 A supervisor `received` ACK advances the command delivery cursor only. Implementations of

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@meistrari/agent-core",
     "type": "module",
-    "version": "0.2.0-experimental.0",
+    "version": "0.2.0-experimental.1",
     "packageManager": "bun@1.3.12",
     "description": "Shared contracts and runtime modules for Tela coding-agent sandboxes: agent protocol, supervisor wire protocol, resident supervisor, worker runtime client, and Claude/Codex harness adapters.",
     "license": "UNLICENSED",

package/src/agents/claude/claude-event-mapper.ts

@@ -5,6 +5,7 @@ import type { BetaMessage, BetaRawMessageStreamEvent, BetaUsage } from '@anthrop
 import type { AgentError, AgentEventActor, AgentUsage, JsonValue } from '../../protocol'
 import type { AgentWorkObservation } from '../../protocol/agent-work'
 import type { AgentEventDraft } from '../agent-event-stream'
+import { randomUUID } from 'node:crypto'
 import z from 'zod'
 import { jsonValueSchema } from '../../protocol'
 import { canonicalToolName } from '../../protocol/agent-tool-name'
@@ -95,6 +96,7 @@ const taskListWorkOutputSchema = z.object({
 }).passthrough() satisfies z.ZodType<TaskListWorkOutput>
 
 export interface ClaudeEventMapperState {
+    readonly usageScopeId: string
     readonly toolNameById: Map<string, string>
     readonly pendingWorkCallById: Map<string, PendingClaudeWorkCall>
     readonly startedMessageIds: Set<string>
@@ -118,6 +120,7 @@ export interface ClaudeEventMapperState {
 
 export function createClaudeEventMapperState(): ClaudeEventMapperState {
     return {
+        usageScopeId: `claude-query:${randomUUID()}`,
         toolNameById: new Map(),
         pendingWorkCallById: new Map(),
         startedMessageIds: new Set(),
@@ -135,7 +138,7 @@ export function createClaudeEventMapperState(): ClaudeEventMapperState {
     }
 }
 
-export function mapClaudeMessage(message: SDKMessage, state: ClaudeEventMapperState): AgentEventDraft[] {
+export function mapClaudeMessage(message: SDKMessage, state: ClaudeEventMapperState, options: { continueTurn?: boolean } = {}): AgentEventDraft[] {
     const drafts: AgentEventDraft[] = []
 
     if (message.type === 'system') {
@@ -189,23 +192,33 @@ export function mapClaudeMessage(message: SDKMessage, state: ClaudeEventMapperSt
     if (message.type === 'result') {
         const turnId = ensureTurnStarted(drafts, state)
         const usage = usageFromObject(message.usage)
-        // Claude Agent SDK result usage is per completed ask/turn for the stream-json path we use,
-        // not a monotonic counter across the long-lived query. Emit it directly so summing
-        // normalized usage events gives the run total; do not diff against prior results.
+        // SDK usage is per result, but modelUsage is cumulative within this query process.
+        // A resumed CLI resets modelUsage even when it retains the native session ID.
+        // Keep display counters separate; the control plane deduplicates/differences accounting.
         if (usage) {
             drafts.push({ type: 'usage', turnId, actor: mainActor, payload: { usage, accounting: {
                 observationId: message.uuid,
-                mode: 'increment',
-                scopeId: turnId,
+                mode: Object.keys(message.modelUsage ?? {}).length ? 'cumulative' : 'increment',
+                scopeId: Object.keys(message.modelUsage ?? {}).length ? state.usageScopeId : turnId,
                 includesChildren: true,
                 models: Object.fromEntries(Object.entries(message.modelUsage ?? {}).map(([model, counts]) => [model, {
                     inputTokens: counts.inputTokens,
                     outputTokens: counts.outputTokens,
                     cacheReadTokens: counts.cacheReadInputTokens,
                     cacheWriteTokens: counts.cacheCreationInputTokens,
+                    webSearchRequests: counts.webSearchRequests,
                 }])),
             } } })
         }
+        // A native steer may finish one query segment while retaining the logical turn.
+        // Usage belongs to this segment and must still be emitted exactly once. The segment
+        // may have been aborted mid-generation (error_during_execution): close whatever it
+        // streamed so the steer's user message follows a closed assistant step.
+        if (options.continueTurn) {
+            endOpenReasoning(drafts, state, turnId)
+            endOpenAssistantMessage(drafts, state, turnId)
+            return drafts
+        }
         endOpenReasoning(drafts, state, turnId)
         const interruptAccepted = state.interrupt.status === 'accepted' && state.interrupt.turnId === turnId
         drafts.push({ type: 'turn.ended', turnId, actor: mainActor, payload: turnEndedPayload(message, interruptAccepted) })
@@ -599,6 +612,16 @@ function endOpenReasoning(drafts: AgentEventDraft[], state: ClaudeEventMapperSta
     }
 }
 
+function endOpenAssistantMessage(drafts: AgentEventDraft[], state: ClaudeEventMapperState, turnId: string): void {
+    const messageId = state.currentMessageId
+    if (!messageId)
+        return
+    endAssistantMessageById(drafts, state, turnId, messageId, state.streamedTextByMessageId.get(messageId), state.actorByMessageId.get(messageId))
+    state.actorByMessageId.delete(messageId)
+    state.currentMessageId = undefined
+    state.contentBlockTypeByIndex.clear()
+}
+
 function reasoningIdForMessage(messageId: string): string {
     return `reasoning-${messageId}`
 }

package/src/agents/claude/claude-run.ts

@@ -96,12 +96,14 @@ export class ClaudeRun implements AgentRun {
     private initializationReject: (error: unknown) => void = () => undefined
     private initialized = false
     private firstInputPushed = false
+    private pendingSteerResult?: Extract<SDKMessage, { type: 'result' }>
     private modelChangeReady = true
     private modelChangeInFlight = false
     private finished = false
     private interruptRequest?: { turnId: string, promise: Promise<void> }
     private readonly acceptanceWaiters = new Map<string, AcceptanceWaiter>()
     private readonly commandByClientMessageId = new Map<string, string>()
+    private readonly pendingMessages = new Map<string, { messageId: string, mode: 'next' | 'steer', turnId?: string, started: boolean }>()
 
     constructor({ metadata, query, userInputRequests, input, eventMapperState, init, recordStartup }: ClaudeRunInput) {
         this.metadata = metadata
@@ -147,6 +149,20 @@ export class ClaudeRun implements AgentRun {
             return
         }
         this.events.push(decorated)
+        if (draft.type === 'turn.started' && draft.payload.commandId)
+            this.emitAcceptedMessage(draft.payload.commandId, draft.turnId)
+    }
+
+    private emitAcceptedMessage(commandId: string, turnId: string): void {
+        const pending = this.pendingMessages.get(commandId)
+        if (!pending?.started || !this.initialized || this.finished)
+            return
+        if (pending.mode === 'steer' && pending.turnId && pending.turnId !== turnId)
+            return
+        this.pendingMessages.delete(commandId)
+        const actor = { type: 'main', actorId: 'main' } as const
+        this.events.push({ type: 'message.started', turnId, actor, payload: { messageId: pending.messageId, commandId, role: 'user' } })
+        this.events.push({ type: 'message.ended', turnId, actor, payload: { messageId: pending.messageId, commandId, role: 'user' } })
     }
 
     async requestUserInput(input: UserInputRequestInput): Promise<{ requestId: string }> {
@@ -169,6 +185,8 @@ export class ClaudeRun implements AgentRun {
         this.assertCommandTargetsRun(command)
         this.assertRunning()
         options.signal?.throwIfAborted()
+        if (command.reasoningEffort !== undefined && command.reasoningEffort !== this.init.reasoningEffort)
+            throw new AgentNotAcceptedError({ message: 'Claude reasoning effort changes are not supported by this adapter.', recovery: { kind: 'terminal', reason: 'reasoning_effort_change_not_supported' } })
         const input = { prompt: command.prompt, mode: command.mode, commandId: command.commandId, origin: command.origin, author: command.author, senderContext: options.senderContext }
         const message = await mapClaudeUserMessage(input, options.inputAttachmentPreparation)
         options.signal?.throwIfAborted()
@@ -191,12 +209,15 @@ export class ClaudeRun implements AgentRun {
             this.init.requestedModel = command.model
             options.signal?.throwIfAborted()
         }
+        if (command.turnId && (command.mode !== 'steer' || command.turnId !== this.eventMapperState.currentTurnId))
+            throw new AgentNotAcceptedError({ message: 'The targeted claude turn is no longer active.', recovery: { kind: 'terminal', reason: 'target_turn_not_active' } })
         this.modelChangeReady = false
         // Register before the push: the CLI's queued receipt can outrun the local push resolution,
         // and a receipt with no registered waiter would be lost.
         const clientMessageId = deriveMessageId(command.commandId)
         const receipt = this.registerAcceptanceWaiter(clientMessageId)
         this.commandByClientMessageId.set(clientMessageId, command.commandId)
+        this.pendingMessages.set(command.commandId, { messageId: clientMessageId, mode: command.mode, turnId: command.turnId, started: false })
         try {
             await this.deliverInput(message)
             // `submitted` requires the provider's positive acceptance receipt — the pinned
@@ -233,6 +254,8 @@ export class ClaudeRun implements AgentRun {
         this.assertRunning()
         options.signal?.throwIfAborted()
         const turnId = this.eventMapperState.currentTurnId
+        if (command.turnId && command.turnId !== turnId)
+            return
         if (!turnId)
             return
         if (this.eventMapperState.interrupt.status === 'accepted' && this.eventMapperState.interrupt.turnId === turnId)
@@ -291,6 +314,7 @@ export class ClaudeRun implements AgentRun {
         }
         this.acceptanceWaiters.clear()
         this.commandByClientMessageId.clear()
+        this.pendingMessages.clear()
         this.events.push({ type: 'session.ended', payload: error ? { reason, error } : { reason } })
         this.events.push({ type: 'session.state.changed', payload: { state: reason === 'failed' ? 'failed' : 'stopped' } })
         this.events.end()
@@ -322,6 +346,20 @@ export class ClaudeRun implements AgentRun {
     // they reject any pending waiter as delivery-unknown so command processing can advance.
     // Valid positive frames without a pending
     // waiter are internal lifecycle for already-settled or non-prompt inputs and are ignored.
+    private hasPendingSteer(): boolean {
+        return [...this.pendingMessages.values()].some(pending => pending.mode === 'steer'
+            && (!pending.turnId || pending.turnId === this.eventMapperState.currentTurnId))
+    }
+
+    private flushSteerResult(continueTurn = false): void {
+        const result = this.pendingSteerResult
+        this.pendingSteerResult = undefined
+        if (result) {
+            for (const draft of mapClaudeMessage(result, this.eventMapperState, { continueTurn }))
+                this.pushEvent(draft)
+        }
+    }
+
     private settleAcceptance(frame: ClaudeCommandLifecycleMessage): void {
         const parsed = commandLifecycleFrameSchema.safeParse(frame)
         if (!parsed.success) {
@@ -336,21 +374,39 @@ export class ClaudeRun implements AgentRun {
                 details: { expected: this.metadata.providerSessionId, actual: parsed.data.session_id },
             })
         }
+        const commandId = this.commandByClientMessageId.get(parsed.data.command_uuid)
         if (parsed.data.state === 'cancelled' || parsed.data.state === 'discarded') {
+            if (commandId)
+                this.pendingMessages.delete(commandId)
             this.acceptanceWaiters.get(parsed.data.command_uuid)?.reject(new AgentDeliveryUnknownError({
                 message: `Claude command ended as ${parsed.data.state} before acceptance was observed.`,
             }))
             this.commandByClientMessageId.delete(parsed.data.command_uuid)
+            if (!this.hasPendingSteer())
+                this.flushSteerResult()
             return
         }
         // A queued receipt acknowledges admission, not turn ownership. Keep the
         // mapping after acceptance settles: the provider's started receipt is
         // the authority for the next root turn, even with several queued inputs.
         if (parsed.data.state === 'started') {
-            this.eventMapperState.currentCommandId = this.commandByClientMessageId.get(parsed.data.command_uuid)
+            const pending = commandId ? this.pendingMessages.get(commandId) : undefined
+            // Only a native started receipt can join the interrupted segment to a steer.
+            // A queued receipt alone must never suppress the logical turn's completion.
+            this.flushSteerResult(pending?.mode === 'steer' && (!pending.turnId || pending.turnId === this.eventMapperState.currentTurnId))
+            this.eventMapperState.currentCommandId = commandId
+            if (pending && commandId) {
+                pending.started = true
+                const turnId = this.eventMapperState.currentTurnId
+                if (pending.mode === 'steer' && turnId && (!pending.turnId || pending.turnId === turnId))
+                    this.emitAcceptedMessage(commandId, turnId)
+            }
         }
-        if (parsed.data.state === 'completed')
+        if (parsed.data.state === 'completed') {
             this.commandByClientMessageId.delete(parsed.data.command_uuid)
+            if (commandId)
+                this.pendingMessages.delete(commandId)
+        }
         this.acceptanceWaiters.get(parsed.data.command_uuid)?.resolve()
     }
 
@@ -433,6 +489,17 @@ export class ClaudeRun implements AgentRun {
                     this.completeInitialization(message)
                     continue
                 }
+                this.flushSteerResult()
+                if (message.type === 'result' && this.hasPendingSteer()) {
+                    // priority: now ends the current segment and yields its result before the
+                    // cancelled/started receipts: a success after a tool call or mid-response
+                    // (null stop reason), or error_during_execution when the CLI aborted the
+                    // in-flight model call (the steer landed while the model was still thinking).
+                    // Hold it until that native boundary proves continuation of the logical turn
+                    // or its true completion; a steer must never open a new turn.
+                    this.pendingSteerResult = message
+                    continue
+                }
                 const completeMessage = message.type === 'user'
                     ? await hydrateClaudeToolOutput(message, {
                             transcriptPath: this.metadata.transcriptPath,
@@ -447,6 +514,7 @@ export class ClaudeRun implements AgentRun {
             if (!this.initialized) {
                 throw new AgentProviderProtocolError({ message: 'Claude SDK ended before emitting system init.' })
             }
+            this.flushSteerResult()
             this.finish('completed')
         }
         catch (error) {

package/src/agents/codex/codex-run.ts

@@ -36,6 +36,7 @@ interface PreparedCodexTurn {
     commandId: string
     origin: 'user' | 'supervisor'
     model?: string
+    reasoningEffort?: AgentReasoningEffort
 }
 
 interface CodexRunInput {
@@ -61,7 +62,7 @@ export class CodexRun implements AgentRun {
     private readonly client: CodexJsonRpcClient
     private readonly beforePrompt: ((signal?: AbortSignal) => Promise<void>) | undefined
     private readonly resolveInferenceModel: (model: string) => string
-    private readonly reasoningEffort: AgentReasoningEffort | undefined
+    private reasoningEffort: AgentReasoningEffort | undefined
     private readonly onStop: () => void
     private readonly userInputRequests: UserInputRequestStore
     private readonly eventMapperState: CodexEventMapperState
@@ -244,12 +245,17 @@ export class CodexRun implements AgentRun {
             options,
         })
         prepared.model = command.model
+        prepared.reasoningEffort = command.reasoningEffort
         // A turn/started fact may have reduced during attachment preparation.
         this.deferNextWhileTurnActive(command.mode)
 
+        if (command.turnId && (command.mode !== 'steer' || command.turnId !== this.activeTurnId))
+            throw new AgentNotAcceptedError({ message: 'The targeted codex turn is no longer active.', recovery: { kind: 'terminal', reason: 'target_turn_not_active' } })
         const activeTurnId = this.activeTurnId
         if (activeTurnId && command.model && command.model !== this.metadata.model)
             throw new AgentPromptDeferredError({ message: 'Codex model changes require an idle turn boundary.' })
+        if (activeTurnId && command.reasoningEffort && command.reasoningEffort !== this.reasoningEffort)
+            throw new AgentPromptDeferredError({ message: 'Codex reasoning effort changes require an idle turn boundary.' })
         if (command.mode === 'next' || !activeTurnId)
             return await this.startPreparedTurn(prepared)
 
@@ -306,6 +312,8 @@ export class CodexRun implements AgentRun {
         this.assertCommandTargetsRun(command)
         this.assertRunning()
         options.signal?.throwIfAborted()
+        if (command.turnId && command.turnId !== this.activeTurnId)
+            return
         const turnId = command.turnId ?? this.activeTurnId
         if (!turnId)
             return
@@ -364,7 +372,7 @@ export class CodexRun implements AgentRun {
                 input: prepared.input,
                 cwd: this.metadata.cwd,
                 model: inferenceModel,
-                effort: codexEffort(this.reasoningEffort),
+                effort: codexEffort(prepared.reasoningEffort ?? this.reasoningEffort),
                 summary: codexReasoningSummary,
                 approvalPolicy: 'never',
                 sandboxPolicy: { type: 'dangerFullAccess' },
@@ -375,6 +383,8 @@ export class CodexRun implements AgentRun {
             throw mapTurnTransportLoss(error)
         }
         this.activeTurnId = result.turn.id
+        if (prepared.reasoningEffort)
+            this.reasoningEffort = prepared.reasoningEffort
         if (prepared.model)
             this.metadata.model = prepared.model
         return { kind: 'turn', turnId: result.turn.id, placement: 'started' }

package/src/protocol/agent-command.ts

@@ -23,11 +23,13 @@ const runningCommandBaseSchema = z.object({
 export const sendPromptCommandSchema = runningCommandBaseSchema.extend({
     type: z.literal('agent.send-prompt'),
     mode: agentPromptModeSchema,
+    turnId: z.string().min(1).optional(),
     origin: z.enum(['user', 'supervisor']).default('user'),
     prompt: agentPromptSchema,
     commandId: commandIdSchema,
     /** Resolved by the application for this prompt, including after runtime recovery. */
     model: z.string().trim().min(1).max(256).optional(),
+    reasoningEffort: agentReasoningEffortSchema.optional(),
     author: agentAuthorSchema.optional(),
 }).strict()
 

package/src/protocol/agent-usage.ts

@@ -9,6 +9,7 @@ export const agentUsageSchema = z.object({
     cacheWriteTokens: tokenCountSchema.optional(),
     reasoningOutputTokens: tokenCountSchema.optional(),
     totalTokens: tokenCountSchema.optional(),
+    webSearchRequests: tokenCountSchema.optional(),
 }).strict()
 
 export type AgentUsage = z.infer<typeof agentUsageSchema>

package/src/provenance.gen.ts

@@ -1,6 +1,6 @@
 // Generated by scripts/write-provenance.ts. Do not edit by hand.
 export const generatedProvenance = {
-    version: "0.2.0-experimental.0",
-    sha: "da33c4f2db2875602c75e8ad3fde2d01d8ea7a94",
-    buildTime: "2026-09-22T18:15:52.470Z",
+    version: "0.2.0-experimental.1",
+    sha: "e5c42a085c63ca53443040d94e1ef40b159073e2",
+    buildTime: "2026-09-22T18:27:33.931Z",
 } as const

package/src/steps/contract.ts

@@ -81,8 +81,11 @@ export function splitStepText(text: string): string[] {
 
 export function stepPreview(value: unknown): string {
     const text = (typeof value === 'string' ? value : JSON.stringify(value) ?? '').replaceAll('\0', '\\0')
+    if (Buffer.byteLength(JSON.stringify(text)) <= 2048)
+        return text
     let preview = ''
-    let bytes = 0
+    // Include the JSON quotes and truncation marker in the same preview budget.
+    let bytes = Buffer.byteLength(JSON.stringify('…'))
     for (const character of text) {
         const size = Buffer.byteLength(JSON.stringify(character)) - 2
         if (bytes + size > 2048)

package/src/steps/projector.ts

@@ -272,8 +272,24 @@ export class DurableStepProjector {
         ).get(...key)?.command_id
         const payload = 'payload' in event ? event.payload as Record<string, unknown> : event
         const explicit = typeof payload.commandId === 'string' ? payload.commandId : undefined
-        if (previous && explicit && previous !== explicit)
+        if (previous && explicit && previous !== explicit) {
+            if ('type' in event && event.actor.type === 'main' && payload.role === 'user'
+                && (event.type === 'message.started' || event.type === 'message.ended') && 'messageId' in payload && typeof payload.messageId === 'string') {
+                const messageStepId = stepIdFor({ sessionId: event.sessionId, providerSessionId: event.providerSessionId, actor: event.actor, turnId: event.turnId, kind: 'message', sourceId: payload.messageId })
+                const known = this.db.query<{ command_id: string | null }, [string]>(
+                    'select json_extract(body,\'$.commandId\') as command_id from steps where id=?',
+                ).get(messageStepId)
+                // Delayed/repeated facts for an older message must not rewind the turn's current command.
+                if (known?.command_id === explicit)
+                    return explicit
+                if (!known && event.type === 'message.started') {
+                    this.db.query('update turn_commands set command_id=? where session_id=? and provider_session_id=? and actor_id=? and turn_id=?')
+                        .run(explicit, ...key)
+                    return explicit
+                }
+            }
             throw new Error('Conflicting command identity for a provider turn.')
+        }
         let inherited: string | undefined
         if (!previous && !explicit && event.actor.type === 'subagent') {
             const toolCallId = event.actor.parentToolCallId

package/src/supervisor/agent-provider-factory.ts

@@ -7,6 +7,7 @@ import type { WireEventBody } from '../supervisor-protocol/event-body'
 import type { SupervisorAgentRunSnapshot } from '../supervisor-protocol/supervisor-agent-run-snapshot'
 import type { SupervisorAgentRuntime, SupervisorProviderFactory } from './provider-factory'
 import type { SupervisorRpcClient } from './rpc-client'
+import { Database } from 'bun:sqlite'
 import { wrapAgentEvent } from '../supervisor-protocol/agent-event-wrapper'
 import { createSupervisorProviderFactory } from './provider-factory'
 
@@ -15,6 +16,40 @@ export interface AgentProviderBindingStore {
     save: (input: { sessionId: string, provider: AgentProviderId, providerSessionId: string }) => Promise<void>
 }
 
+/** Local provider identity only; credentials and transcripts do not belong in this store. */
+export class SqliteAgentProviderBindingStore implements AgentProviderBindingStore {
+    private readonly db: Database
+
+    constructor(path: string) {
+        this.db = new Database(path, { create: true })
+        this.db.exec(`pragma journal_mode=WAL; pragma synchronous=FULL;
+            create table if not exists provider_bindings(
+                session_id text not null,
+                provider text not null,
+                provider_session_id text not null,
+                primary key(session_id, provider)
+            );`)
+    }
+
+    async load(input: { sessionId: string, provider: AgentProviderId }): Promise<string | undefined> {
+        return this.db.query<{ provider_session_id: string }, [string, string]>(
+            'select provider_session_id from provider_bindings where session_id=? and provider=?',
+        ).get(input.sessionId, input.provider)?.provider_session_id
+    }
+
+    async save(input: { sessionId: string, provider: AgentProviderId, providerSessionId: string }): Promise<void> {
+        if (!input.sessionId || !input.providerSessionId)
+            throw new Error('Provider binding requires session and provider session identities.')
+        this.db.query(`insert into provider_bindings(session_id,provider,provider_session_id) values (?,?,?)
+            on conflict(session_id,provider) do update set provider_session_id=excluded.provider_session_id`)
+            .run(input.sessionId, input.provider, input.providerSessionId)
+    }
+
+    close(): void {
+        this.db.close()
+    }
+}
+
 export interface AgentSupervisorProviderFactoryOptions {
     eventProcessor?: {
         recover: (emit: (body: WireEventBody) => void, options?: { interruptUnfinishedTurns: boolean }) => Promise<void>
@@ -65,11 +100,28 @@ export function createAgentSupervisorProviderFactory(
                 ? await provider.resumeSession({ ...sessionInput, provider: 'codex', providerSessionId: previousProviderSessionId }, { signal: input.signal })
                 : await provider.openSession({ ...sessionInput, provider: 'codex' }, { signal: input.signal })
 
-        await options.bindingStore.save({
-            sessionId: input.bootstrap.sessionId,
-            provider: provider.id,
-            providerSessionId: run.metadata.providerSessionId,
-        })
+        try {
+            await options.bindingStore.save({
+                sessionId: input.bootstrap.sessionId,
+                provider: provider.id,
+                providerSessionId: run.metadata.providerSessionId,
+            })
+        }
+        catch (error) {
+            try {
+                await run.stop({
+                    type: 'agent.stop',
+                    provider: run.metadata.provider,
+                    sessionId: run.metadata.sessionId,
+                    providerSessionId: run.metadata.providerSessionId,
+                    reason: 'provider_binding_persistence_failed',
+                }, { signal: new AbortController().signal })
+            }
+            catch (cleanupError) {
+                throw new AggregateError([error, cleanupError], 'Provider binding persistence and cleanup failed.')
+            }
+            throw error
+        }
 
         return new AgentSupervisorRuntime({
             run,
@@ -138,7 +190,9 @@ class AgentSupervisorRuntime implements SupervisorAgentRuntime {
                 providerSessionId: metadata.providerSessionId,
                 commandId: input.commandId,
                 mode: input.body.mode,
+                turnId: input.body.turnId,
                 model: input.body.model,
+                reasoningEffort: input.body.reasoningEffort,
                 origin: 'user',
                 prompt: input.body.prompt,
                 author: input.body.user
@@ -158,6 +212,7 @@ class AgentSupervisorRuntime implements SupervisorAgentRuntime {
         if (input.body.type === 'agent.interrupt') {
             await this.input.run.interrupt({
                 type: 'agent.interrupt',
+                turnId: input.body.turnId,
                 provider: metadata.provider,
                 sessionId: metadata.sessionId,
                 providerSessionId: metadata.providerSessionId,

package/src/supervisor/bootstrap-binder.ts

@@ -51,8 +51,8 @@ export function createBootstrapBinder(input: {
                 outcome: 'rejected',
                 ack: {
                     kind: 'command.ack',
-                    commandId: request.envelope.body.initialCommand.commandId,
-                    commandSeq: request.envelope.body.initialCommand.commandSeq,
+                    commandId: request.envelope.body.initialCommand?.commandId ?? `bootstrap:${request.envelope.body.sessionId}`,
+                    commandSeq: request.envelope.body.initialCommand?.commandSeq ?? 1,
                     status: 'rejected',
                     errorCode: error.code,
                     detail: error.publicMessage.slice(0, 240),
@@ -123,6 +123,7 @@ export function createBootstrapBinder(input: {
             outcome: 'accepted',
             runtimeState: {
                 kind: 'runtime.state',
+                ...(request.envelope.body.commandTransport === 'wss-v1' ? { sourceId: acceptedBinding.store.journalSourceId() } : {}),
                 lastReceivedCommandSeq: acceptedBinding.store.lastReceivedCommandSeq(),
                 nextEventSeq: acceptedBinding.store.localEventMax() + 1,
                 agentRun: acceptedBinding.store.agentRunSnapshot(),

package/src/supervisor/index.ts

@@ -1,4 +1,4 @@
-export { createAgentSupervisorProviderFactory } from './agent-provider-factory'
+export { createAgentSupervisorProviderFactory, SqliteAgentProviderBindingStore } from './agent-provider-factory'
 export type { AgentProviderBindingStore, AgentSupervisorProviderFactoryOptions } from './agent-provider-factory'
 export {
     CLEAN_EXIT_CODE,

package/src/supervisor/persistence/supervisor-store.ts

@@ -46,6 +46,9 @@ export interface PersistedSupervisorBinding {
     runtimeConnectionAttemptId: string
 }
 
+/** A command whose sequence is already journaled under a different identity or body. */
+export const commandSequenceConflictCode = 'agent-core.command-sequence-conflict'
+
 export class SupervisorStore {
     private closed = false
 
@@ -113,12 +116,14 @@ export class SupervisorStore {
                     now,
                 )
                 this.insertAttempt(input)
-                this.insertCommand({
-                    kind: 'command',
-                    commandId: input.body.initialCommand.commandId,
-                    commandSeq: input.body.initialCommand.commandSeq,
-                    body: input.body.initialCommand.body,
-                })
+                if (input.body.initialCommand) {
+                    this.insertCommand({
+                        kind: 'command',
+                        commandId: input.body.initialCommand.commandId,
+                        commandSeq: input.body.initialCommand.commandSeq,
+                        body: input.body.initialCommand.body,
+                    })
+                }
                 return {
                     body: input.body,
                     bodyHash,
@@ -175,12 +180,12 @@ export class SupervisorStore {
             if (existing.command_id !== envelope.commandId
                 || existing.body_hash !== sha256CanonicalJson(body)
                 || existing.body_json !== canonicalJson(body)) {
-                throw new SupervisorPersistenceError({ message: 'Command sequence conflicts with durable inbox state.' })
+                throw new SupervisorPersistenceError({ code: commandSequenceConflictCode, message: 'Command sequence conflicts with durable inbox state.' })
             }
             return { status: 'received', duplicate: true }
         }
         const maximum = this.lastReceivedCommandSeq()
-        if (envelope.commandSeq !== maximum + 1)
+        if (this.binding()?.body.commandTransport !== 'wss-v1' && envelope.commandSeq !== maximum + 1)
             throw new SupervisorPersistenceError({ message: 'Command sequence contains a gap.' })
         try {
             this.insertCommand({ ...envelope, body })
@@ -240,6 +245,15 @@ export class SupervisorStore {
         })()
     }
 
+    /** Stable identity of this SQLite journal, independent of socket and worker. */
+    journalSourceId(): string {
+        this.database.query('INSERT OR IGNORE INTO metadata (key, value) VALUES (\'journal_source_id\', ?)').run(crypto.randomUUID())
+        const row = this.database.query<{ value: string }, []>('SELECT value FROM metadata WHERE key = \'journal_source_id\'').get()
+        if (!row)
+            throw new SupervisorPersistenceError({ message: 'Missing journal identity.' })
+        return row.value
+    }
+
     lastReceivedCommandSeq(): number {
         return this.database.query<{ maximum: number }, []>('SELECT COALESCE(MAX(seq), 0) AS maximum FROM commands').get()?.maximum ?? 0
     }