@meistrari/agent-core 0.1.0 → 0.1.2

package/README.md

@@ -45,3 +45,15 @@ bunx agent-core-supervisor \
 Use `--loopback-tcp` for local and image-build probes. Production images default to the protected Unix socket. The extension module exports `default`, `extensions`, or `createSupervisorExtensions()` matching `SupervisorExtensions`.
 
 Publishing runs from `main` through `.github/workflows/publish.yml` (conventional commits decide the bump).
+
+## Durable command outcomes
+
+A supervisor `received` ACK advances the command delivery cursor only. Implementations of
+`DurableEventSink.record` must atomically store each durable event, project
+`supervisor.command.applied` or `supervisor.command.failed` into command state, and advance the
+ACK floor. Duplicate events must not repeat projections. This keeps outcomes consistent when
+the worker disconnects after persistence but before sending its event ACK.
+
+The former `ConnectionAuthorityStore.projectAppliedCommand` callback has been removed.
+Move that projection into the durable-event transaction; receiving a command does not prove
+that the provider executed it. See `InMemoryRuntimeControlPlane.record` for the test fixture.

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@meistrari/agent-core",
     "type": "module",
-    "version": "0.1.0",
+    "version": "0.1.2",
     "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",
@@ -14,6 +14,8 @@
         "registry": "https://registry.npmjs.org"
     },
     "exports": {
+        "./steps/contract": "./src/steps/contract.ts",
+        "./steps/projector": "./src/steps/projector.ts",
         "./errors": "./src/errors/index.ts",
         "./errors/application-error": "./src/errors/application-error.ts",
         "./logger": "./src/logger/index.ts",
@@ -89,9 +91,9 @@
         }
     },
     "dependencies": {
-        "jose": "^6.1.3",
+        "jose": "6.2.11",
         "pino": "^9.7.0",
-        "ulid": "^3.0.1",
+        "ulid": "3.0.2",
         "zod": "^4.1.12"
     },
     "devDependencies": {
@@ -100,9 +102,9 @@
         "@anthropic-ai/sdk": "0.93.0",
         "@modelcontextprotocol/sdk": "1.29.0",
         "@types/bun": "1.3.12",
-        "@types/pg": "^8.15.5",
+        "@types/pg": "8.23.1",
         "eslint": "^9.30.0",
-        "pg": "^8.16.3",
+        "pg": "8.23.0",
         "typescript": "5.9.3"
     }
 }

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

@@ -191,8 +191,20 @@ export function mapClaudeMessage(message: SDKMessage, state: ClaudeEventMapperSt
         // 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.
-        if (usage)
-            drafts.push({ type: 'usage', turnId, actor: mainActor, payload: { usage } })
+        if (usage) {
+            drafts.push({ type: 'usage', turnId, actor: mainActor, payload: { usage, accounting: {
+                observationId: message.uuid,
+                mode: 'increment',
+                scopeId: 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,
+                }])),
+            } } })
+        }
         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) })

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

