@myagentroam/node 0.9.2 → 0.9.4

package/dist/database.js

@@ -552,11 +552,6 @@ export class NodeDatabase {
             this.raw
                 .prepare('UPDATE legacy_agent_sessions SET last_activity_at = ?, updated_at = ? WHERE id = ?')
                 .run(value.createdAt, value.createdAt, value.sessionId);
-            this.recordWorkspaceActivity(value.workspaceId, 'run.created', {
-                runId: value.id,
-                sessionId: value.sessionId,
-                runner: value.runner
-            });
             this.raw.exec('COMMIT');
             return { run: value, created: true };
         }
@@ -632,14 +627,6 @@ export class NodeDatabase {
             .get(input.runId, input.sequence);
         const value = event(stored);
         this.projectRunEvent(value, input.status);
-        const run = this.getRun(input.runId);
-        if (run !== undefined) {
-            this.recordWorkspaceActivity(run.workspaceId, 'run.updated', {
-                runId: run.id,
-                eventType: input.eventType,
-                status: input.status ?? null
-            });
-        }
         return value;
     }
     listRunEvents(runId, after = 0) {
@@ -709,25 +696,6 @@ export class NodeDatabase {
                 : null
         };
     }
-    listWorkspaceActivity(input) {
-        if (this.getWorkspace(input.workspaceId) === undefined)
-            throw new Error('WORKSPACE_NOT_FOUND');
-        const limit = pageLimit(input.limit);
-        const cursor = decodeCursor(input.cursor, 'workspace-activity', input.workspaceId);
-        const rows = this.raw
-            .prepare(`SELECT id, workspace_id, event_type, payload, created_at FROM workspace_activity_events
-         WHERE workspace_id = ? AND (? IS NULL OR id > ?)
-         ORDER BY id ASC LIMIT ?`)
-            .all(input.workspaceId, cursor === undefined ? null : cursor.value, cursor?.value ?? 0, limit + 1);
-        const page = rows.slice(0, limit);
-        const last = page.at(-1);
-        return {
-            events: page.map((row) => workspaceActivityEvent(row)),
-            nextCursor: rows.length > limit && last !== undefined
-                ? encodeCursor('workspace-activity', input.workspaceId, numberValue(last, 'id'), '')
-                : null
-        };
-    }
     createApproval(input) {
         if (this.getRun(input.runId) === undefined)
             throw new Error('RUN_NOT_FOUND');
@@ -828,18 +796,6 @@ export class NodeDatabase {
             .get(runId);
         return row['sequence'] === null ? 0 : numberValue(row, 'sequence');
     }
-    saveSnapshot(runId, snapshot) {
-        this.raw
-            .prepare(`INSERT INTO run_snapshots (run_id, snapshot, created_at) VALUES (?, ?, ?)
-         ON CONFLICT(run_id) DO UPDATE SET snapshot = excluded.snapshot, created_at = excluded.created_at`)
-            .run(runId, JSON.stringify(snapshot), this.now());
-    }
-    getSnapshot(runId) {
-        const row = this.raw
-            .prepare('SELECT snapshot FROM run_snapshots WHERE run_id = ?')
-            .get(runId);
-        return row === undefined ? undefined : JSON.parse(stringValue(row, 'snapshot'));
-    }
     markActiveRunsSuspect() {
         this.raw
             .prepare("UPDATE agent_runs SET recovery_state = 'SUSPECT', recovery_updated_at = ? WHERE status NOT IN ('SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED')")
@@ -877,12 +833,6 @@ export class NodeDatabase {
             .prepare("UPDATE workspace_leases SET state = 'RELEASED', updated_at = ? WHERE run_id = ? AND state IN ('ACTIVE', 'SUSPECT')")
             .run(this.now(), runId);
     }
-    recordWorkspaceActivity(workspaceId, eventType, payload) {
-        this.raw
-            .prepare(`INSERT INTO workspace_activity_events (workspace_id, event_type, payload, created_at)
-         VALUES (?, ?, ?, ?)`)
-            .run(workspaceId, eventType, JSON.stringify(payload), this.now());
-    }
     recordConversationItemChange(sessionId, itemId, revision) {
         this.raw
             .prepare(`INSERT INTO conversation_item_events (session_id, item_id, revision, created_at)
@@ -1206,10 +1156,8 @@ function initializeEphemeralRuntimeTables(database) {
         'conversation_turns',
         'conversation_items',
         'conversation_item_events',
-        'workspace_activity_events',
         'approvals',
-        'workspace_leases',
-        'run_snapshots'
+        'workspace_leases'
     ]);
     for (const raw of NODE_SCHEMA_V1.split(';')) {
         const statement = raw.trim();
@@ -1341,15 +1289,6 @@ function conversationItem(row) {
         completedAt: nullableNumber(row, 'completed_at')
     };
 }
-function workspaceActivityEvent(row) {
-    return {
-        id: numberValue(row, 'id'),
-        workspaceId: stringValue(row, 'workspace_id'),
-        eventType: stringValue(row, 'event_type'),
-        payload: JSON.parse(stringValue(row, 'payload')),
-        createdAt: numberValue(row, 'created_at')
-    };
-}
 function pageLimit(value) {
     if (value === undefined)
         return 100;

package/dist/event-buffer.d.ts

@@ -1,12 +1,9 @@
 import { type NodeEnvelope, type WorkbenchEvent } from '@myagentroam/protocol';
-/**
- * Keeps exactly the page-level business frames that have not received a Server
- * ACK. Node-global sequences make a reconnect replay harmless.
- */
+/** Keeps live page-level frames only until the current Server connection ACKs them. */
 export declare class ReliableWorkbenchEventBuffer {
     private readonly pending;
     queue(event: WorkbenchEvent): NodeEnvelope;
     acknowledge(replyTo: string | undefined): boolean;
-    replay(send: (envelope: NodeEnvelope) => void): void;
+    clear(): void;
     get size(): number;
 }

package/dist/event-buffer.js

@@ -1,8 +1,5 @@
 import { createEnvelope } from '@myagentroam/protocol';
-/**
- * Keeps exactly the page-level business frames that have not received a Server
- * ACK. Node-global sequences make a reconnect replay harmless.
- */
+/** Keeps live page-level frames only until the current Server connection ACKs them. */
 export class ReliableWorkbenchEventBuffer {
     pending = new Map();
     queue(event) {
@@ -13,14 +10,8 @@ export class ReliableWorkbenchEventBuffer {
     acknowledge(replyTo) {
         return replyTo !== undefined && this.pending.delete(replyTo);
     }
-    replay(send) {
-        const ordered = [...this.pending.values()].sort((left, right) => {
-            const a = left.payload;
-            const b = right.payload;
-            return a.sequence - b.sequence;
-        });
-        for (const envelope of ordered)
-            send(envelope);
+    clear() {
+        this.pending.clear();
     }
     get size() {
         return this.pending.size;

package/dist/native-session-history.js

@@ -9,7 +9,9 @@ const DISCOVERY_READ_BYTES = 32 * 1024;
 const TRANSCRIPT_READ_BYTES = 4 * 1024 * 1024;
 const CONTEXT_USAGE_READ_BYTES = 256 * 1024;
 const CLAUDE_CONTEXT_USAGE_READ_BYTES = [CONTEXT_USAGE_READ_BYTES, 1024 * 1024, 4 * 1024 * 1024];
+const TRANSCRIPT_INDEX_TTL_MS = 60 * 60_000;
 const transcriptIndex = new Map();
+const transcriptIndexTimers = new Map();
 const discoveryReads = new Map();
 const DEFAULT_CLAUDE_CONTEXT_WINDOW_TOKENS = 200_000;
 const CLAUDE_CONTEXT_WINDOW_ENV = 'MAR_CLAUDE_CONTEXT_WINDOW_TOKENS';
@@ -53,7 +55,7 @@ async function performNativeSessionDiscovery(runner) {
         if (parsed === undefined)
             continue;
         const cwd = canonical(parsed.cwd);
-        transcriptIndex.set(indexKey(runner, cwd, parsed.externalSessionId), files[index]);
+        setTranscriptIndex(indexKey(runner, cwd, parsed.externalSessionId), files[index]);
         found.set(`${cwd}\u0000${parsed.externalSessionId}`, parsed);
     }
     nodeLog('native.session.discovery.completed', {
@@ -83,14 +85,14 @@ async function readDiscoveryHeaders(files, runner) {
 /** Reads one already-discovered external session again to follow appended JSONL records. */
 export async function readNativeSession(runner, workspacePath, externalSessionId) {
     const wanted = canonical(workspacePath);
-    const path = transcriptIndex.get(indexKey(runner, wanted, externalSessionId));
+    const path = getTranscriptIndex(indexKey(runner, wanted, externalSessionId));
     if (path === undefined)
         return undefined;
     const parsed = await readTranscript(path, runner, TRANSCRIPT_READ_BYTES);
     if (parsed === undefined ||
         parsed.externalSessionId !== externalSessionId ||
         canonical(parsed.cwd) !== wanted) {
-        transcriptIndex.delete(indexKey(runner, wanted, externalSessionId));
+        deleteTranscriptIndex(indexKey(runner, wanted, externalSessionId));
         return undefined;
     }
     return parsed;
@@ -103,10 +105,10 @@ export async function readNativeSession(runner, workspacePath, externalSessionId
  */
 export async function readCodexNativeContextUsage(workspacePath, externalSessionId) {
     const wanted = canonical(workspacePath);
-    let path = transcriptIndex.get(indexKey('codex', wanted, externalSessionId));
+    let path = getTranscriptIndex(indexKey('codex', wanted, externalSessionId));
     if (path === undefined) {
         await discoverNativeSessions('codex', workspacePath);
-        path = transcriptIndex.get(indexKey('codex', wanted, externalSessionId));
+        path = getTranscriptIndex(indexKey('codex', wanted, externalSessionId));
     }
     if (path === undefined)
         return undefined;
@@ -124,11 +126,11 @@ export async function readCodexNativeContextUsage(workspacePath, externalSession
 /** Reads the latest actual Claude prompt occupancy without starting a CLI/SDK control stream. */
 export async function readClaudeNativeContextUsage(workspacePath, externalSessionId, options = {}) {
     const wanted = canonical(workspacePath);
-    let path = transcriptIndex.get(indexKey('claude-code', wanted, externalSessionId));
+    let path = getTranscriptIndex(indexKey('claude-code', wanted, externalSessionId));
     path ??= await locateClaudeTranscript(wanted, externalSessionId);
     if (path === undefined) {
         await discoverNativeSessions('claude-code', workspacePath);
-        path = transcriptIndex.get(indexKey('claude-code', wanted, externalSessionId));
+        path = getTranscriptIndex(indexKey('claude-code', wanted, externalSessionId));
     }
     if (path === undefined)
         return undefined;
@@ -178,7 +180,7 @@ async function locateClaudeTranscript(wantedCwd, externalSessionId) {
     const match = parsed.find(({ history }) => history?.externalSessionId === externalSessionId && canonical(history.cwd) === wantedCwd);
     if (match === undefined)
         return undefined;
-    transcriptIndex.set(indexKey('claude-code', wantedCwd, externalSessionId), match.path);
+    setTranscriptIndex(indexKey('claude-code', wantedCwd, externalSessionId), match.path);
     return match.path;
 }
 export async function claudeContextWindowTokens(options = {}) {
@@ -207,10 +209,10 @@ export async function claudeContextWindowTokens(options = {}) {
  */
 export async function removeNativeSession(runner, workspacePath, externalSessionId) {
     const wanted = canonical(workspacePath);
-    let path = transcriptIndex.get(indexKey(runner, wanted, externalSessionId));
+    let path = getTranscriptIndex(indexKey(runner, wanted, externalSessionId));
     if (path === undefined) {
         await discoverNativeSessions(runner, workspacePath);
-        path = transcriptIndex.get(indexKey(runner, wanted, externalSessionId));
+        path = getTranscriptIndex(indexKey(runner, wanted, externalSessionId));
     }
     if (path === undefined)
         throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
@@ -218,7 +220,7 @@ export async function removeNativeSession(runner, workspacePath, externalSession
     if (parsed === undefined ||
         parsed.externalSessionId !== externalSessionId ||
         canonical(parsed.cwd) !== wanted) {
-        transcriptIndex.delete(indexKey(runner, wanted, externalSessionId));
+        deleteTranscriptIndex(indexKey(runner, wanted, externalSessionId));
         throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
     }
     try {
@@ -229,7 +231,7 @@ export async function removeNativeSession(runner, workspacePath, externalSession
             throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
         throw error;
     }
-    transcriptIndex.delete(indexKey(runner, wanted, externalSessionId));
+    deleteTranscriptIndex(indexKey(runner, wanted, externalSessionId));
 }
 function transcriptRoot(runner) {
     return runner === 'codex'
@@ -886,6 +888,25 @@ function canonical(value) {
 function indexKey(runner, cwd, externalSessionId) {
     return `${runner}\u0000${cwd}\u0000${externalSessionId}`;
 }
+function setTranscriptIndex(key, path) {
+    const previousTimer = transcriptIndexTimers.get(key);
+    if (previousTimer !== undefined)
+        clearTimeout(previousTimer);
+    transcriptIndex.set(key, path);
+    const timer = setTimeout(() => deleteTranscriptIndex(key), TRANSCRIPT_INDEX_TTL_MS);
+    timer.unref();
+    transcriptIndexTimers.set(key, timer);
+}
+function getTranscriptIndex(key) {
+    return transcriptIndex.get(key);
+}
+function deleteTranscriptIndex(key) {
+    const timer = transcriptIndexTimers.get(key);
+    if (timer !== undefined)
+        clearTimeout(timer);
+    transcriptIndexTimers.delete(key);
+    transcriptIndex.delete(key);
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

package/dist/runner/claude/managed-run-controller.d.ts

@@ -26,7 +26,6 @@ export interface ClaudeManagedRunHost<TAttachment extends ClaudeRunnerImageAttac
     hasActiveSessionLease(sessionId: string): boolean;
     session(sessionId: string): NodeAgentSession | undefined;
     completeCancelled(runId: string, cwd: string): boolean;
-    captureSnapshot(runId: string, cwd: string): Promise<void>;
     requestUserInput(runId: string, input: Record<string, unknown>, toolUseId: string): Promise<ReturnType<typeof denyPermission>>;
     requestApproval(runId: string, toolName: string, input: Record<string, unknown>): Promise<ReturnType<typeof denyPermission>>;
     rememberNative(nativeSessionId: string, sessionId: string): void;

package/dist/runner/claude/managed-run-controller.js

@@ -1,10 +1,10 @@
 import { createEnvelope } from '@myagentroam/protocol';
 import { ClaudeChannelGate } from '../../claude-channel.js';
 import { boundedConversationItemId, claudePlanText, compactRunnerText, compactRunnerValue, extractClaudeText, extractClaudeThinkingSummaries, extractClaudeToolResults, extractClaudeToolUses, isClaudeCommandTool } from '../codex/conversation-parser.js';
-import { isTerminalRunStatus } from '../../util/node-operation-parsers.js';
 import { claudeContentBlocks } from '../../util/node-operation-parsers.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
+import { runnerErrorProjection } from '../../util/runner-error.js';
 export class ClaudeManagedRunController {
     runner;
     host;
@@ -116,16 +116,25 @@ export class ClaudeManagedRunController {
         let terminal = false;
         let handle;
         const toolKinds = new Map();
-        const finish = (status, eventType, eventPayload) => {
+        const finish = (status, eventType, eventPayload, failure, fallbackCode = 'CLAUDE_RUN_FAILED') => {
             if (terminal)
                 return;
             terminal = true;
-            this.host.emit(runId, eventType, eventPayload, status);
+            const projected = status === 'FAILED'
+                ? runnerErrorProjection(failure ?? eventPayload, fallbackCode)
+                : undefined;
+            if (projected !== undefined) {
+                this.host.emitItem(runId, {
+                    itemId: boundedConversationItemId('runner-error', runId),
+                    kind: 'error',
+                    status: 'FAILED',
+                    payload: { ...projected, recoverable: true, retryAfterMs: null }
+                });
+            }
+            this.host.emit(runId, eventType, projected ?? eventPayload, status);
             this.runner.execution.runs.delete(runId);
             handle?.cancel();
             this.host.active.delete(runId);
-            if (isTerminalRunStatus(status))
-                void this.host.captureSnapshot(runId, cwd);
         };
         try {
             const gate = new ClaudeChannelGate(sessionId);
@@ -314,7 +323,7 @@ export class ClaudeManagedRunController {
                         // result completes this AgentRun even though that iterable can
                         // remain open waiting for another user turn; waiting only for
                         // stream closure would leave the WorkspaceLease permanently held.
-                        finish(subtype === 'success' && record.is_error !== true ? 'SUCCEEDED' : 'FAILED', subtype === 'success' && record.is_error !== true ? 'run.completed' : 'run.failed', { subtype });
+                        finish(subtype === 'success' && record.is_error !== true ? 'SUCCEEDED' : 'FAILED', subtype === 'success' && record.is_error !== true ? 'run.completed' : 'run.failed', { subtype }, record);
                         if (completedNativeSessionId !== undefined)
                             void this.host.syncTitle(sessionId, completedNativeSessionId, cwd);
                     }
@@ -324,14 +333,10 @@ export class ClaudeManagedRunController {
             this.host.setChannelToken(sessionId, gate.token);
             this.host.send('session.channel.ready', { sessionId, token: gate.token });
             this.host.emit(runId, 'run.running', {}, 'RUNNING');
-            void handle.completed.then(() => finish('SUCCEEDED', 'run.completed', { subtype: 'stream_closed' }), (error) => finish('FAILED', 'run.failed', {
-                code: safeErrorCode(error, 'CLAUDE_RUN_FAILED')
-            }));
+            void handle.completed.then(() => finish('SUCCEEDED', 'run.completed', { subtype: 'stream_closed' }), (error) => finish('FAILED', 'run.failed', { code: safeErrorCode(error, 'CLAUDE_RUN_FAILED') }, error));
         }
         catch (error) {
-            finish('FAILED', 'run.failed', {
-                code: safeErrorCode(error, 'CLAUDE_RUN_START_FAILED')
-            });
+            finish('FAILED', 'run.failed', { code: safeErrorCode(error, 'CLAUDE_RUN_START_FAILED') }, error, 'CLAUDE_RUN_START_FAILED');
         }
     }
 }

package/dist/runner/codex/conversation-parser.d.ts

@@ -1,7 +1,7 @@
 import type { NodeAgentSession, NodeConversationItem, NodeConversationTurn, NodeMessageAttachmentInput } from '../../database.js';
 export type PublicConversationItem = {
     readonly itemId: string;
-    readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan' | 'context_compaction' | 'file_change' | 'unknown';
+    readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan' | 'context_compaction' | 'file_change' | 'error' | 'unknown';
     readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'DECLINED';
     readonly payload: Record<string, unknown>;
     readonly merge?: boolean;

package/dist/runner/codex/conversation-parser.js

@@ -83,6 +83,7 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
         const consumedOfficialIds = new Set();
         const officialUser = officialItems.find((item) => item.kind === 'user_message');
         const officialAssistants = officialItems.filter((item) => item.kind === 'assistant_message');
+        const officialContextCompactions = officialItems.filter((item) => item.kind === 'context_compaction');
         const officialItemMarker = `:official:${value.id}:`;
         const officialByNativeId = new Map(officialItems.flatMap((item) => {
             const markerIndex = item.id.lastIndexOf(officialItemMarker);
@@ -95,6 +96,8 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
             let replacement;
             if (managedItem.kind === 'user_message')
                 replacement = officialUser;
+            else if (managedItem.kind === 'context_compaction')
+                replacement = officialContextCompactions.find((item) => !consumedOfficialIds.has(item.id));
             else {
                 const nativeId = conversationItemNativeId(managedItem.id);
                 if (nativeId !== undefined)

package/dist/runner/codex/managed-run-controller.d.ts

@@ -6,6 +6,15 @@ import { CodexRunner } from '../codex-runner.js';
 type CodexImageInput = Extract<CodexComposerInput, {
     readonly type: 'localImage';
 }>;
+interface CodexNotificationRun {
+    readonly threadId: string;
+    readonly turnId?: string;
+}
+export declare function resolveCodexNotificationRun<T extends CodexNotificationRun>(runs: ReadonlyMap<string, T>, input: {
+    readonly threadId?: string;
+    readonly turnId?: string;
+    readonly allowUnboundFallback?: boolean;
+}): readonly [string, T] | undefined;
 export interface CodexManagedRunHost<TAttachment> {
     readonly available: () => boolean;
     readonly intercepted: () => boolean;
@@ -44,14 +53,13 @@ export interface CodexManagedRunHost<TAttachment> {
     }): void;
     emitItem(runId: string, item: {
         readonly itemId: string;
-        readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan' | 'context_compaction' | 'file_change' | 'unknown';
+        readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan' | 'context_compaction' | 'file_change' | 'error' | 'unknown';
         readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'DECLINED';
         readonly payload: Record<string, unknown>;
         readonly merge?: boolean;
         readonly append?: 'sections' | 'outputPreview' | 'outputSummary';
     }): void;
     appendImages(runId: string, images: readonly NodeMessageAttachmentInput[]): readonly Record<string, unknown>[];
-    captureSnapshot(runId: string, cwd: string): Promise<void>;
     syncTitle(sessionId: string, nativeSessionId: string, cwd: string): Promise<void>;
     commandState(sessionId: string, commandId: string): RunnerCommandState | undefined;
     setCommandState(sessionId: string, state: RunnerCommandState): void;
@@ -76,5 +84,6 @@ export declare class CodexManagedRunController<TAttachment> {
     private requestUserInput;
     start(envelope: NodeEnvelope): void;
     private run;
+    private emitError;
 }
 export {};

package/dist/runner/codex/managed-run-controller.js

@@ -1,7 +1,27 @@
 import { extractId } from '../../util/runner-native-session-parsers.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
+import { runnerErrorProjection } from '../../util/runner-error.js';
 import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
+export function resolveCodexNotificationRun(runs, input) {
+    const entries = [...runs.entries()];
+    if (input.turnId !== undefined) {
+        const exact = entries.find(([, value]) => value.turnId === input.turnId &&
+            (input.threadId === undefined || value.threadId === input.threadId));
+        if (exact !== undefined)
+            return exact;
+        if (input.allowUnboundFallback !== true)
+            return undefined;
+        // `turn/started` can arrive before the `turn/start` response binds its native Turn ID. Only
+        // an unbound Run on the same thread is a valid fallback; an older bound Run is never valid.
+        return entries
+            .reverse()
+            .find(([, value]) => value.threadId === input.threadId && value.turnId === undefined);
+    }
+    if (input.threadId === undefined)
+        return undefined;
+    return entries.reverse().find(([, value]) => value.threadId === input.threadId);
+}
 export class CodexManagedRunController {
     runner;
     host;
@@ -84,7 +104,8 @@ export class CodexManagedRunController {
             };
         }
         catch (error) {
-            this.host.emit(runId, 'run.failed', { code: safeErrorCode(error, 'CODEX_COMPACT_FAILED') }, 'FAILED');
+            this.emitError(runId, error, 'CODEX_COMPACT_FAILED');
+            this.host.emit(runId, 'run.failed', runnerErrorProjection(error, 'CODEX_COMPACT_FAILED'), 'FAILED');
             this.runner.execution.runs.delete(runId);
             this.runner.releaseEnvironment(runId);
             this.host.removeActive(runId);
@@ -102,8 +123,11 @@ export class CodexManagedRunController {
         const threadId = typeof params.threadId === 'string' ? params.threadId : undefined;
         if (turnId === undefined && threadId === undefined)
             return;
-        const run = [...this.runner.execution.runs.entries()].find(([, value]) => (turnId !== undefined && value.turnId === turnId) ||
-            (threadId !== undefined && value.threadId === threadId));
+        const run = resolveCodexNotificationRun(this.runner.execution.runs, {
+            ...(turnId === undefined ? {} : { turnId }),
+            ...(threadId === undefined ? {} : { threadId }),
+            ...(notification.method === 'turn/started' ? { allowUnboundFallback: true } : {})
+        });
         if (run === undefined)
             return;
         const [runId] = run;
@@ -184,16 +208,18 @@ export class CodexManagedRunController {
         if (notification.method === 'turn/completed') {
             const status = turn?.status;
             const terminal = status === 'completed' ? 'SUCCEEDED' : status === 'interrupted' ? 'INTERRUPTED' : 'FAILED';
-            this.host.emit(runId, 'run.completed', { status: status ?? 'unknown' }, terminal);
+            if (terminal === 'FAILED')
+                this.emitError(runId, turn?.error ?? turn, 'CODEX_RUN_FAILED');
+            const failure = terminal === 'FAILED'
+                ? runnerErrorProjection(turn?.error ?? turn, 'CODEX_RUN_FAILED')
+                : { status: status ?? 'unknown' };
+            this.host.emit(runId, terminal === 'FAILED' ? 'run.failed' : 'run.completed', failure, terminal);
             const active = this.runner.execution.runs.get(runId);
             const titleRefresh = active === undefined ||
                 active.refreshTitle === false ||
                 this.host.session(active.sessionId)?.titleSource !== 'AUTO'
                 ? undefined
                 : this.host.syncTitle(active.sessionId, active.threadId, active.cwd);
-            if (active !== undefined) {
-                void this.host.captureSnapshot(runId, active.cwd);
-            }
             this.runner.execution.runs.delete(runId);
             if (titleRefresh === undefined)
                 this.runner.releaseEnvironment(runId);
@@ -284,7 +310,8 @@ export class CodexManagedRunController {
             secretEnvironment = parseSecretEnvironment(payload.secretEnvironment);
         }
         catch (error) {
-            this.host.emit(runId, 'run.rejected', { code: safeErrorCode(error, 'MESSAGE_ATTACHMENTS_INVALID') }, 'FAILED');
+            this.emitError(runId, error, 'CODEX_RUN_FAILED');
+            this.host.emit(runId, 'run.rejected', runnerErrorProjection(error, 'MESSAGE_ATTACHMENTS_INVALID'), 'FAILED');
             return;
         }
         this.host.adopt({
@@ -345,28 +372,46 @@ export class CodexManagedRunController {
                 ...(typeof payload.access === 'string' ? { access: payload.access } : {}),
                 ...(payload.mcpServers === undefined ? {} : { mcpServers: payload.mcpServers })
             };
-            const threadResult = typeof payload.externalSessionId === 'string'
-                ? await this.runner.resumeThread(payload.externalSessionId, cwd, configuration)
-                : await this.runner.startThread(cwd, configuration);
-            if (this.host.completeCancelled(runId, cwd)) {
-                this.runner.releaseEnvironment(runId);
-                return;
+            const collaborationMode = payload.collaborationMode === 'plan' || payload.collaborationMode === 'default'
+                ? payload.collaborationMode
+                : undefined;
+            const turnConfiguration = {
+                ...configuration,
+                ...(collaborationMode === undefined ? {} : { collaborationMode }),
+                ...(payload.serviceTier === 'fast' ? { serviceTier: 'fast' } : {})
+            };
+            const materializedAttachments = await this.host.materialize(runId, attachments);
+            let threadId;
+            let turnResult;
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                try {
+                    const threadResult = typeof payload.externalSessionId === 'string'
+                        ? await this.runner.resumeThread(payload.externalSessionId, cwd, configuration)
+                        : await this.runner.startThread(cwd, configuration);
+                    if (this.host.completeCancelled(runId, cwd)) {
+                        this.runner.releaseEnvironment(runId);
+                        return;
+                    }
+                    threadId = extractId(threadResult, 'thread');
+                    this.runner.execution.runs.set(runId, { sessionId, threadId, cwd });
+                    turnResult = await this.runner.startTurn(threadId, input, cwd, turnConfiguration, materializedAttachments);
+                    break;
+                }
+                catch (error) {
+                    this.runner.execution.runs.delete(runId);
+                    if (attempt === 0 && (await this.runner.recoverMissingRollout(runId, error)))
+                        continue;
+                    throw error;
+                }
             }
-            const threadId = extractId(threadResult, 'thread');
+            if (threadId === undefined || turnResult === undefined)
+                throw new Error('CODEX_RUN_FAILED');
             let publicSessionId = sessionId;
             if (typeof payload.externalSessionId !== 'string') {
                 this.host.promoteSession(sessionId, threadId);
                 publicSessionId = threadId;
                 this.host.send('session.external-id', { sessionId, externalSessionId: threadId });
             }
-            this.runner.execution.runs.set(runId, { sessionId: publicSessionId, threadId, cwd });
-            const turnResult = await this.runner.startTurn(threadId, input, cwd, {
-                ...configuration,
-                ...(payload.collaborationMode === 'plan' || payload.collaborationMode === 'default'
-                    ? { collaborationMode: payload.collaborationMode }
-                    : {}),
-                ...(payload.serviceTier === 'fast' ? { serviceTier: 'fast' } : {})
-            }, await this.host.materialize(runId, attachments));
             const turnId = extractId(turnResult, 'turn');
             this.runner.execution.runs.set(runId, { sessionId: publicSessionId, threadId, turnId, cwd });
             this.runner.execution.managedTurns.set(turnId, { sessionId: publicSessionId, runId });
@@ -382,10 +427,20 @@ export class CodexManagedRunController {
                 this.runner.releaseEnvironment(runId);
                 return;
             }
-            this.host.emit(runId, 'run.failed', { code: safeErrorCode(error, 'CODEX_RUN_FAILED') }, 'FAILED');
+            this.emitError(runId, error, 'CODEX_RUN_FAILED');
+            this.host.emit(runId, 'run.failed', runnerErrorProjection(error, 'CODEX_RUN_FAILED'), 'FAILED');
             this.runner.execution.runs.delete(runId);
             this.runner.releaseEnvironment(runId);
             this.host.removeActive(runId);
         }
     }
+    emitError(runId, error, fallbackCode) {
+        const projected = runnerErrorProjection(error, fallbackCode);
+        this.host.emitItem(runId, {
+            itemId: boundedConversationItemId('runner-error', runId),
+            kind: 'error',
+            status: 'FAILED',
+            payload: { ...projected, recoverable: true, retryAfterMs: null }
+        });
+    }
 }

package/dist/runner/codex-runner.d.ts

@@ -13,6 +13,7 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
     private environmentFingerprint;
     private readonly environmentRuns;
     private readonly profileCache;
+    private readonly profileCacheTimers;
     private readonly profileRefreshes;
     private readonly profileClients;
     private readonly profileKeyByEnvironment;
@@ -23,6 +24,7 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
     refreshProfile(capabilities: NodeCapabilities, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<RunnerProfile>;
     private refreshCodexProfile;
     private selectCachedProfile;
+    private cacheProfile;
     private fetchCodexProfile;
     available(capabilities: NodeCapabilities): boolean;
     executeGlobalCommand(commandId: string, input: string): unknown;
@@ -56,6 +58,7 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
     presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
     onNotification(listener: (notification: JsonRpcNotification) => void): () => void;
     start(): Promise<void>;
+    recoverMissingRollout(runId: string, error: unknown): Promise<boolean>;
     prepareEnvironment(environment: Readonly<Record<string, string>>, runId: string): void;
     releaseEnvironment(runId: string): void;
     stop(): void;