@myagentroam/node 0.9.2 → 0.9.4

package/dist/codex-app-server.d.ts

@@ -51,6 +51,18 @@ export interface CodexRunConfiguration {
     readonly collaborationMode?: 'default' | 'plan';
     readonly mcpServers?: unknown;
 }
+interface CodexRpcErrorPayload {
+    readonly code?: unknown;
+    readonly message?: unknown;
+    readonly data?: unknown;
+}
+export declare class CodexAppServerRpcError extends Error {
+    readonly code: unknown;
+    readonly rpcMessage: string;
+    readonly data: unknown;
+    constructor(payload: CodexRpcErrorPayload);
+}
+export declare function isCodexRolloutMissingError(error: unknown): boolean;
 /** Public App Server turn inputs supported by the Workbench Composer. */
 export type CodexComposerInput = {
     readonly type: 'text';
@@ -71,15 +83,26 @@ export declare class CodexAppServerClient {
     private socketPath;
     private nextId;
     private readonly pending;
+    private readonly pendingDrainWaiters;
     private readonly notifications;
     private environment;
+    private starting;
+    private restarting;
+    private lifecycleRevision;
     constructor(options?: CodexAppServerOptions);
     configureEnvironment(environment: Readonly<Record<string, string>>): void;
     clearEnvironment(): void;
     start(): Promise<void>;
+    restart(): Promise<void>;
+    private startManaged;
+    private restartManaged;
     stop(): void;
+    private stopManaged;
     onNotification(listener: (notification: JsonRpcNotification) => void): () => void;
     request(method: string, params: unknown): Promise<unknown>;
+    private requestDirect;
+    private waitForPendingRequests;
+    private resolvePendingDrain;
     notify(method: string, params: unknown): void;
     respond(requestId: string | number, result: unknown): void;
     startThread(cwd: string, configuration?: CodexRunConfiguration): Promise<unknown>;
@@ -106,3 +129,4 @@ export declare class CodexAppServerClient {
 export declare function probeCodex(command?: string): CodexProbe;
 export declare function probeCodexAsync(command?: string): Promise<CodexProbe>;
 export declare function isSupportedCodexVersion(version: string): boolean;
+export {};

package/dist/codex-app-server.js

@@ -36,6 +36,25 @@ export function codexSessionControl(input) {
         capabilities: ['history.read', 'turn.start']
     };
 }
+export class CodexAppServerRpcError extends Error {
+    code;
+    rpcMessage;
+    data;
+    constructor(payload) {
+        const rpcMessage = typeof payload.message === 'string' ? payload.message : 'Codex App Server request failed';
+        super(`CODEX_APP_SERVER_RPC_ERROR:${JSON.stringify(payload)}`);
+        this.name = 'CodexAppServerRpcError';
+        this.code = payload.code;
+        this.rpcMessage = rpcMessage;
+        this.data = payload.data;
+    }
+}
+export function isCodexRolloutMissingError(error) {
+    return (error instanceof CodexAppServerRpcError &&
+        error.code === -32600 &&
+        (/^no rollout found for thread id\b/i.test(error.rpcMessage) ||
+            /^thread not loaded:\s*/i.test(error.rpcMessage)));
+}
 /**
  * Local JSON-RPC client for a Node-supervised Codex App Server. Linux uses a
  * private Unix socket by default; Windows uses stdio. Neither is exposed to
@@ -48,8 +67,12 @@ export class CodexAppServerClient {
     socketPath;
     nextId = 1;
     pending = new Map();
+    pendingDrainWaiters = new Set();
     notifications = new Set();
     environment = {};
+    starting;
+    restarting;
+    lifecycleRevision = 0;
     constructor(options = {}) {
         this.options = options;
     }
@@ -63,9 +86,35 @@ export class CodexAppServerClient {
             throw new Error('CODEX_APP_SERVER_ALREADY_STARTED');
         this.environment = {};
     }
-    async start() {
+    start() {
+        if (this.restarting !== undefined)
+            return this.restarting;
+        if (this.starting !== undefined)
+            return this.starting;
         if (this.child !== undefined)
-            return;
+            return Promise.resolve();
+        const starting = this.startManaged();
+        this.starting = starting;
+        const clearStarting = () => {
+            if (this.starting === starting)
+                this.starting = undefined;
+        };
+        void starting.then(clearStarting, clearStarting);
+        return starting;
+    }
+    restart() {
+        if (this.restarting !== undefined)
+            return this.restarting;
+        const restarting = this.restartManaged(this.lifecycleRevision);
+        this.restarting = restarting;
+        const clearRestarting = () => {
+            if (this.restarting === restarting)
+                this.restarting = undefined;
+        };
+        void restarting.then(clearRestarting, clearRestarting);
+        return restarting;
+    }
+    async startManaged() {
         const command = this.options.command ?? 'codex';
         const mode = this.transportMode();
         this.socketPath =
@@ -105,18 +154,39 @@ export class CodexAppServerClient {
         this.transport = socket ?? stdioTransport(child);
         const lines = createInterface({ input: socket ?? child.stdout });
         lines.on('line', (line) => this.handleLine(line));
-        child.once('error', (error) => this.failAll(new Error(`CODEX_APP_SERVER_START_FAILED:${error.message}`)));
+        const managedChild = child;
+        child.once('error', (error) => {
+            if (this.child !== managedChild)
+                return;
+            this.failAll(new Error(`CODEX_APP_SERVER_START_FAILED:${error.message}`));
+        });
         child.once('exit', () => {
+            if (this.child !== managedChild)
+                return;
             this.child = undefined;
             this.failAll(new Error('CODEX_APP_SERVER_EXITED'));
         });
-        await this.request('initialize', {
+        await this.requestDirect('initialize', {
             clientInfo: { name: 'codex_vscode', title: 'MyAgentRoam', version: '0.1.4' },
             capabilities: { experimentalApi: true }
         });
         this.notify('initialized', {});
     }
+    async restartManaged(lifecycleRevision) {
+        await Promise.resolve();
+        if (this.starting !== undefined)
+            await this.starting;
+        await this.waitForPendingRequests();
+        if (this.lifecycleRevision !== lifecycleRevision)
+            throw new Error('CODEX_APP_SERVER_STOPPED');
+        this.stopManaged();
+        await this.startManaged();
+    }
     stop() {
+        this.lifecycleRevision += 1;
+        this.stopManaged();
+    }
+    stopManaged() {
         this.transport?.destroy();
         this.transport = undefined;
         this.child?.kill();
@@ -131,6 +201,13 @@ export class CodexAppServerClient {
         return () => this.notifications.delete(listener);
     }
     async request(method, params) {
+        if (this.restarting !== undefined)
+            await this.restarting;
+        else if (this.starting !== undefined)
+            await this.starting;
+        return this.requestDirect(method, params);
+    }
+    requestDirect(method, params) {
         const transport = this.transport;
         if (transport === undefined || !transport.writable)
             throw new Error('CODEX_APP_SERVER_UNAVAILABLE');
@@ -139,6 +216,7 @@ export class CodexAppServerClient {
         const result = new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.pending.delete(id);
+                this.resolvePendingDrain();
                 reject(new Error('CODEX_APP_SERVER_TIMEOUT'));
             }, timeoutMs);
             this.pending.set(id, { resolve, reject, timer });
@@ -146,6 +224,18 @@ export class CodexAppServerClient {
         transport.write(`${JSON.stringify({ method, id, params })}\n`);
         return result;
     }
+    waitForPendingRequests() {
+        if (this.pending.size === 0)
+            return Promise.resolve();
+        return new Promise((resolve) => this.pendingDrainWaiters.add(resolve));
+    }
+    resolvePendingDrain() {
+        if (this.pending.size !== 0)
+            return;
+        for (const resolve of this.pendingDrainWaiters)
+            resolve();
+        this.pendingDrainWaiters.clear();
+    }
     notify(method, params) {
         const transport = this.transport;
         if (transport === undefined || !transport.writable)
@@ -233,8 +323,9 @@ export class CodexAppServerClient {
                 return;
             clearTimeout(pending.timer);
             this.pending.delete(message.id);
+            this.resolvePendingDrain();
             if (message.error !== undefined) {
-                pending.reject(new Error(`CODEX_APP_SERVER_RPC_ERROR:${JSON.stringify(message.error)}`));
+                pending.reject(new CodexAppServerRpcError(isRecord(message.error) ? message.error : { message: String(message.error) }));
             }
             else {
                 pending.resolve(message.result);
@@ -252,6 +343,7 @@ export class CodexAppServerClient {
             pending.reject(error);
             this.pending.delete(id);
         }
+        this.resolvePendingDrain();
     }
     transportMode() {
         const requested = this.options.transport ?? 'auto';
@@ -371,6 +463,9 @@ function defaultSpawn(command, args, options) {
         ...(options.env === undefined ? {} : { env: options.env })
     });
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 function stdioTransport(child) {
     return {
         get writable() {

package/dist/connector.js

@@ -43,7 +43,7 @@ import { SessionQueryService } from './service/session-query-service.js';
 import { WorkspaceQueueWorkbenchService } from './service/workspace-queue-workbench-service.js';
 import { SessionIdentityService } from './service/session-identity-service.js';
 import { NativeSessionProjectionService } from './service/native-session-projection-service.js';
-import { ConversationHistoryService, hasManagedActiveRun } from './service/conversation-history-service.js';
+import { ConversationHistoryService, convergeConversationWatchPage, hasManagedActiveRun } from './service/conversation-history-service.js';
 import { ConversationSegmentService, conversationSegmentIdentityForItem, conversationSegments } from './service/conversation-segment-service.js';
 import { RunnerInteractionService } from './service/runner-interaction-service.js';
 import { SessionLifecycleService } from './service/session-lifecycle-service.js';
@@ -197,9 +197,13 @@ export class NodeConnector {
         refreshActivity: (session) => this.conversationHistoryService.refreshExternalActivity(session),
         present: (session) => this.sessionPresentationService.present(session),
         readPage: (session, limit) => this.conversationHistoryService.read(session, { limit }),
+        convergePage: convergeConversationWatchPage,
         projectInitialPage: (session, page, _unit, limit) => this.conversationSegmentService.projectInitial(session, page, limit),
         emitSession: (session) => this.emitWorkbenchEvent('session', { session }),
-        emitTurn: (turn) => this.emitConversationTurn(turn)
+        emitPage: (session, page) => this.emitWorkbenchEvent('conversation', {
+            sessionId: session.id,
+            snapshot: this.conversationSegmentService.projectInitial(session, page, 10)
+        })
     });
     constructor(options = {}) {
         this.config = options.config;
@@ -253,7 +257,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 +266,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 +288,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 +317,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 +348,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 +398,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 +419,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 +574,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 +628,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 +647,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 +678,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 +706,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 +719,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

@@ -67,6 +67,8 @@ export interface NodeAgentRun {
     readonly recoveryState: RunRecoveryState;
     readonly version: number;
     readonly clientMessageId: string;
+    /** Server-authenticated user that submitted this Run. Internal lifecycle metadata only. */
+    readonly initiatedByUserId?: number;
     readonly createdAt: number;
     readonly updatedAt: number;
 }
@@ -80,13 +82,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 +127,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 +279,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 +293,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;