@myagentroam/node 0.9.3 → 0.9.5

package/dist/claude-agent-sdk.d.ts

@@ -23,6 +23,7 @@ export interface ClaudeQueryInput {
     readonly onChannelReply?: (content: string) => void;
     readonly environment?: Readonly<Record<string, string>>;
     readonly mcpServers?: NonNullable<Options['mcpServers']>;
+    readonly personalInstructions?: string;
 }
 /** Image blocks accepted by the Claude Agent SDK message input. */
 export interface ClaudeImageAttachment {

package/dist/claude-agent-sdk.js

@@ -64,6 +64,15 @@ export class ClaudeAgentSdkAdapter {
                 // This is the SDK's documented API-side public summary mode. We never
                 // enable or forward raw thinking deltas to the Workbench.
                 settings: { showThinkingSummaries: true },
+                ...(input.personalInstructions === undefined
+                    ? {}
+                    : {
+                        systemPrompt: {
+                            type: 'preset',
+                            preset: 'claude_code',
+                            append: input.personalInstructions
+                        }
+                    }),
                 abortController,
                 canUseTool: input.onPermission,
                 ...(input.mcpServers !== undefined || channelEnabled

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

@@ -50,7 +50,20 @@ export interface CodexRunConfiguration {
     readonly serviceTier?: 'fast';
     readonly collaborationMode?: 'default' | 'plan';
     readonly mcpServers?: unknown;
+    readonly developerInstructions?: string;
 }
+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 +84,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 +130,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';
@@ -266,6 +358,9 @@ export class CodexAppServerClient {
 function codexThreadConfiguration(cwd, configuration) {
     return {
         ...modelOption(configuration.model),
+        ...(configuration.developerInstructions === undefined
+            ? {}
+            : { developerInstructions: configuration.developerInstructions }),
         ...(configuration.mcpServers === undefined
             ? {}
             : { config: { mcp_servers: configuration.mcpServers } }),
@@ -284,8 +379,7 @@ function codexTurnConfiguration(cwd, configuration) {
                     mode: configuration.collaborationMode,
                     settings: {
                         model: configuration.model ?? 'gpt-5.6-sol',
-                        reasoningEffort: configuration.effort ?? null,
-                        developerInstructions: null
+                        reasoningEffort: configuration.effort ?? null
                     }
                 }
             }),
@@ -371,6 +465,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.d.ts

@@ -3,6 +3,7 @@ export type { NodeConnectorOptions } from './connector/node-connector-options.js
 export { nodeConnectEndpoint, validatedCapabilities } from './runner/codex/conversation-parser.js';
 export declare function nextReconnectDelay(attempt: number): number;
 export declare class NodeConnector {
+    private readonly nodeGeneration;
     private readonly controlChannel;
     private readonly controlMessages;
     private readonly nodeRequests;

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';
@@ -86,6 +86,7 @@ function upgradeMetadata(metadata, status) {
     return next;
 }
 export class NodeConnector {
+    nodeGeneration = crypto.randomUUID().replace(/-/g, '');
     controlChannel;
     controlMessages;
     nodeRequests;
@@ -153,7 +154,7 @@ export class NodeConnector {
         discover: (workspaceId) => this.discoverWorkspaceSessions(workspaceId),
         listPage: (workspaceId) => this.executeNodeOperation('session.list', { workspaceId, limit: 20 }),
         active: (workspaceId) => this.workspaceWatchService.topicActive(workspaceId, 'sessions'),
-        emitRevision: (workspaceId, revision) => this.emitWorkbenchEvent('workspace', { workspaceId, topic: 'sessions', revision }),
+        emitRevision: (workspaceId) => void this.workspaceWorkbenchService?.refreshTopic(workspaceId, 'sessions'),
         onPending: (workspaceId, waitMs) => nodeLog('native.session.discovery.pending', {
             nodeId: this.config?.nodeId,
             workspaceId,
@@ -192,14 +193,22 @@ export class NodeConnector {
     });
     nativeSessionWatchService = new NativeSessionWatchService({
         resolve: async (sessionId) => this.runtime.getAgentSession(sessionId) ??
-            this.nativeSessionProjectionService.resolve(sessionId),
+            this.nativeSessionProjectionService.resolveCurrent(sessionId),
         managedActive: (session) => hasManagedActiveRun(this.runtime, session),
+        suspended: (sessionId) => this.externalSessionResumeService.transitioning(sessionId),
         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)
+        }),
+        nodeId: () => this.config?.nodeId ?? 'runtime-node',
+        nodeGeneration: () => this.nodeGeneration,
+        emitWatchEvent: (payload) => this.send('watch.event', payload)
     });
     constructor(options = {}) {
         this.config = options.config;
@@ -392,10 +401,8 @@ export class NodeConnector {
             readImage: async (runId, imageIndex) => this.runAttachmentService.read(runId, imageIndex) ??
                 (await this.runAttachmentService.readNative(runId, imageIndex)),
             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),
+            cancelQueued: (runId) => this.workspaceQueueWorkbenchService.cancelQueued(runId),
+            pauseQueue: (sessionId) => this.workspaceQueueWorkbenchService.pauseForInterrupt(sessionId),
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             control: (operation, payload) => this.controlMessages.handle(JSON.stringify(createEnvelope(operation, payload))),
             markInterrupted: (runId) => this.runState.interruptRequested.add(runId)
@@ -443,7 +450,7 @@ export class NodeConnector {
             migrateRunnerState: (previousId, nextId) => this.runEventBridge.migrateRunnerSessionIdentity(previousId, nextId),
             emitSession: (session) => this.emitWorkbenchEvent('session', { session }),
             emitRun: (run) => this.emitWorkbenchEvent('run', { run }),
-            emitQueue: (workspaceId, sessionId) => this.runEventBridge.emitQueue(workspaceId, sessionId),
+            emitQueue: (sessionId) => this.workspaceQueueWorkbenchService.publish(sessionId),
             emitTurn: (turn) => this.emitConversationTurn(turn)
         });
         this.sessionLifecycleService = new SessionLifecycleService({
@@ -497,7 +504,6 @@ export class NodeConnector {
             emitSession: (session) => this.emitWorkbenchEvent('session', {
                 session: this.sessionPresentationService.present(session)
             }),
-            emitQueue: (workspaceId, sessionId) => this.runEventBridge.emitQueue(workspaceId, sessionId),
             channelToken: (sessionId) => {
                 const session = this.runtime.getAgentSession(sessionId);
                 return session === undefined
@@ -646,7 +652,7 @@ export class NodeConnector {
             watches: this.workspaceWatchService,
             sessions: this.workspaceSessionService,
             changes: this.workspaceChangeService,
-            emit: (workspaceId, topic, revision) => this.emitWorkbenchEvent('workspace', { workspaceId, topic, revision }),
+            emit: (workspaceId, topic) => void this.workspaceWorkbenchService?.refreshTopic(workspaceId, topic),
             send: (type, payload, replyTo) => this.send(type, payload, replyTo)
         });
         this.runEventBridge = new NodeRunEventBridge({
@@ -707,7 +713,10 @@ export class NodeConnector {
             uploads: this.workspaceUploadService,
             changes: this.workspaceChangeService,
             listSessions: (workspaceId) => this.executeNodeOperation('session.list', { workspaceId, limit: 20 }),
-            invalidate: (workspaceId) => this.workspaceCoordinator.invalidate(workspaceId)
+            invalidate: (workspaceId) => this.workspaceCoordinator.invalidate(workspaceId),
+            nodeId: () => this.config?.nodeId ?? 'runtime-node',
+            nodeGeneration: () => this.nodeGeneration,
+            emitWatchEvent: (payload) => this.send('watch.event', payload)
         });
         this.operationRouter.registerAll(this.runnerService.operations());
         this.operationRouter.registerAll(this.terminalService.operations());

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

package/dist/native-session-history.d.ts

@@ -78,8 +78,9 @@ export interface NativeClaudeContextUsage {
 export declare function discoverNativeSessions(runner: RunnerName, workspacePath: string): Promise<readonly NativeSessionHistory[]>;
 /**
  * Reads every supported transcript header before applying a Workspace filter.
- * The caller owns in-process caching; a fixed file-count cutoff would silently
- * hide older sessions from a project with a large global history.
+ * A short Runner-level snapshot is shared across Workspaces and refreshes only
+ * files whose size or modification time changed. A fixed file-count cutoff
+ * would silently hide older sessions from a project with a large global history.
  */
 export declare function discoverAllNativeSessions(runner: RunnerName): Promise<readonly NativeSessionHistory[]>;
 /** Reads one already-discovered external session again to follow appended JSONL records. */