@@ -71,6 +71,7 @@ export class ClaudeProvider implements AgentProvider<'claude'> {
         const sdkOptions: Options = removeUndefined({
             abortController,
             cwd: input.cwd,
+            settingSources: ['project', 'local'],
             env: this.environment,
             model: input.model,
             thinking: { type: 'adaptive', display: 'summarized' },

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

@@ -285,8 +285,8 @@ export class ClaudeRun implements AgentRun {
     // session identity mismatch are provider protocol drift and fail the run closed. `cancelled`
     // (a steered-over/aborted command) and `discarded` (the session ended with the command still
     // queued) are valid observed states but NEGATIVE terminals — never a positive acceptance, so
-    // they are validated and no-op even when a waiter is pending; the pending prompt's real outcome
-    // is settled by run close/error as delivery-unknown. Valid positive frames without a pending
+    // 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 settleAcceptance(frame: ClaudeCommandLifecycleMessage): void {
         const parsed = commandLifecycleFrameSchema.safeParse(frame)
@@ -302,8 +302,12 @@ export class ClaudeRun implements AgentRun {
                 details: { expected: this.metadata.providerSessionId, actual: parsed.data.session_id },
             })
         }
-        if (parsed.data.state === 'cancelled' || parsed.data.state === 'discarded')
+        if (parsed.data.state === 'cancelled' || parsed.data.state === 'discarded') {
+            this.acceptanceWaiters.get(parsed.data.command_uuid)?.reject(new AgentDeliveryUnknownError({
+                message: `Claude command ended as ${parsed.data.state} before acceptance was observed.`,
+            }))
             return
+        }
         this.acceptanceWaiters.get(parsed.data.command_uuid)?.resolve()
     }
 

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

@@ -3,6 +3,7 @@ import type { AgentWorkStatus } from '../../protocol/agent-work'
 import type { AgentEventDraft } from '../agent-event-stream'
 import type { CodexJsonRpcMessage, CodexServerNotification } from './codex-json-rpc-client'
 import type { ServerNotificationParamsByMethod } from './codex-protocol'
+import { createHash } from 'node:crypto'
 import { jsonObjectSchema, jsonValueSchema } from '../../protocol'
 import { CANONICAL_TOOL } from '../../protocol/agent-tool-name'
 import { createRuntimeWorkItemId } from '../agent-id'
@@ -96,7 +97,19 @@ export function mapCodexNotification(notification: CodexNotification, state: Cod
             const usage = usageFromTokenUsage(notification.params.tokenUsage)
             if (!usage)
                 return []
-            return emitOrBufferByThread({ draft: { type: 'usage', turnId: notification.params.turnId, payload: { usage } }, threadId: notification.params.threadId, state })
+            return emitOrBufferByThread({ draft: { type: 'usage', turnId: notification.params.turnId, payload: {
+                usage,
+                accounting: {
+                    observationId: createHash('sha256').update(notification.params.threadId).update(JSON.stringify(notification.params.tokenUsage.total)).digest('hex'),
+                    mode: 'cumulative',
+                    scopeId: notification.params.threadId,
+                    includesChildren: false,
+                    usage: {
+                        ...usageFromCounts(notification.params.tokenUsage.total),
+                        inputTokens: Math.max(0, notification.params.tokenUsage.total.inputTokens - notification.params.tokenUsage.total.cachedInputTokens),
+                    },
+                },
+            } }, threadId: notification.params.threadId, state })
         }
         case 'turn/plan/updated':
             if (!state.startedTurnIds.has(notification.params.turnId) || notification.params.threadId !== state.mainThreadId)

package/src/protocol/agent-event.ts

@@ -4,7 +4,7 @@ import { agentRunMetadataSchema } from './agent-metadata'
 import { agentPayloadOverflowSchema } from './agent-overflow'
 import { agentProviderIdSchema } from './agent-provider'
 import { agentToolCallStatusSchema, agentToolResultSchema } from './agent-tool'
-import { agentUsageSchema } from './agent-usage'
+import { agentUsageAccountingSchema, agentUsageSchema } from './agent-usage'
 import { agentUserInputAnswersSchema, agentUserInputQuestionSchema } from './agent-user-input'
 import { agentWorkObservationSchema } from './agent-work'
 
@@ -265,6 +265,7 @@ export const usageAgentEventSchema = agentTurnEventBaseSchema.extend({
     type: z.literal('usage'),
     payload: z.object({
         usage: agentUsageSchema,
+        accounting: agentUsageAccountingSchema.optional(),
     }).strict(),
 }).strict()
 

package/src/protocol/agent-usage.ts

@@ -12,3 +12,17 @@ export const agentUsageSchema = z.object({
 }).strict()
 
 export type AgentUsage = z.infer<typeof agentUsageSchema>
+
+/**
+ * Accounting semantics are separate from display counters. Consumers persist
+ * observations/checkpoints before acknowledging events, including across runs.
+ */
+export const agentUsageAccountingSchema = z.object({
+    observationId: z.string().min(1),
+    mode: z.enum(['increment', 'cumulative']),
+    scopeId: z.string().min(1),
+    includesChildren: z.boolean(),
+    usage: agentUsageSchema.optional(),
+    model: z.string().min(1).optional(),
+    models: z.record(z.string(), agentUsageSchema).optional(),
+}).strict()

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.1.0",
-    sha: "9cd95365c6d39d1f44098fdd8006087c3adabfb4",
-    buildTime: "2026-09-04T20:01:49.852Z",
+    version: "0.1.2",
+    sha: "85081b3dd3667033dfb1dfd399a6f59d3fd42d43",
+    buildTime: "2026-09-09T11:47:21.679Z",
 } as const

