@myagentroam/node 0.9.0 → 0.9.3

package/dist/connector.d.ts

@@ -27,6 +27,7 @@ export declare class NodeConnector {
     private readonly sessionIdentityService;
     private readonly nativeSessionProjectionService;
     private readonly conversationHistoryService;
+    private readonly conversationSegmentService;
     private readonly runnerInteractionService;
     private readonly runnerChannelMessages;
     private readonly managedRunnerSessions;
@@ -78,6 +79,7 @@ export declare class NodeConnector {
     private readonly handleMessage;
     private readonly emitRunEvent;
     private readonly emitConversationItem;
+    private readonly emitConversationTurn;
     private readonly emitWorkbenchEvent;
     private readonly discoverWorkspaceSessions;
     private readonly invalidateWorkspaceWatchTopics;

package/dist/connector.js

@@ -44,6 +44,7 @@ import { WorkspaceQueueWorkbenchService } from './service/workspace-queue-workbe
 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 { 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';
 import { ExternalSessionResumeService } from './service/external-session-resume-service.js';
@@ -51,7 +52,7 @@ import { SessionMessageService } from './service/session-message-service.js';
 import { SessionCatalogService } from './service/session-catalog-service.js';
 import { SessionCommandService } from './service/session-command-service.js';
 import { SessionPresentationService } from './service/session-presentation-service.js';
-import { isRunnerImageAttachment, parseRunnerImageAttachments } from './runner/codex/conversation-parser.js';
+import { isPlainRecord, isRunnerImageAttachment, parseRunnerImageAttachments } from './runner/codex/conversation-parser.js';
 export { nodeConnectEndpoint, validatedCapabilities } from './runner/codex/conversation-parser.js';
 import { NodeControlChannel } from './service/node-control-channel.js';
 import { NodeControlMessageService } from './service/node-control-message-service.js';
@@ -114,6 +115,7 @@ export class NodeConnector {
     sessionIdentityService;
     nativeSessionProjectionService;
     conversationHistoryService;
+    conversationSegmentService;
     runnerInteractionService;
     runnerChannelMessages;
     managedRunnerSessions;
@@ -173,7 +175,12 @@ export class NodeConnector {
         isBootstrapSession: (sessionId) => this.sessionIdentityService.bootstrapIds.has(sessionId),
         presentSession: (session) => this.sessionPresentationService.present(session),
         rejectBootstrap: (sessionId, code) => this.sessionIdentityService.reject(sessionId, code),
-        emitWorkbench: (category, payload) => this.emitWorkbenchEvent(category, payload),
+        emitWorkbench: (category, payload) => {
+            if (category === 'conversation' && isPlainRecord(payload) && 'turn' in payload)
+                this.emitConversationTurn(payload.turn);
+            else
+                this.emitWorkbenchEvent(category, payload);
+        },
         cleanupAttachments: (runId) => this.runAttachmentService.cleanup(runId),
         expireImages: (runId) => this.runAttachmentService.expire(runId),
         scheduleContextRefresh: (sessionId) => this.sessionContextService.schedule(sessionId),
@@ -190,8 +197,9 @@ export class NodeConnector {
         refreshActivity: (session) => this.conversationHistoryService.refreshExternalActivity(session),
         present: (session) => this.sessionPresentationService.present(session),
         readPage: (session, limit) => this.conversationHistoryService.read(session, { limit }),
+        projectInitialPage: (session, page, _unit, limit) => this.conversationSegmentService.projectInitial(session, page, limit),
         emitSession: (session) => this.emitWorkbenchEvent('session', { session }),
-        emitTurn: (turn) => this.emitWorkbenchEvent('conversation', { turn })
+        emitTurn: (turn) => this.emitConversationTurn(turn)
     });
     constructor(options = {}) {
         this.config = options.config;
@@ -230,7 +238,7 @@ export class NodeConnector {
         this.fakeRunner =
             options.fakeRunner === undefined ? undefined : new FakeTestRunner(options.fakeRunner);
         this.fakeScript = options.fakeScript;
-        this.runAttachmentService = new RunAttachmentService((session) => this.runners.require(session.runner).nativeImageRoot(session));
+        this.runAttachmentService = new RunAttachmentService((session) => this.runners.require(session.runner).nativeImageRoots(session));
         this.codexClient = new CodexRunner(options.codexClient, options.codexProfileClientFactory);
         this.codexRunController = new CodexManagedRunController(this.codexClient, {
             available: () => this.capabilities.codex.available,
@@ -245,16 +253,15 @@ 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),
             cancel: (runId, threadId, turnId, cwd, status) => this.runnerInteractionService.cancelCodexTurn(runId, threadId, turnId, cwd, status),
             createApproval: (input) => this.runtime.createApproval(input),
             publishApproval: (input) => this.runEventBridge.publishApproval(input),
-            emitItem: (runId, item) => this.runEventBridge.emitRun(runId, 'conversation.item', item),
+            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),
@@ -273,13 +280,20 @@ export class NodeConnector {
             intercepted: () => this.fakeRunner !== undefined,
             active: this.runState.active,
             parseAttachments: parseRunnerImageAttachments,
+            persistAttachments: (cwd, runId, attachments) => this.runAttachmentService.persistFiles(cwd, `${runId}-opencode-images`, attachments),
             emit: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
-            emitItem: (runId, item) => this.runEventBridge.emitRun(runId, 'conversation.item', item),
+            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);
@@ -299,14 +313,13 @@ 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),
             promote: (sessionId, nativeSessionId) => this.sessionIdentityService.promote(sessionId, nativeSessionId),
             send: (type, payload) => this.send(type, payload),
-            emitItem: (runId, item) => this.runEventBridge.emitRun(runId, 'conversation.item', item),
+            emitItem: (runId, item) => this.emitConversationItem(runId, item),
             syncTitle: (sessionId, nativeSessionId, cwd) => this.managedRunnerSessions.refreshTitle(sessionId, nativeSessionId, cwd),
             setChannelToken: (sessionId, token) => this.runtime.setChannelToken(sessionId, token),
             commandState: (sessionId, commandId) => this.commandStates.get(sessionId, commandId),
@@ -330,8 +343,7 @@ export class NodeConnector {
             claude: () => this.claudeClient,
             runners: this.runners,
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
-            emitItem: (runId, item) => this.runEventBridge.emitRun(runId, 'conversation.item', item),
-            captureSnapshot: (runId, cwd) => this.workspaceCoordinator.captureRunSnapshot(runId, cwd),
+            emitItem: (runId, item) => this.emitConversationItem(runId, item),
             approvalTimeoutMs: this.claudeApprovalTimeoutMs,
             publishApproval: (input) => this.runEventBridge.publishApproval(input)
         });
@@ -368,6 +380,7 @@ export class NodeConnector {
             hasManagedActiveRun: (session) => hasManagedActiveRun(this.runtime, session),
             setExternalActivity: (sessionId, activity) => this.sessionState.externalActivity.set(sessionId, activity)
         });
+        this.conversationSegmentService = new ConversationSegmentService((session, input) => this.conversationHistoryService.read(session, input));
         this.sessionContextService = new SessionContextService({
             runners: this.runners,
             session: (sessionId) => this.runtime.getAgentSession(sessionId),
@@ -381,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))),
@@ -392,6 +406,7 @@ export class NodeConnector {
             resolve: (sessionId) => this.nativeSessionProjectionService.resolve(sessionId),
             present: (session) => this.sessionPresentationService.present(session),
             history: (session, input) => this.conversationHistoryService.read(session, input),
+            segments: (session, input) => this.conversationSegmentService.read(session, input),
             context: this.sessionContextService,
             discover: (runner, workspaceId) => this.nativeSessionProjectionService.discover(runner, workspaceId),
             workspaceIdForCwd: (cwd) => this.database?.listWorkspaces().find((candidate) => candidate.path === cwd)?.id
@@ -400,8 +415,9 @@ 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.emitWorkbenchEvent('conversation', { turn }),
+            emitConversation: (turn) => this.emitConversationTurn(turn),
             control: (operation, payload) => this.controlMessages.handle(JSON.stringify(createEnvelope(operation, payload))),
             stopped: () => this.stopped,
             markInterrupted: (runId) => this.runState.interruptRequested.add(runId),
@@ -428,7 +444,7 @@ export class NodeConnector {
             emitSession: (session) => this.emitWorkbenchEvent('session', { session }),
             emitRun: (run) => this.emitWorkbenchEvent('run', { run }),
             emitQueue: (workspaceId, sessionId) => this.runEventBridge.emitQueue(workspaceId, sessionId),
-            emitTurn: (turn) => this.emitWorkbenchEvent('conversation', { turn })
+            emitTurn: (turn) => this.emitConversationTurn(turn)
         });
         this.sessionLifecycleService = new SessionLifecycleService({
             database: () => {
@@ -554,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({
@@ -596,7 +611,7 @@ export class NodeConnector {
                 this.terminalChannel.disconnect();
                 if (code === 4000 && reason === 'NODE_CONNECTION_REPLACED')
                     nodeLog('node.connection.replaced', {
-                        message: '当前 Node 已被同一身份的新实例接管，请检查是否启动了重复实例。'
+                        message: 'This Node connection was replaced by a newer instance with the same identity. Check for duplicate processes.'
                     });
                 if (code === 4003 || code === 1001)
                     void this.terminalManager.shutdown();
@@ -609,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)
         });
@@ -629,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,
@@ -661,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
@@ -690,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,
@@ -704,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());
@@ -781,7 +791,22 @@ export class NodeConnector {
     /** @internal Thin compatibility delegates; all behavior remains in the extracted services. */
     handleMessage = (raw) => this.controlMessages.handle(raw);
     emitRunEvent = (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status);
-    emitConversationItem = (runId, item) => this.runEventBridge.emitRun(runId, 'conversation.item', item);
+    emitConversationItem = (runId, item) => {
+        this.runEventService.flushPendingText(runId);
+        const itemId = isPlainRecord(item) && typeof item.itemId === 'string' ? item.itemId : undefined;
+        const itemKind = isPlainRecord(item) && typeof item.kind === 'string' ? item.kind : undefined;
+        const turn = this.runtime.conversationTurnForRun(runId);
+        const segment = itemId === undefined || turn === undefined
+            ? undefined
+            : conversationSegmentIdentityForItem(turn, itemId, itemKind);
+        this.runEventBridge.emitRun(runId, 'conversation.item', segment === undefined || !isPlainRecord(item)
+            ? item
+            : { ...item, segmentId: segment.id, segmentIndex: segment.index });
+    };
+    emitConversationTurn = (turn) => {
+        const segments = isPlainRecord(turn) && Array.isArray(turn.items) ? conversationSegments(turn) : [];
+        this.emitWorkbenchEvent('conversation', { turn, segments });
+    };
     emitWorkbenchEvent = (category, payload) => this.runEventBridge.emitWorkbench(category, payload);
     discoverWorkspaceSessions = (workspaceId) => this.nativeSessionProjectionService.discoverWorkspace(workspaceId);
     invalidateWorkspaceWatchTopics = (workspaceId) => this.workspaceCoordinator.invalidate(workspaceId);

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;