@myagentroam/node 0.9.2 → 0.9.3

package/dist/connector.js

@@ -253,7 +253,7 @@ export class NodeConnector {
             interrupted: (runId) => this.runState.interruptRequested.has(runId),
             parseAttachments: parseRunnerImageAttachments,
             materialize: (runId, attachments) => this.runAttachmentService.materializeCodex(runId, attachments),
-            completeCancelled: (runId, cwd) => this.runnerInteractionService.completeCancelledRun(runId, cwd),
+            completeCancelled: (runId) => this.runnerInteractionService.completeCancelledRun(runId),
             promoteSession: (sessionId, nativeSessionId) => this.sessionIdentityService.promote(sessionId, nativeSessionId),
             send: (type, payload) => this.send(type, payload),
             emit: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
@@ -262,7 +262,6 @@ export class NodeConnector {
             publishApproval: (input) => this.runEventBridge.publishApproval(input),
             emitItem: (runId, item) => this.emitConversationItem(runId, item),
             appendImages: (runId, images) => this.runAttachmentService.append(runId, images.filter(isRunnerImageAttachment)),
-            captureSnapshot: (runId, cwd) => this.workspaceCoordinator.captureRunSnapshot(runId, cwd),
             syncTitle: (sessionId, nativeSessionId, cwd) => this.managedRunnerSessions.refreshTitle(sessionId, nativeSessionId, cwd),
             commandState: (sessionId, commandId) => this.commandStates.get(sessionId, commandId),
             setCommandState: (sessionId, state) => this.commandStates.set(sessionId, state),
@@ -285,10 +284,16 @@ export class NodeConnector {
             emit: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             emitItem: (runId, item) => this.emitConversationItem(runId, item),
             adopt: (input) => this.runtime.adoptRun(input),
+            run: (runId) => {
+                const run = this.runtime.getRun(runId);
+                if (run === undefined)
+                    throw new Error('RUN_NOT_FOUND');
+                return run;
+            },
+            hasActiveSessionLease: (sessionId) => this.runtime.hasActiveSessionLease(sessionId),
             promote: (sessionId, nativeSessionId) => this.sessionIdentityService.promote(sessionId, nativeSessionId),
             rememberNative: (nativeSessionId, sessionId) => this.managedRunnerSessions.remember(nativeSessionId, sessionId),
             send: (type, payload) => this.send(type, payload),
-            captureSnapshot: (runId, cwd) => this.workspaceCoordinator.captureRunSnapshot(runId, cwd),
             createApproval: (input) => this.runtime.createApproval(input),
             expireApproval: (approvalId) => {
                 this.runtime.expireApproval(approvalId);
@@ -308,8 +313,7 @@ export class NodeConnector {
             run: (runId) => this.runtime.getRun(runId),
             hasActiveSessionLease: (sessionId) => this.runtime.hasActiveSessionLease(sessionId),
             session: (sessionId) => this.runtime.getAgentSession(sessionId),
-            completeCancelled: (runId, cwd) => this.runnerInteractionService.completeCancelledRun(runId, cwd),
-            captureSnapshot: (runId, cwd) => this.workspaceCoordinator.captureRunSnapshot(runId, cwd),
+            completeCancelled: (runId) => this.runnerInteractionService.completeCancelledRun(runId),
             requestUserInput: (runId, input, toolUseId) => this.runnerInteractionService.requestClaudeUserInput(runId, input, toolUseId),
             requestApproval: (runId, toolName, input) => this.runnerInteractionService.requestClaudeApproval(runId, toolName, input),
             rememberNative: (nativeSessionId, sessionId) => this.managedRunnerSessions.remember(nativeSessionId, sessionId),
@@ -340,7 +344,6 @@ export class NodeConnector {
             runners: this.runners,
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             emitItem: (runId, item) => this.emitConversationItem(runId, item),
-            captureSnapshot: (runId, cwd) => this.workspaceCoordinator.captureRunSnapshot(runId, cwd),
             approvalTimeoutMs: this.claudeApprovalTimeoutMs,
             publishApproval: (input) => this.runEventBridge.publishApproval(input)
         });
@@ -391,6 +394,7 @@ export class NodeConnector {
             respondUserInput: (runId, requestId, answers) => this.runnerInteractionService.respondUserInput(runId, requestId, answers),
             deleteQueuedStart: (runId) => this.workspaceQueueWorkbenchService.remove(runId),
             clearImages: (runId) => this.runAttachmentService.clear(runId),
+            cleanupAttachments: (runId) => this.runAttachmentService.cleanup(runId),
             emitQueue: (workspaceId, sessionId) => this.runEventBridge.emitQueue(workspaceId, sessionId),
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             control: (operation, payload) => this.controlMessages.handle(JSON.stringify(createEnvelope(operation, payload))),
@@ -411,6 +415,7 @@ export class NodeConnector {
             runtime: this.runtime,
             emit: (workspaceId, sessionId) => this.runEventBridge.emitQueue(workspaceId, sessionId),
             clearImages: (runId) => this.runAttachmentService.clear(runId),
+            cleanupAttachments: (runId) => this.runAttachmentService.cleanup(runId),
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             emitConversation: (turn) => this.emitConversationTurn(turn),
             control: (operation, payload) => this.controlMessages.handle(JSON.stringify(createEnvelope(operation, payload))),
@@ -565,7 +570,6 @@ export class NodeConnector {
                 state: this.runState,
                 emitRun: (runId, type, payload, status) => this.runEventBridge.emitRun(runId, type, payload, status),
                 publishApproval: (input) => this.runEventBridge.publishApproval(input),
-                captureSnapshot: (runId, cwd) => this.workspaceCoordinator.captureRunSnapshot(runId, cwd),
                 disconnect: () => this.controlChannel.close(4010, 'FAKE_RUNNER_DISCONNECT')
             });
         this.fakeRunner?.bindControl({
@@ -620,14 +624,13 @@ export class NodeConnector {
             close: (code, reason) => this.controlChannel.close(code, reason),
             inspectWorkspace: (envelope) => this.workspaceCoordinator.inspect(envelope),
             handleNodeRequest: (envelope) => this.nodeRequests.handle(envelope),
-            acknowledgeWorkbenchEvent: (replyTo) => this.workbenchEventService.acknowledge(replyTo),
             reconcileRuns: (envelope) => this.runEventBridge.reconcile(envelope),
             runners: this.runners,
             deliverSessionChannelMessage: (envelope) => this.runnerChannelMessages.handle(envelope),
             completeUncontrolledCancellation: (runId) => {
                 const run = this.runtime.getRun(runId);
                 if (run?.status === 'CANCELLING')
-                    this.runnerInteractionService.completeCancelledRun(runId, undefined);
+                    this.runnerInteractionService.completeCancelledRun(runId);
             },
             send: (type, payload, replyTo) => this.send(type, payload, replyTo)
         });
@@ -640,7 +643,6 @@ export class NodeConnector {
         this.workspaceCoordinator = new NodeWorkspaceCoordinator({
             config: () => this.config,
             database: () => this.database,
-            runtime: this.runtime,
             watches: this.workspaceWatchService,
             sessions: this.workspaceSessionService,
             changes: this.workspaceChangeService,
@@ -672,7 +674,6 @@ export class NodeConnector {
             }),
             control: this.controlChannel,
             terminal: this.terminalChannel,
-            events: this.workbenchEventService,
             metrics: this.metrics,
             heartbeatMs: HEARTBEAT_MS,
             refreshMs: CAPABILITY_REFRESH_MS
@@ -701,7 +702,6 @@ export class NodeConnector {
         });
         this.workspaceWorkbenchService = new WorkspaceWorkbenchService({
             requireWorkspace: (workspaceId) => this.workspaceCoordinator.require(workspaceId),
-            runtime: this.runtime,
             watch: this.workspaceWatchService,
             files: this.workspaceFileService,
             uploads: this.workspaceUploadService,
@@ -715,7 +715,6 @@ export class NodeConnector {
         this.operationRouter.registerAll(this.workspaceWorkbenchService.operations());
         this.operationRouter.registerAll(this.runWorkbenchService.operations());
         this.operationRouter.registerAll(this.nativeSessionWatchService.operations());
-        this.operationRouter.registerAll(this.workbenchEventService.operations());
         this.operationRouter.registerAll(this.sessionQueryService.operations());
         this.operationRouter.registerAll(this.sessionLifecycleService.operations());
         this.operationRouter.registerAll(this.sessionMessageService.operations());

package/dist/control-outbound-scheduler.d.ts

@@ -7,20 +7,23 @@ interface WritableControlSocket {
 /** Keeps control responses responsive while reliable Workbench events are busy. */
 export declare class ControlOutboundScheduler {
     private readonly socket;
+    private readonly onExpired;
     private readonly high;
     private readonly normal;
     private scheduled;
     private retryTimer;
+    private expiryTimer;
     private backpressureStartedAt;
     private backpressureLogged;
     private maximumHighDepth;
     private maximumNormalDepth;
-    constructor(socket: () => WritableControlSocket | undefined);
+    constructor(socket: () => WritableControlSocket | undefined, onExpired?: () => void);
     enqueue(envelope: NodeEnvelope, priority: 'high' | 'normal'): void;
     reset(): void;
     private schedule;
     private flush;
     private waitForBackpressure;
     private finishBackpressure;
+    private scheduleExpiry;
 }
 export {};

package/dist/control-outbound-scheduler.js

@@ -4,19 +4,23 @@ const MAX_BYTES_PER_TURN = 256 * 1024;
 const SOCKET_NORMAL_DIRECT_WATER_BYTES = 256 * 1024;
 const SOCKET_HIGH_WATER_BYTES = 1024 * 1024;
 const BACKPRESSURE_RETRY_MS = 5;
+const OUTBOUND_QUEUE_TTL_MS = 30_000;
 /** Keeps control responses responsive while reliable Workbench events are busy. */
 export class ControlOutboundScheduler {
     socket;
+    onExpired;
     high = [];
     normal = [];
     scheduled = false;
     retryTimer;
+    expiryTimer;
     backpressureStartedAt;
     backpressureLogged = false;
     maximumHighDepth = 0;
     maximumNormalDepth = 0;
-    constructor(socket) {
+    constructor(socket, onExpired = () => undefined) {
         this.socket = socket;
+        this.onExpired = onExpired;
     }
     enqueue(envelope, priority) {
         const socket = this.socket();
@@ -29,9 +33,13 @@ export class ControlOutboundScheduler {
             socket.send(JSON.stringify(envelope));
             return;
         }
-        (priority === 'high' ? this.high : this.normal).push(envelope);
+        (priority === 'high' ? this.high : this.normal).push({
+            envelope,
+            expiresAt: Date.now() + OUTBOUND_QUEUE_TTL_MS
+        });
         this.maximumHighDepth = Math.max(this.maximumHighDepth, this.high.length);
         this.maximumNormalDepth = Math.max(this.maximumNormalDepth, this.normal.length);
+        this.scheduleExpiry();
         this.schedule();
     }
     reset() {
@@ -41,6 +49,9 @@ export class ControlOutboundScheduler {
         if (this.retryTimer !== undefined)
             clearTimeout(this.retryTimer);
         this.retryTimer = undefined;
+        if (this.expiryTimer !== undefined)
+            clearTimeout(this.expiryTimer);
+        this.expiryTimer = undefined;
         this.finishBackpressure('reset');
     }
     schedule() {
@@ -62,8 +73,8 @@ export class ControlOutboundScheduler {
         let bytes = 0;
         while (frames < MAX_FRAMES_PER_TURN) {
             const queue = this.high.length > 0 ? this.high : this.normal;
-            const envelope = queue[0];
-            if (envelope === undefined)
+            const queued = queue[0];
+            if (queued === undefined)
                 break;
             // Reliable Workbench events may be replayed in a large burst after a
             // reconnect. Stop normal traffic early so a later HTTP/control response
@@ -73,7 +84,7 @@ export class ControlOutboundScheduler {
                 this.waitForBackpressure(socket, 'normal');
                 return;
             }
-            const serialized = JSON.stringify(envelope);
+            const serialized = JSON.stringify(queued.envelope);
             const size = Buffer.byteLength(serialized);
             if (frames > 0 && bytes + size > MAX_BYTES_PER_TURN)
                 break;
@@ -86,8 +97,12 @@ export class ControlOutboundScheduler {
         }
         if (this.high.length > 0 || this.normal.length > 0)
             this.schedule();
-        else
+        else {
+            if (this.expiryTimer !== undefined)
+                clearTimeout(this.expiryTimer);
+            this.expiryTimer = undefined;
             this.finishBackpressure('drained');
+        }
     }
     waitForBackpressure(socket, level) {
         this.backpressureStartedAt ??= Date.now();
@@ -118,4 +133,22 @@ export class ControlOutboundScheduler {
         this.maximumHighDepth = 0;
         this.maximumNormalDepth = 0;
     }
+    scheduleExpiry() {
+        if (this.expiryTimer !== undefined)
+            return;
+        const expiresAt = Math.min(this.high[0]?.expiresAt ?? Number.POSITIVE_INFINITY, this.normal[0]?.expiresAt ?? Number.POSITIVE_INFINITY);
+        if (!Number.isFinite(expiresAt))
+            return;
+        this.expiryTimer = setTimeout(() => {
+            this.expiryTimer = undefined;
+            if ((this.high[0]?.expiresAt ?? Number.POSITIVE_INFINITY) > Date.now() &&
+                (this.normal[0]?.expiresAt ?? Number.POSITIVE_INFINITY) > Date.now()) {
+                this.scheduleExpiry();
+                return;
+            }
+            this.reset();
+            this.onExpired();
+        }, Math.max(0, expiresAt - Date.now()));
+        this.expiryTimer.unref();
+    }
 }

package/dist/database.d.ts

@@ -80,13 +80,6 @@ export interface NodeRunEvent {
     readonly status?: AgentRunStatus;
     readonly createdAt: number;
 }
-export interface WorkspaceActivityEvent {
-    readonly id: number;
-    readonly workspaceId: string;
-    readonly eventType: string;
-    readonly payload: unknown;
-    readonly createdAt: number;
-}
 export interface ConversationPage {
     readonly turns: readonly NodeConversationTurn[];
     readonly nextCursor: string | null;
@@ -132,10 +125,6 @@ export interface NodeMessageAttachmentInput {
     readonly mime: string;
     readonly dataBase64: string;
 }
-export interface WorkspaceActivityPage {
-    readonly events: readonly WorkspaceActivityEvent[];
-    readonly nextCursor: string | null;
-}
 export interface NodeApproval {
     readonly id: string;
     readonly runId: string;
@@ -288,11 +277,6 @@ export declare class NodeDatabase {
         readonly cursor?: string;
         readonly limit?: number;
     }): ConversationItemPage;
-    listWorkspaceActivity(input: {
-        readonly workspaceId: string;
-        readonly cursor?: string;
-        readonly limit?: number;
-    }): WorkspaceActivityPage;
     createApproval(input: {
         readonly runId: string;
         readonly approvalId: string;
@@ -307,13 +291,10 @@ export declare class NodeDatabase {
     decideApproval(id: string, decision: 'APPROVED' | 'REJECTED'): NodeApproval;
     listNonterminalRuns(): readonly NodeAgentRun[];
     lastRunSequence(runId: string): number;
-    saveSnapshot(runId: string, snapshot: unknown): void;
-    getSnapshot(runId: string): unknown | undefined;
     markActiveRunsSuspect(): void;
     hasActiveWorkspaceLease(workspaceId: string): boolean;
     reconcileRun(runId: string, active: boolean): void;
     private releaseLease;
-    private recordWorkspaceActivity;
     private recordConversationItemChange;
     private projectApproval;
     private readConversationTurn;

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');
         }
     }
 }