package/src/steps/contract.ts

@@ -0,0 +1,94 @@
+import { Buffer } from 'node:buffer'
+import { createHash } from 'node:crypto'
+import { z } from 'zod'
+import { agentEventActorSchema } from '../protocol/agent-event'
+import { jsonValueSchema } from '../protocol/agent-json'
+
+export const stepSummarySchema = z.object({
+    version: z.literal(1),
+    stepId: z.string().uuid(),
+    sessionId: z.string(),
+    provider: z.enum(['claude', 'codex']),
+    providerSessionId: z.string(),
+    sourceId: z.string(),
+    actor: agentEventActorSchema,
+    turnId: z.string(),
+    commandId: z.string().nullable(),
+    kind: z.enum(['message', 'tool', 'reasoning']),
+    role: z.enum(['assistant', 'user', 'system']).nullable(),
+    toolName: z.string().nullable(),
+    status: z.enum(['running', 'completed', 'failed', 'interrupted']),
+    incomplete: z.boolean(),
+    startedAt: z.string().datetime(),
+    endedAt: z.string().datetime().nullable(),
+    preview: z.string(),
+}).strict()
+export const stepDetailSchema = stepSummarySchema.extend({
+    content: z.record(z.string(), jsonValueSchema),
+}).strict()
+export type StepSummary = z.infer<typeof stepSummarySchema>
+export type StepDetailV1 = z.infer<typeof stepDetailSchema>
+
+/** Stable bytes across JSONB round trips and deterministic upload retries. */
+export function serializeStepDetail(value: unknown): string {
+    return JSON.stringify(value, (_key, item: unknown) => {
+        if (item && typeof item === 'object' && !Array.isArray(item))
+            return Object.fromEntries(Object.entries(item).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))
+        return item
+    })
+}
+
+export const stepClosedSchema = z.object({
+    step: stepSummarySchema,
+    sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+    byteSize: z.number().int().positive(),
+    textParts: z.number().int().nonnegative(),
+    detail: stepDetailSchema.optional(),
+    reference: z.string().startsWith('vault://').optional(),
+}).strict().refine(value => Boolean(value.detail) !== Boolean(value.reference), 'Exactly one detail source is required')
+
+export function stepIdFor(input: Pick<StepSummary, 'sessionId' | 'providerSessionId' | 'actor' | 'turnId' | 'kind' | 'sourceId'>): string {
+    const hex = createHash('sha256').update(JSON.stringify([
+        input.sessionId,
+        input.providerSessionId,
+        input.actor.actorId,
+        input.turnId,
+        input.kind,
+        input.sourceId,
+    ])).digest('hex')
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-5${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`
+}
+
+/** Both decoded UTF-8 and JSON representation stay bounded without dropping text. */
+export function splitStepText(text: string): string[] {
+    const parts: string[] = []
+    let part = ''
+    let bytes = 2
+    for (const character of text) {
+        const size = Buffer.byteLength(JSON.stringify(character)) - 2
+        if (bytes + size > 16 * 1024) {
+            parts.push(part)
+            part = ''
+            bytes = 2
+        }
+        part += character
+        bytes += size
+    }
+    if (part)
+        parts.push(part)
+    return parts
+}
+
+export function stepPreview(value: unknown): string {
+    const text = (typeof value === 'string' ? value : JSON.stringify(value) ?? '').replaceAll('\0', '\\0')
+    let preview = ''
+    let bytes = 0
+    for (const character of text) {
+        const size = Buffer.byteLength(JSON.stringify(character)) - 2
+        if (bytes + size > 2048)
+            return `${preview}…`
+        bytes += size
+        preview += character
+    }
+    return preview
+}

package/src/steps/projector.ts

@@ -0,0 +1,195 @@
+import type { AgentEvent } from '../protocol'
+import type { WireEventBody } from '../supervisor-protocol/event-body'
+import type { StepDetailV1, StepSummary } from './contract'
+import { Buffer } from 'node:buffer'
+import { createHash } from 'node:crypto'
+import { Database } from 'bun:sqlite'
+import { wrapAgentEvent } from '../supervisor-protocol/agent-event-wrapper'
+import { serializeStepDetail, splitStepText, stepIdFor, stepPreview } from './contract'
+
+/**
+ * Same-binary local recovery. The journal is marked delivered only after emit
+ * synchronously commits all frames into the supervisor's own durable outbox.
+ */
+export class DurableStepProjector {
+    private readonly db: Database
+    private currentEventId = ''
+
+    constructor(private readonly options: {
+        path: string
+        upload: (input: { stepId: string, sha256: string, body: string, byteSize: number }) => Promise<string>
+    }) {
+        this.db = new Database(options.path, { create: true })
+        this.db.exec(`pragma journal_mode=WAL; pragma synchronous=FULL;
+            create table if not exists steps(id text primary key, body text not null, last_event_id text);
+            create table if not exists journal(id text primary key, event text, frames text);
+        `)
+        if (!this.db.query<{ name: string }, []>('pragma table_info(steps)').all().some(column => column.name === 'last_event_id'))
+            this.db.exec('alter table steps add column last_event_id text')
+    }
+
+    close(): void { this.db.close() }
+
+    async recover(emit: (body: WireEventBody) => void): Promise<void> {
+        for (;;) {
+            const row = this.db.query<{ id: string, event: string, frames: string | null }, []>(
+                'select id, event, frames from journal where event is not null order by rowid limit 1',
+            ).get()
+            if (!row)
+                return
+            await this.deliver(row.id, JSON.parse(row.event) as AgentEvent, row.frames, emit)
+        }
+    }
+
+    async process(event: AgentEvent, emit: (body: WireEventBody) => void): Promise<void> {
+        if (['message.delta', 'tool.output.delta', 'reasoning.summary.delta'].includes(event.type)) {
+            // Live deltas never become historical tool payloads. Large transport
+            // deltas are split rather than dropped by the supervisor frame limit.
+            const body = wrapAgentEvent(event)
+            const key = event.type === 'reasoning.summary.delta' ? 'text' : 'delta'
+            const payload = event.payload as Record<string, unknown>
+            for (const part of splitStepText(String(payload[key] ?? ''))) {
+                // Use smaller slices for envelope headroom within the 16 KiB cap.
+                for (const chunk of splitStepText(part).flatMap(part => [...part].length > 2000 ? part.match(/.{1,2000}/gsu)! : [part]))
+                    emit({ ...body, payload: { ...payload, [key]: chunk } } as WireEventBody)
+            }
+            return
+        }
+        const found = this.db.query<{ event: string | null, frames: string | null }, [string]>(
+            'select event, frames from journal where id=?',
+        ).get(event.eventId)
+        if (found?.event === null)
+            return
+        if (!found)
+            this.db.query('insert into journal(id,event) values (?,?)').run(event.eventId, JSON.stringify(event))
+        await this.deliver(event.eventId, event, found?.frames ?? null, emit)
+    }
+
+    private async deliver(id: string, event: AgentEvent, saved: string | null, emit: (body: WireEventBody) => void): Promise<void> {
+        this.currentEventId = id
+        const frames = saved ? JSON.parse(saved) as WireEventBody[] : await this.project(event)
+        if (!saved)
+            this.db.query('update journal set frames=? where id=?').run(JSON.stringify(frames), id)
+        for (const frame of frames)
+            emit(frame)
+        this.db.query('update journal set event=null, frames=null where id=?').run(id)
+    }
+
+    private async project(event: AgentEvent): Promise<WireEventBody[]> {
+        const kind = event.type.startsWith('message.')
+            ? 'message'
+            : event.type.startsWith('tool.call.')
+                ? 'tool'
+                : event.type.startsWith('reasoning.') ? 'reasoning' : undefined
+        if (!kind || !('turnId' in event)) {
+            const frames: WireEventBody[] = []
+            if (event.type === 'turn.ended' || event.type === 'session.ended') {
+                for (const row of this.db.query<{ body: string, last_event_id: string | null }, []>('select body, last_event_id from steps').all()) {
+                    const step = JSON.parse(row.body) as StepDetailV1
+                    if ((step.status !== 'running' && row.last_event_id !== event.eventId) || (event.type === 'turn.ended' && (step.turnId !== event.turnId || step.actor.actorId !== event.actor.actorId)))
+                        continue
+                    step.status = event.type === 'turn.ended' && event.payload.status === 'failed' ? 'failed' : 'interrupted'
+                    step.incomplete = true
+                    step.endedAt = event.timestamp
+                    frames.push(...await this.finish(step))
+                }
+            }
+            frames.push(wrapAgentEvent(event))
+            return frames
+        }
+        const payload = event.payload as Record<string, unknown>
+        const sourceId = String(payload.messageId ?? payload.toolCallId ?? payload.reasoningId)
+        const identity = { sessionId: event.sessionId, providerSessionId: event.providerSessionId, actor: event.actor, turnId: event.turnId, kind: kind as StepSummary['kind'], sourceId }
+        const stepId = stepIdFor(identity)
+        const row = this.db.query<{ body: string, last_event_id: string | null }, [string]>('select body, last_event_id from steps where id=?').get(stepId)
+        const step: StepDetailV1 = row
+            ? JSON.parse(row.body)
+            : {
+                    ...identity,
+                    stepId,
+                    version: 1,
+                    provider: event.provider,
+                    commandId: typeof payload.commandId === 'string' ? payload.commandId : null,
+                    role: kind === 'message' ? payload.role as StepSummary['role'] : null,
+                    toolName: typeof payload.toolName === 'string' ? payload.toolName : null,
+                    status: 'running',
+                    incomplete: !event.type.endsWith('started'),
+                    startedAt: event.timestamp,
+                    endedAt: null,
+                    preview: '',
+                    content: {},
+                }
+        if (step.status !== 'running' && row?.last_event_id !== event.eventId)
+            return []
+        if (event.type.endsWith('started')) {
+            if (row && row.last_event_id !== event.eventId)
+                return []
+            if (step.status !== 'running')
+                return []
+            if (kind === 'tool') {
+                step.content.input = payload.input as StepDetailV1['content'][string] ?? null
+                step.preview = stepPreview(payload.input)
+            }
+            this.save(step)
+            return [this.frame('product.step.started', { step: summary(step) })]
+        }
+        if (kind === 'message') {
+            step.content.text = typeof payload.text === 'string' ? payload.text : ''
+            step.preview = ''
+        }
+        else if (kind === 'tool') {
+            step.content.output = payload.output as StepDetailV1['content'][string] ?? null
+            step.content.error = payload.error as StepDetailV1['content'][string] ?? null
+            step.preview = stepPreview(payload.output ?? payload.error)
+        }
+        else {
+            step.content.summary = typeof payload.summary === 'string' ? payload.summary : ''
+            step.preview = stepPreview(payload.summary)
+        }
+        step.status = payload.status === 'failed' ? 'failed' : payload.status === 'cancelled' ? 'interrupted' : 'completed'
+        if (kind === 'tool' && payload.output === undefined && payload.error === undefined) {
+            step.incomplete = true
+            step.status = 'interrupted'
+        }
+        step.endedAt = event.timestamp
+        if (payload.overflow)
+            throw new Error('Step projection requires complete provider content before overflow truncation.')
+        return await this.finish(step)
+    }
+
+    private async finish(step: StepDetailV1): Promise<WireEventBody[]> {
+        if (step.kind === 'message') {
+            // References, not repeated complete tool payloads, connect message content.
+            step.content.toolSteps = this.db.query<{ id: string }, [string, string]>(`
+                select id from steps where json_extract(body,'$.kind')='tool'
+                and json_extract(body,'$.turnId')=? and json_extract(body,'$.actor.actorId')=? order by rowid
+            `).all(step.turnId, step.actor.actorId).map(row => row.id)
+        }
+        this.save(step)
+        const body = serializeStepDetail(step)
+        const sha256 = createHash('sha256').update(body).digest('hex')
+        const byteSize = Buffer.byteLength(body)
+        const text = step.kind === 'message' && typeof step.content.text === 'string' ? splitStepText(step.content.text) : []
+        const detailSource = byteSize <= 32 * 1024
+            ? { detail: step }
+            : { reference: await this.options.upload({ stepId: step.stepId, sha256, byteSize, body }) }
+        return [
+            ...text.map((part, index) => this.frame('product.step.text', { step: summary(step), index, count: text.length, text: part })),
+            this.frame('product.step.closed', { step: summary(step), sha256, byteSize, textParts: text.length, ...detailSource }),
+        ]
+    }
+
+    private save(step: StepDetailV1): void {
+        this.db.query('insert into steps(id,body,last_event_id) values (?,?,?) on conflict(id) do update set body=excluded.body,last_event_id=excluded.last_event_id')
+            .run(step.stepId, JSON.stringify(step), this.currentEventId)
+    }
+
+    private frame(type: `product.${string}`, payload: unknown): WireEventBody {
+        return { type, payload } as WireEventBody
+    }
+}
+
+function summary(step: StepDetailV1): StepSummary {
+    const { content: _content, ...value } = step
+    return value
+}

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

@@ -16,6 +16,10 @@ export interface AgentProviderBindingStore {
 }
 
 export interface AgentSupervisorProviderFactoryOptions {
+    eventProcessor?: {
+        recover: (emit: (body: WireEventBody) => void) => Promise<void>
+        process: (event: AgentEvent, emit: (body: WireEventBody) => void) => Promise<void>
+    }
     createProvider: (input: {
         bootstrap: SessionBootstrapBody
         credentials?: EphemeralCredentials
@@ -69,6 +73,9 @@ export function createAgentSupervisorProviderFactory(
 
         return new AgentSupervisorRuntime({
             run,
+            emit: input.emit,
+            onFatal: input.onFatal,
+            eventProcessor: options.eventProcessor,
             prepareInputAttachments: options.prepareInputAttachments,
             onSecretsRefreshed: options.onSecretsRefreshed,
         })
@@ -76,17 +83,27 @@ export function createAgentSupervisorProviderFactory(
 }
 
 class AgentSupervisorRuntime implements SupervisorAgentRuntime {
+    private readonly attached = Promise.withResolvers<void>()
     private state: SupervisorAgentRunSnapshot = { status: 'attached', agentState: null }
     private emit: ((body: WireEventBody) => void) | undefined
     private readonly pendingEvents: WireEventBody[] = []
     private readonly eventPump: Promise<void>
+    private eventFailure: unknown
 
     constructor(private readonly input: {
         run: AgentRun
+        emit?: (body: WireEventBody) => void
+        onFatal?: (error: unknown) => void
+        eventProcessor?: AgentSupervisorProviderFactoryOptions['eventProcessor']
         prepareInputAttachments?: AgentSupervisorProviderFactoryOptions['prepareInputAttachments']
         onSecretsRefreshed?: AgentSupervisorProviderFactoryOptions['onSecretsRefreshed']
     }) {
-        this.eventPump = this.consumeEvents()
+        if (input.emit)
+            this.attachEmitter(input.emit)
+        this.eventPump = this.consumeEvents().catch((error: unknown) => {
+            this.eventFailure = error
+            input.onFatal?.(error)
+        })
     }
 
     snapshot(): SupervisorAgentRunSnapshot {
@@ -94,6 +111,8 @@ class AgentSupervisorRuntime implements SupervisorAgentRuntime {
     }
 
     async handle(input: Parameters<SupervisorAgentRuntime['handle']>[0]): Promise<void> {
+        if (this.eventFailure)
+            throw this.eventFailure
         this.attachEmitter(input.emit)
         const metadata = this.input.run.metadata
         if (input.body.type === 'agent.send-prompt') {
@@ -154,6 +173,7 @@ class AgentSupervisorRuntime implements SupervisorAgentRuntime {
     }
 
     async close(input: { signal: AbortSignal }): Promise<void> {
+        this.attached.resolve()
         const metadata = this.input.run.metadata
         await this.input.run.stop({
             type: 'agent.stop',
@@ -167,15 +187,25 @@ class AgentSupervisorRuntime implements SupervisorAgentRuntime {
 
     private attachEmitter(emit: (body: WireEventBody) => void): void {
         this.emit = emit
+        this.attached.resolve()
         for (const event of this.pendingEvents.splice(0))
             emit(event)
     }
 
     private async consumeEvents(): Promise<void> {
+        if (this.input.eventProcessor) {
+            await this.attached.promise
+            if (!this.emit)
+                return
+            await this.input.eventProcessor.recover(body => this.emit!(body))
+        }
         for await (const event of this.input.run.events) {
             if (event.type === 'session.state.changed')
                 this.state = { status: 'attached', agentState: event.payload.state }
-            this.emitEvent(event)
+            if (this.input.eventProcessor)
+                await this.input.eventProcessor.process(event, body => this.emit!(body))
+            else
+                this.emitEvent(event)
         }
     }
 

package/src/supervisor/bootstrap-binder.ts

@@ -34,7 +34,12 @@ export function createBootstrapBinder(input: {
     shutdown: (code: number) => void
     logger: Logger
 }): BootstrapBinder {
+    let pending = Promise.resolve()
     return async (request) => {
+        const previous = pending
+        const released = Promise.withResolvers<void>()
+        pending = released.promise
+        await previous
         try {
             return await bind(request)
         }
@@ -55,6 +60,9 @@ export function createBootstrapBinder(input: {
                 terminate: () => input.shutdown(TERMINAL_ERROR_CODE),
             }
         }
+        finally {
+            released.resolve()
+        }
     }
 
     async function bind(request: {

package/src/supervisor/provider-factory.ts

@@ -27,6 +27,8 @@ export interface SupervisorProviderFactory {
         gitToken?: SessionBootstrapGitToken
         rpc: SupervisorRpcClient
         signal: AbortSignal
+        emit?: (body: WireEventBody) => void
+        onFatal?: (error: unknown) => void
     }) => Promise<SupervisorAgentRuntime>
 }
 

package/src/supervisor/runtime-handler.ts

@@ -185,6 +185,8 @@ export class SupervisorRuntimeHandler implements RuntimeConnectionHandler {
                 ...initialSecrets,
                 rpc: this.rpc,
                 signal: this.lifecycleController.signal,
+                emit: body => this.emit(body),
+                onFatal: error => this.dependencies.onFatal(error),
             }).then(async (agent) => {
                 if ((this.dependencies.credentials !== initialSecrets.credentials
                     || this.dependencies.gitToken !== initialSecrets.gitToken) && agent.refreshSecrets) {

package/src/supervisor/websocket-server.ts

@@ -381,6 +381,7 @@ export class ResidentSupervisorWebSocketServer {
                 return
             input.socket.data.terminalRejection = undefined
             input.socket.close(internalErrorCloseCode, 'Supervisor rejection receipt was not observed.')
+            input.terminate()
         }, terminalRejectionReceiptBudgetMs)
         timeout.unref?.()
         input.socket.data.terminalRejection = { terminate: input.terminate, timeout }

package/src/testing/in-memory-runtime-control-plane.ts

@@ -26,6 +26,7 @@ EphemeralEventSink, RpcDispatcher, BootstrapProvider, SessionFailureSink, Runtim
     readonly ephemeralEventLog: Array<Parameters<EphemeralEventSink['publish']>[0]> = []
     readonly readySnapshots: SupervisorAgentRunSnapshot[] = []
     readonly projectedCommandSequences: number[] = []
+    readonly failedCommandSequences: number[] = []
     readonly failureLog: Array<{ kind: string, code?: string, detail?: string }> = []
     readonly rpcCalls: SupervisorRpcRequestEnvelope[] = []
     onDurableRecord: ((event: DurableEventEnvelope) => void | Promise<void>) | undefined
@@ -105,7 +106,7 @@ EphemeralEventSink, RpcDispatcher, BootstrapProvider, SessionFailureSink, Runtim
         return {
             renewed,
             ...(renewed ? { leaseExpiresAt: new Date(Date.now() + 30_000) } : {}),
-            hasOutstandingCommand: this.projectedCommandSequences.length < this.commandLog.length - 1,
+            hasOutstandingCommand: this.projectedCommandSequences.length + this.failedCommandSequences.length < this.commandLog.length,
         }
     }
 
@@ -131,10 +132,6 @@ EphemeralEventSink, RpcDispatcher, BootstrapProvider, SessionFailureSink, Runtim
         return this.claimed && input.generation === this.generation
     }
 
-    async projectAppliedCommand(input: { commandSeq: number }): Promise<void> {
-        this.projectedCommandSequences.push(input.commandSeq)
-    }
-
     async initial(): Promise<CommandEnvelope | undefined> {
         return this.commandLog[0]
     }
@@ -157,6 +154,10 @@ EphemeralEventSink, RpcDispatcher, BootstrapProvider, SessionFailureSink, Runtim
             return { status: 'duplicate', highWaterMark: this.ackFloor }
         if (event.seq !== this.ackFloor + 1)
             return { status: 'gap' }
+        if (event.body.type === 'supervisor.command.applied')
+            this.projectedCommandSequences.push(event.body.payload.commandSeq)
+        if (event.body.type === 'supervisor.command.failed')
+            this.failedCommandSequences.push(event.body.payload.commandSeq)
         this.durableEventLog.push(event)
         this.ackFloor = event.seq
         await this.onDurableRecord?.(event)

package/src/worker-runtime-client/command-pump.ts

@@ -98,11 +98,6 @@ export class SessionCommandPump {
                         return
                     }
                     this.afterSequence = ack.commandSeq
-                    await this.dependencies.authorityStore.projectAppliedCommand({
-                        sessionSandboxId: this.dependencies.sessionSandboxId,
-                        runtimeConnectionId: this.dependencies.runtimeConnectionId,
-                        commandSeq: ack.commandSeq,
-                    })
                 }
             }
         }

package/src/worker-runtime-client/connection-attempt.ts

@@ -31,6 +31,7 @@ export class SessionSandboxConnectionAttempt {
 
     constructor(private readonly dependencies: {
         claim: ConnectionClaim
+        establishmentDeadline: number
         replicaId: string
         trafficTokenEncryptionKey: string
         signControlAuthority: ControlAuthoritySigner
@@ -96,7 +97,7 @@ export class SessionSandboxConnectionAttempt {
             signal: this.controller.signal,
             onMessage: frame => this.processor ? this.processor.receive(frame) : queuedFrames.push(frame),
             onClose: close => closed.resolve(close),
-        }), performance.now() + this.dependencies.timings.dialTimeoutMs, this.controller.signal, () => new ConnectionClosedError({
+        }), Math.min(this.dependencies.establishmentDeadline, performance.now() + this.dependencies.timings.dialTimeoutMs), this.controller.signal, () => new ConnectionClosedError({
             ready: false,
             detail: 'Supervisor connection dial timed out.',
         }))
@@ -160,7 +161,15 @@ export class SessionSandboxConnectionAttempt {
             ...secrets,
         }))
 
-        const readiness = await processor.waitForReadiness({ signal: this.controller.signal }).catch(async (error: unknown) => {
+        const readiness = await beforeDeadline(Promise.race([
+            processor.waitForReadiness({ signal: this.controller.signal }),
+            closed.promise.then((close) => {
+                throw new ConnectionClosedError({ ready: false, detail: `${close.code}:${close.reason}` })
+            }),
+        ]), Math.min(this.dependencies.establishmentDeadline, performance.now() + 10_000), this.controller.signal, () => new ConnectionClosedError({
+            ready: false,
+            detail: 'Supervisor bootstrap timed out.',
+        })).catch(async (error: unknown) => {
             if (error instanceof BootstrapRejectedAckError) {
                 await processor.acknowledgeBootstrapRejection(error.ack)
                 throw new DeterministicEstablishmentError(error.ack.errorCode, error.ack.detail, true)

package/src/worker-runtime-client/ports.ts

@@ -44,7 +44,6 @@ export interface ConnectionAuthorityStore {
     markConnectionReconnecting: (input: { sessionSandboxId: string, generation: number }) => Promise<void>
     releaseConnection: (input: { sessionSandboxId: string, generation: number, reason: string }) => Promise<void>
     markConnectionRetryExhausted: (input: { sessionSandboxId: string, generation: number, replicaId: string }) => Promise<boolean>
-    projectAppliedCommand: (input: { sessionSandboxId: string, runtimeConnectionId: string, commandSeq: number }) => Promise<void>
 }
 
 export interface CommandSource {
@@ -58,6 +57,9 @@ export type DurableEventResult
 
 export interface DurableEventSink {
     getAckFloor: (input: { sessionSandboxId: string }) => Promise<number>
+    // Atomically persist the event, advance the ACK floor, and project its command outcome.
+    // Only supervisor.command.applied marks a command applied; received ACKs never do.
+    // Replayed events must not duplicate projections, including after reconnect.
     record: (input: SessionSandboxRef & { runtimeConnectionId: string, event: DurableEventEnvelope }) => Promise<DurableEventResult>
 }
 

package/src/worker-runtime-client/sandbox-connection-runtime.ts

@@ -154,6 +154,7 @@ class OwnedConnection {
             while (!this.controller.signal.aborted) {
                 const attempt = new SessionSandboxConnectionAttempt({
                     claim,
+                    establishmentDeadline,
                     replicaId: this.dependencies.replicaId,
                     trafficTokenEncryptionKey: this.dependencies.trafficTokenEncryptionKey,
                     signControlAuthority: this.dependencies.signControlAuthority,