@myagentroam/node 0.9.2 → 0.9.3

package/dist/runtime-state.js

@@ -9,22 +9,22 @@ export class NodeRuntimeState {
     nodeId;
     getWorkspace;
     now;
+    static MAX_COMPLETED_TURNS_PER_SESSION = 10;
     sessions = new Map();
     runs = new Map();
     messageRuns = new Map();
     events = new Map();
     turns = new Map();
     approvals = new Map();
-    workspaceEvents = new Map();
     /** A Session owns at most one running turn; Workspace sessions may run concurrently. */
     leases = new Map();
     /** Session FIFO metadata is deliberately process-local with the rest of run state. */
     queuedRuns = new Map();
     queueVersions = new Map();
     pausedQueues = new Set();
-    snapshots = new Map();
+    /** Bounded tombstones reject stale internal start envelopes after terminal cleanup. */
+    terminalRunIds = new Set();
     nextEventId = 1;
-    nextWorkspaceEventId = 1;
     constructor(nodeId, getWorkspace, now = Date.now) {
         this.nodeId = nodeId;
         this.getWorkspace = getWorkspace;
@@ -73,6 +73,8 @@ export class NodeRuntimeState {
     }
     /** Internal envelope compatibility for a Run already accepted in this process. */
     adoptRun(input) {
+        if (this.terminalRunIds.has(input.runId))
+            throw new Error('RUN_TERMINAL');
         let session = this.sessions.get(input.sessionId);
         if (session === undefined) {
             const now = this.now();
@@ -316,11 +318,6 @@ export class NodeRuntimeState {
         this.queuedRuns.set(session.id, [...(this.queuedRuns.get(session.id) ?? []), run.id]);
         this.bumpQueueVersion(session.id);
         this.turns.set(session.id, [...(this.turns.get(session.id) ?? []), fixedTurn]);
-        this.recordWorkspaceActivity(run.workspaceId, 'run.created', {
-            runId: run.id,
-            sessionId: session.id,
-            runner: run.runner
-        });
         this.replaceSession(session.id, { lastActivityAt: now });
         return { run, created: true };
     }
@@ -402,7 +399,6 @@ export class NodeRuntimeState {
         this.bumpQueueVersion(run.sessionId);
         this.runs.delete(runId);
         this.events.delete(runId);
-        this.snapshots.delete(runId);
         this.turns.set(run.sessionId, (this.turns.get(run.sessionId) ?? []).filter((turn) => turn.runId !== runId));
         for (const [key, candidate] of this.messageRuns)
             if (candidate === runId)
@@ -468,12 +464,6 @@ export class NodeRuntimeState {
         if (input.status !== undefined)
             this.transitionRun(input.runId, input.status);
         this.projectEvent(value);
-        const run = this.requireRun(input.runId);
-        this.recordWorkspaceActivity(run.workspaceId, 'run.updated', {
-            runId: run.id,
-            eventType: input.eventType,
-            status: input.status ?? null
-        });
         return value;
     }
     listRunEvents(id, after = 0) {
@@ -559,16 +549,6 @@ export class NodeRuntimeState {
         this.replaceSession(session.id, { lastActivityAt: now });
         return completedTurn;
     }
-    listWorkspaceActivity(input) {
-        const all = this.workspaceEvents.get(input.workspaceId) ?? [];
-        const start = decodeCursor(input.cursor, input.workspaceId);
-        const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
-        const events = all.slice(start, start + limit);
-        return {
-            events,
-            nextCursor: start + limit < all.length ? encodeCursor(input.workspaceId, start + limit) : null
-        };
-    }
     createApproval(input) {
         this.requireRun(input.runId);
         if (this.approvals.has(input.approvalId))
@@ -631,11 +611,30 @@ export class NodeRuntimeState {
     lastRunSequence(id) {
         return this.events.get(id)?.at(-1)?.sequence ?? 0;
     }
-    saveSnapshot(id, value) {
-        this.snapshots.set(id, value);
-    }
-    getSnapshot(id) {
-        return this.snapshots.get(id);
+    removeTerminalRun(runId) {
+        const run = this.requireRun(runId);
+        if (!terminal(run.status))
+            throw new Error('RUN_ACTIVE');
+        this.terminalRunIds.add(runId);
+        if (this.terminalRunIds.size > 1_024)
+            this.terminalRunIds.delete(this.terminalRunIds.values().next().value);
+        const queue = this.queuedRuns.get(run.sessionId) ?? [];
+        if (queue.includes(runId)) {
+            this.queuedRuns.set(run.sessionId, queue.filter((candidate) => candidate !== runId));
+            this.bumpQueueVersion(run.sessionId);
+        }
+        this.runs.delete(runId);
+        this.events.delete(runId);
+        const turns = this.turns.get(run.sessionId) ?? [];
+        const completed = turns.filter((turn) => terminalTurn(turn.status));
+        const retainedCompleted = new Set(completed.slice(-NodeRuntimeState.MAX_COMPLETED_TURNS_PER_SESSION).map((turn) => turn.id));
+        this.turns.set(run.sessionId, turns.filter((turn) => !terminalTurn(turn.status) || retainedCompleted.has(turn.id)));
+        for (const [key, candidate] of this.messageRuns)
+            if (candidate === runId)
+                this.messageRuns.delete(key);
+        for (const [approvalId, approval] of this.approvals)
+            if (approval.runId === runId)
+                this.approvals.delete(approvalId);
     }
     hasActiveWorkspaceLease(workspaceId) {
         return [...this.leases.values()]
@@ -658,7 +657,6 @@ export class NodeRuntimeState {
         for (const runId of runIds) {
             this.runs.delete(runId);
             this.events.delete(runId);
-            this.snapshots.delete(runId);
         }
         for (const [key, runId] of this.messageRuns)
             if (runIds.has(runId))
@@ -681,7 +679,6 @@ export class NodeRuntimeState {
         for (const runId of runIds) {
             this.runs.delete(runId);
             this.events.delete(runId);
-            this.snapshots.delete(runId);
         }
         for (const [key, runId] of this.messageRuns)
             if (runIds.has(runId))
@@ -689,7 +686,6 @@ export class NodeRuntimeState {
         for (const [approvalId, approval] of this.approvals)
             if (runIds.has(approval.runId))
                 this.approvals.delete(approvalId);
-        this.workspaceEvents.delete(workspaceId);
         for (const sessionId of sessionIds) {
             this.queuedRuns.delete(sessionId);
             this.queueVersions.delete(sessionId);
@@ -730,19 +726,6 @@ export class NodeRuntimeState {
             throw new Error('APPROVAL_NOT_FOUND');
         return value;
     }
-    recordWorkspaceActivity(workspaceId, eventType, payload) {
-        const event = {
-            id: this.nextWorkspaceEventId++,
-            workspaceId,
-            eventType,
-            payload,
-            createdAt: this.now()
-        };
-        this.workspaceEvents.set(workspaceId, [
-            ...(this.workspaceEvents.get(workspaceId) ?? []),
-            event
-        ]);
-    }
     updateTurnForRun(runId, update) {
         const run = this.requireRun(runId);
         const current = this.turns.get(run.sessionId) ?? [];
@@ -840,6 +823,9 @@ export class NodeRuntimeState {
 function terminal(status) {
     return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED', 'LOST'].includes(status);
 }
+function terminalTurn(status) {
+    return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED'].includes(status);
+}
 function transitionAllowed(from, to) {
     return !terminal(from) || from === to;
 }

package/dist/service/attachment-domain-state.d.ts

@@ -1,5 +1,7 @@
 export declare class AttachmentDomainState<TCachedRunImages, TNativeImageSource> {
     readonly runDirectories: Map<string, string>;
+    readonly runFileDirectories: Map<string, string>;
     readonly runImages: Map<string, TCachedRunImages>;
     readonly nativeHistoryImages: Map<string, TNativeImageSource[]>;
+    readonly nativeHistoryImageTimers: Map<string, NodeJS.Timeout>;
 }

package/dist/service/attachment-domain-state.js

@@ -1,5 +1,7 @@
 export class AttachmentDomainState {
     runDirectories = new Map();
+    runFileDirectories = new Map();
     runImages = new Map();
     nativeHistoryImages = new Map();
+    nativeHistoryImageTimers = new Map();
 }

package/dist/service/conversation-segment-service.js

@@ -3,11 +3,11 @@ export function conversationSegments(turn) {
     const groups = [];
     let current = [];
     for (const item of turn.items) {
+        if (current.at(-1)?.kind === 'assistant_message' && item.kind !== 'assistant_message') {
+            groups.push(current);
+            current = [];
+        }
         current.push(item);
-        if (item.kind !== 'assistant_message')
-            continue;
-        groups.push(current);
-        current = [];
     }
     if (current.length > 0 || groups.length === 0)
         groups.push(current);
@@ -36,14 +36,15 @@ export function conversationSegments(turn) {
 export function conversationSegmentIdentityForItem(turn, itemId, itemKind) {
     let index = 0;
     const runtimeItemId = turn.runId === null ? itemId : `${turn.runId}:${itemId}`;
-    for (const item of turn.items) {
+    for (const [itemIndex, item] of turn.items.entries()) {
+        const previous = turn.items[itemIndex - 1];
+        if (previous?.kind === 'assistant_message' && item.kind !== 'assistant_message')
+            index += 1;
         if (item.id === itemId || item.id === runtimeItemId)
             return { id: `${turn.id}:segment:${index}`, index };
-        if (item.kind === 'assistant_message')
-            index += 1;
     }
-    if (itemKind === 'assistant_message' && turn.items.at(-1)?.kind === 'assistant_message')
-        index -= 1;
+    if (turn.items.at(-1)?.kind === 'assistant_message' && itemKind !== 'assistant_message')
+        index += 1;
     return { id: `${turn.id}:segment:${index}`, index };
 }
 export class ConversationSegmentService {

package/dist/service/external-session-resume-service.js

@@ -1,3 +1,4 @@
+const RESUME_FAILURE_TTL_MS = 30 * 60_000;
 export class ExternalSessionResumeService {
     options;
     constructor(options) {
@@ -84,15 +85,23 @@ export class ExternalSessionResumeService {
             : 'REJECTED';
     }
     clearFailure(sessionId) {
+        const timer = this.options.state.failureTimers.get(sessionId);
+        if (timer !== undefined)
+            clearTimeout(timer);
+        this.options.state.failureTimers.delete(sessionId);
         this.options.state.resumeFailures.delete(sessionId);
         this.options.state.resumeFailureDetails.delete(sessionId);
         this.options.state.messageResumeFailures.delete(sessionId);
     }
     setFailure(sessionId, code, detail) {
+        this.clearFailure(sessionId);
         this.options.state.resumeFailures.set(sessionId, code);
         if (detail === undefined)
             this.options.state.resumeFailureDetails.delete(sessionId);
         else
             this.options.state.resumeFailureDetails.set(sessionId, detail);
+        const timer = setTimeout(() => this.clearFailure(sessionId), RESUME_FAILURE_TTL_MS);
+        timer.unref();
+        this.options.state.failureTimers.set(sessionId, timer);
     }
 }

package/dist/service/fake-managed-run-service.d.ts

@@ -17,7 +17,6 @@ interface FakeManagedRunServiceOptions {
         readonly payload: unknown;
         readonly expiresAt: number;
     }) => void;
-    readonly captureSnapshot: (runId: string, cwd: string) => Promise<void>;
     readonly disconnect: () => void;
 }
 /** Test-only managed Run adapter; production Runner paths never depend on it. */

package/dist/service/fake-managed-run-service.js

@@ -32,8 +32,6 @@ export class FakeManagedRunService {
                 this.options.emitRun(runId, eventType, eventPayload, status);
                 if (status !== undefined && isTerminalRunStatus(status)) {
                     this.options.state.active.delete(runId);
-                    if (cwd !== undefined)
-                        void this.options.captureSnapshot(runId, cwd);
                 }
             },
             approval: (approvalId, approvalPayload, expiresAt) => {

package/dist/service/native-session-projection-service.js

@@ -238,7 +238,12 @@ export class NativeSessionProjectionService {
                 this.options.state.externalActivity.delete(directId);
                 this.options.state.resumedByDirectId.delete(directId);
                 this.options.state.resumeFailures.delete(directId);
+                this.options.state.messageResumeFailures.delete(directId);
                 this.options.state.resumeFailureDetails.delete(directId);
+                const timer = this.options.state.failureTimers.get(directId);
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                this.options.state.failureTimers.delete(directId);
             }
         }
         for (const [directId, resumedId] of this.options.state.resumedByDirectId)

package/dist/service/node-connection-lifecycle-service.d.ts

@@ -3,7 +3,6 @@ import { type NodeConfig } from '../config.js';
 import type { NodeMetrics } from '../operational.js';
 import type { NodeControlChannel } from './node-control-channel.js';
 import type { NodeTerminalChannel } from './node-terminal-channel.js';
-import type { WorkbenchEventService } from './workbench-event-service.js';
 interface NodeConnectionLifecycleServiceOptions {
     readonly config: () => NodeConfig | undefined;
     readonly setConfig: (config: NodeConfig) => void;
@@ -15,7 +14,6 @@ interface NodeConnectionLifecycleServiceOptions {
     readonly setCapabilities: (capabilities: NodeCapabilities) => void;
     readonly control: NodeControlChannel;
     readonly terminal: NodeTerminalChannel;
-    readonly events: WorkbenchEventService;
     readonly metrics: NodeMetrics;
     readonly heartbeatMs: number;
     readonly refreshMs: number;

package/dist/service/node-connection-lifecycle-service.js

@@ -48,7 +48,6 @@ export class NodeConnectionLifecycleService {
         this.options.terminal.connect();
         this.options.control.send('heartbeat', {});
         this.options.metrics.heartbeatSent();
-        this.options.events.replay();
         this.heartbeat = setInterval(() => {
             this.options.metrics.heartbeatSent();
             this.options.control.send('heartbeat', {});

package/dist/service/node-control-channel.js

@@ -5,7 +5,7 @@ import { nodeConnectEndpoint } from '../runner/codex/conversation-parser.js';
 export class NodeControlChannel {
     options;
     socket;
-    outbound = new ControlOutboundScheduler(() => this.socket);
+    outbound = new ControlOutboundScheduler(() => this.socket, () => this.socket?.close(1013, 'NODE_CONTROL_BACKPRESSURE_TIMEOUT'));
     reconnectTimer;
     attempts = 0;
     constructor(options) {

package/dist/service/node-control-message-service.d.ts

@@ -8,7 +8,6 @@ interface NodeControlMessageServiceOptions {
     readonly close: (code: number, reason: string) => void;
     readonly inspectWorkspace: (envelope: NodeEnvelope) => Promise<void>;
     readonly handleNodeRequest: (envelope: NodeEnvelope) => Promise<void>;
-    readonly acknowledgeWorkbenchEvent: (replyTo: string | undefined) => void;
     readonly reconcileRuns: (envelope: NodeEnvelope) => void;
     readonly runners: RunnerRegistry;
     readonly deliverSessionChannelMessage: (envelope: NodeEnvelope) => void;

package/dist/service/node-control-message-service.js

@@ -33,12 +33,8 @@ export class NodeControlMessageService {
             void this.options.handleNodeRequest(envelope);
             return;
         }
-        if (envelope.type === 'ack') {
-            const payload = envelope.payload;
-            if (payload.type === 'workbench.event')
-                this.options.acknowledgeWorkbenchEvent(envelope.replyTo);
+        if (envelope.type === 'ack')
             return;
-        }
         if (envelope.type === 'runs.reconcile') {
             this.options.reconcileRuns(envelope);
             return;
@@ -49,7 +45,14 @@ export class NodeControlMessageService {
         }
         if (envelope.type === 'run.start') {
             this.options.send('ack', { type: envelope.type }, envelope.id);
-            this.options.runners.startManagedRun(envelope);
+            try {
+                this.options.runners.startManagedRun(envelope);
+            }
+            catch (error) {
+                // A delayed internal start may arrive after the terminal projection was removed.
+                if (!(error instanceof Error) || error.message !== 'RUN_TERMINAL')
+                    throw error;
+            }
             return;
         }
         if (envelope.type === 'session.channel.message') {

package/dist/service/node-workspace-coordinator.d.ts

@@ -1,7 +1,6 @@
 import type { NodeEnvelope } from '@myagentroam/protocol';
 import type { NodeConfig } from '../config.js';
 import type { NodeAgentSession, NodeDatabase, NodeWorkspace } from '../database.js';
-import type { NodeRuntimeState } from '../runtime-state.js';
 import type { TerminalSummary } from '../terminal.js';
 import type { WorkspaceChangeService } from './workspace-change-service.js';
 import type { WorkspaceSessionService } from './workspace-session-service.js';
@@ -9,14 +8,13 @@ import type { WorkspaceWatchService } from './workspace-watch-service.js';
 interface NodeWorkspaceCoordinatorOptions {
     readonly config: () => NodeConfig | undefined;
     readonly database: () => NodeDatabase | undefined;
-    readonly runtime: NodeRuntimeState;
     readonly watches: WorkspaceWatchService;
     readonly sessions: WorkspaceSessionService;
     readonly changes: WorkspaceChangeService;
     readonly emit: (workspaceId: string, topic: 'files' | 'changes', revision: number) => void;
     readonly send: (type: string, payload: unknown, replyTo?: string) => void;
 }
-/** Coordinates Workspace invalidation, inspection, snapshots and persisted Terminal summaries. */
+/** Coordinates Workspace invalidation, inspection and persisted Terminal summaries. */
 export declare class NodeWorkspaceCoordinator {
     private readonly options;
     constructor(options: NodeWorkspaceCoordinatorOptions);
@@ -27,6 +25,5 @@ export declare class NodeWorkspaceCoordinator {
     invalidateChanges(workspaceId: string): void;
     persistTerminal(summary: TerminalSummary): void;
     inspect(envelope: NodeEnvelope): Promise<void>;
-    captureRunSnapshot(runId: string, cwd: string): Promise<void>;
 }
 export {};

package/dist/service/node-workspace-coordinator.js

@@ -1,5 +1,5 @@
-import { inspectWorkspace, readGitSummary } from '../workspace.js';
-/** Coordinates Workspace invalidation, inspection, snapshots and persisted Terminal summaries. */
+import { inspectWorkspace } from '../workspace.js';
+/** Coordinates Workspace invalidation, inspection and persisted Terminal summaries. */
 export class NodeWorkspaceCoordinator {
     options;
     constructor(options) {
@@ -67,14 +67,4 @@ export class NodeWorkspaceCoordinator {
             this.options.send('workspace.inspect.result', { error: 'WORKSPACE_INVALID' }, envelope.id);
         }
     }
-    async captureRunSnapshot(runId, cwd) {
-        try {
-            const snapshot = await readGitSummary(cwd);
-            this.options.runtime.saveSnapshot(runId, snapshot);
-            this.options.send('workspace.snapshot', { runId, snapshot });
-        }
-        catch {
-            // Ordinary directories have no Git snapshot and keep the existing Run result.
-        }
-    }
 }

package/dist/service/run-attachment-service.js

@@ -4,6 +4,7 @@ import { lstat, mkdir, mkdtemp, readFile, realpath, rm, writeFile } from 'node:f
 import { AttachmentDomainState } from './attachment-domain-state.js';
 const MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const IMAGE_CACHE_TTL_MS = 60 * 60_000;
+const NATIVE_IMAGE_INDEX_TTL_MS = 60 * 60_000;
 export class RunAttachmentService {
     nativeImageRoots;
     state = new AttachmentDomainState();
@@ -43,21 +44,28 @@ export class RunAttachmentService {
             throw new Error('MESSAGE_ATTACHMENT_DIRECTORY_INVALID');
         const runDirectory = join(filesDirectory, runId);
         await mkdir(runDirectory, { mode: 0o700 });
+        this.state.runFileDirectories.set(runId, runDirectory);
         try {
             await Promise.all(attachments.map((attachment) => writeFile(join(runDirectory, attachment.name), Buffer.from(attachment.dataBase64, 'base64'), { flag: 'wx', mode: 0o600 })));
             return attachments.map((attachment) => `.mar/temp-files/${runId}/${attachment.name}`);
         }
         catch (error) {
+            this.state.runFileDirectories.delete(runId);
             await rm(runDirectory, { recursive: true, force: true });
             throw error;
         }
     }
     cleanup(runId) {
         const directory = this.state.runDirectories.get(runId);
-        if (directory === undefined)
-            return;
-        this.state.runDirectories.delete(runId);
-        void rm(directory, { recursive: true, force: true }).catch(() => undefined);
+        if (directory !== undefined) {
+            this.state.runDirectories.delete(runId);
+            void rm(directory, { recursive: true, force: true }).catch(() => undefined);
+        }
+        const fileDirectory = this.state.runFileDirectories.get(runId);
+        if (fileDirectory !== undefined) {
+            this.state.runFileDirectories.delete(runId);
+            void rm(fileDirectory, { recursive: true, force: true }).catch(() => undefined);
+        }
     }
     cache(runId, images) {
         if (images.length === 0)
@@ -122,8 +130,18 @@ export class RunAttachmentService {
             }
             attachments.push({ name: image.name, mime: image.mime, runId, imageIndex });
         }
-        if (sources.length > 0)
+        if (sources.length > 0) {
             this.state.nativeHistoryImages.set(runId, sources);
+            const previousTimer = this.state.nativeHistoryImageTimers.get(runId);
+            if (previousTimer !== undefined)
+                clearTimeout(previousTimer);
+            const timer = setTimeout(() => {
+                this.state.nativeHistoryImageTimers.delete(runId);
+                this.state.nativeHistoryImages.delete(runId);
+            }, NATIVE_IMAGE_INDEX_TTL_MS);
+            timer.unref();
+            this.state.nativeHistoryImageTimers.set(runId, timer);
+        }
         return attachments;
     }
     async readNative(runId, imageIndex) {
@@ -161,10 +179,16 @@ export class RunAttachmentService {
         this.state.runImages.delete(runId);
     }
     dispose() {
-        for (const runId of this.state.runDirectories.keys())
+        for (const runId of new Set([
+            ...this.state.runDirectories.keys(),
+            ...this.state.runFileDirectories.keys()
+        ]))
             this.cleanup(runId);
         for (const runId of this.state.runImages.keys())
             this.clear(runId);
+        for (const timer of this.state.nativeHistoryImageTimers.values())
+            clearTimeout(timer);
+        this.state.nativeHistoryImageTimers.clear();
         this.state.nativeHistoryImages.clear();
     }
 }

package/dist/service/run-event-service.d.ts

@@ -29,4 +29,5 @@ export declare class RunEventService {
     private enqueueText;
     private flushText;
     private emitNow;
+    private notificationPayload;
 }

package/dist/service/run-event-service.js

@@ -50,6 +50,9 @@ export class RunEventService {
         this.emitNow(runId, 'text.delta', { text: pending.text });
     }
     emitNow(runId, eventType, payload, status) {
+        if (this.options.runtime.getRun(runId) === undefined)
+            return;
+        const notificationPayload = this.notificationPayload(runId, eventType, payload, status);
         const event = {
             runId,
             sequence: (this.sequences.get(runId) ?? 0) + 1,
@@ -76,6 +79,7 @@ export class RunEventService {
             /* A stale relayed run may race the storage boundary. */
         }
         if (status !== undefined && isTerminalRunStatus(status)) {
+            this.options.state.active.delete(runId);
             this.options.state.interruptRequested.delete(runId);
             const terminalRun = this.options.runtime.getRun(runId);
             if (terminalRun !== undefined && this.options.isBootstrapSession(terminalRun.sessionId))
@@ -91,6 +95,11 @@ export class RunEventService {
         this.options.emitWorkbench('conversation', {
             event: { ...event, createdAt: persisted?.createdAt ?? Date.now() }
         });
+        if (notificationPayload !== undefined)
+            this.emitNow(runId, 'notification', {
+                ...notificationPayload,
+                occurredAt: persisted?.createdAt ?? Date.now()
+            });
         if (status === undefined || !isTerminalRunStatus(status))
             return;
         const turn = this.options.runtime.conversationTurnForRun(runId);
@@ -102,7 +111,67 @@ export class RunEventService {
         const run = this.options.runtime.getRun(runId);
         if (run !== undefined) {
             this.options.scheduleContextRefresh(run.sessionId);
+            this.options.runtime.removeTerminalRun(runId);
+            this.sequences.delete(runId);
             void this.options.dispatchQueue(run.sessionId);
         }
     }
+    notificationPayload(runId, eventType, payload, status) {
+        if (eventType === 'notification')
+            return undefined;
+        const run = this.options.runtime.getRun(runId);
+        if (run === undefined)
+            return undefined;
+        const session = this.options.runtime.getAgentSession(run.sessionId);
+        if (session === undefined)
+            return undefined;
+        const base = {
+            workspaceId: run.workspaceId,
+            sessionId: run.sessionId,
+            sessionTitle: session.customTitle ?? session.runnerTitle ?? session.id,
+            runId
+        };
+        if (status !== undefined && isTerminalRunStatus(status)) {
+            if (this.options.state.interruptRequested.has(runId))
+                return undefined;
+            if (status === 'SUCCEEDED' &&
+                this.options.runtime.sessionQueue(run.sessionId).runIds.length > 0)
+                return undefined;
+            return {
+                ...base,
+                notificationId: `run:${run.workspaceId}:${runId}`,
+                kind: 'RUN_TERMINAL',
+                outcome: status
+            };
+        }
+        if (eventType === 'approval.request' && isPlainRecord(payload)) {
+            const approvalId = payload.approvalId;
+            if (typeof approvalId !== 'string')
+                return undefined;
+            return {
+                ...base,
+                notificationId: `approval:${run.workspaceId}:${runId}:${approvalId}`,
+                kind: 'APPROVAL_REQUIRED'
+            };
+        }
+        if (eventType !== 'conversation.item' || !isPlainRecord(payload))
+            return undefined;
+        if (payload.kind === 'plan' && typeof payload.itemId === 'string')
+            return {
+                ...base,
+                notificationId: `plan:${run.workspaceId}:${run.sessionId}`,
+                kind: 'PLAN_READY'
+            };
+        if (payload.kind === 'user_input_request' &&
+            typeof payload.itemId === 'string' &&
+            isPlainRecord(payload.payload) &&
+            Array.isArray(payload.payload.questions) &&
+            payload.payload.questions.length > 0)
+            return {
+                ...base,
+                notificationId: `user-input:${run.workspaceId}:${runId}:${payload.itemId}`,
+                kind: 'USER_INPUT_REQUIRED'
+            };
+        return undefined;
+    }
 }

package/dist/service/run-workbench-service.d.ts

@@ -6,6 +6,7 @@ export interface RunWorkbenchServiceOptions {
     readonly respondUserInput: (runId: string, requestId: string, answers: Record<string, unknown>) => void;
     readonly deleteQueuedStart: (runId: string) => void;
     readonly clearImages: (runId: string) => void;
+    readonly cleanupAttachments: (runId: string) => void;
     readonly emitQueue: (workspaceId: string, sessionId: string) => void;
     readonly emitRun: (runId: string, eventType: string, payload: unknown, status?: 'CANCELLED') => void;
     readonly control: (operation: string, payload: Record<string, unknown>) => void;
@@ -16,7 +17,6 @@ export declare class RunWorkbenchService {
     constructor(options: RunWorkbenchServiceOptions);
     operations(): Readonly<Record<string, NodeOperationHandler>>;
     private get;
-    private snapshot;
     private image;
     private respond;
     private interruptSession;

package/dist/service/run-workbench-service.js

@@ -8,7 +8,6 @@ export class RunWorkbenchService {
     operations() {
         return {
             'run.get': (data) => this.get(record(data)),
-            'run.snapshot': (data) => this.snapshot(record(data)),
             'run.image.read': (data) => this.image(record(data)),
             'run.user-input.respond': (data) => this.respond(record(data)),
             'session.interrupt': (data) => this.interruptSession(record(data)),
@@ -21,10 +20,6 @@ export class RunWorkbenchService {
     get(input) {
         return { run: this.requireRun(input.runId) };
     }
-    snapshot(input) {
-        const run = this.requireRun(input.runId);
-        return { snapshot: this.options.runtime.getSnapshot(run.id) ?? null };
-    }
     async image(input) {
         if (typeof input.runId !== 'string' ||
             typeof input.imageIndex !== 'number' ||
@@ -63,6 +58,7 @@ export class RunWorkbenchService {
             this.options.runtime.deleteQueuedRun(run.id);
             this.options.deleteQueuedStart(run.id);
             this.options.clearImages(run.id);
+            this.options.cleanupAttachments(run.id);
             this.options.emitQueue(run.workspaceId, run.sessionId);
             return { cancelled: true };
         }

package/dist/service/runner-interaction-service.d.ts

@@ -13,7 +13,6 @@ interface RunnerInteractionServiceOptions {
     readonly runners: RunnerRegistry;
     readonly emitRun: (runId: string, eventType: string, payload: unknown, status?: 'FAILED' | 'CANCELLED' | 'INTERRUPTED') => void;
     readonly emitItem: (runId: string, item: PublicConversationItem) => void;
-    readonly captureSnapshot: (runId: string, cwd: string) => Promise<void>;
     readonly approvalTimeoutMs: number;
     readonly publishApproval: (input: {
         readonly runId: string;
@@ -33,7 +32,7 @@ export declare class RunnerInteractionService {
     cancelClaudeRun(runId: string, intent: 'CANCEL' | 'INTERRUPT'): boolean;
     cancelCodexTurn(runId: string, threadId: string, turnId: string, cwd: string, terminalStatus: 'CANCELLED' | 'INTERRUPTED'): Promise<void>;
     respondUserInput(runId: string, requestId: string, rawAnswers: Record<string, unknown>): void;
-    completeCancelledRun(runId: string, cwd: string | undefined): boolean;
+    completeCancelledRun(runId: string): boolean;
     private respondCodexUserInput;
     private answers;
 }