@myagentroam/node 0.9.4 → 0.9.6

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,6 +50,7 @@ export interface CodexRunConfiguration {
     readonly serviceTier?: 'fast';
     readonly collaborationMode?: 'default' | 'plan';
     readonly mcpServers?: unknown;
+    readonly developerInstructions?: string;
 }
 interface CodexRpcErrorPayload {
     readonly code?: unknown;

package/dist/codex-app-server.js

@@ -358,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 } }),
@@ -376,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
                     }
                 }
             }),

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

@@ -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,8 +193,9 @@ 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 }),
@@ -203,7 +205,10 @@ export class NodeConnector {
         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;
@@ -396,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)
@@ -447,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({
@@ -501,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
@@ -650,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({
@@ -711,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/native-jsonl-reader.d.ts

@@ -3,6 +3,27 @@ export interface JsonlWindow {
     readonly truncated: boolean;
     readonly size: number;
 }
+export interface JsonlBackwardWindow extends JsonlWindow {
+    readonly pageContent: string;
+    readonly start: number;
+    readonly end: number;
+    readonly snapshotEnd: number;
+    readonly fileAnchor: string;
+    readonly anchorBytes: number;
+}
+export declare function readJsonlFileAnchor(path: string, anchorBytes: number): Promise<string | undefined>;
+/** Reads one newline-aligned window backwards from an opaque byte boundary. */
+export declare function readJsonlBackwardWindow(path: string, options: {
+    readonly headBytes: number;
+    readonly targetLines: number;
+    readonly maxBytes: number;
+    readonly page?: {
+        readonly snapshotEnd: number;
+        readonly nextEnd: number;
+        readonly fileAnchor: string;
+        readonly anchorBytes: number;
+    };
+}): Promise<JsonlBackwardWindow | undefined>;
 /** Reads bounded head/tail windows without ever loading an unbounded transcript. */
 export declare function readJsonlWindow(path: string, options: {
     readonly headBytes?: number;

package/dist/native-jsonl-reader.js

@@ -1,5 +1,94 @@
+import { createHash } from 'node:crypto';
 import { open, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
+export async function readJsonlFileAnchor(path, anchorBytes) {
+    try {
+        const handle = await open(path, 'r');
+        try {
+            const metadata = await handle.stat();
+            if (anchorBytes < 0 || anchorBytes > metadata.size)
+                return undefined;
+            return createHash('sha256')
+                .update(await readAt(handle, anchorBytes, 0))
+                .digest('base64url');
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Reads one newline-aligned window backwards from an opaque byte boundary. */
+export async function readJsonlBackwardWindow(path, options) {
+    try {
+        const handle = await open(path, 'r');
+        try {
+            const metadata = await handle.stat();
+            const snapshotEnd = options.page?.snapshotEnd ?? metadata.size;
+            if (snapshotEnd > metadata.size)
+                return undefined;
+            const anchorBytes = options.page?.anchorBytes ?? Math.min(4096, snapshotEnd);
+            if (anchorBytes < 0 || anchorBytes > snapshotEnd)
+                return undefined;
+            const anchor = await readAt(handle, anchorBytes, 0);
+            const fileAnchor = createHash('sha256').update(anchor).digest('base64url');
+            if (options.page !== undefined && options.page.fileAnchor !== fileAnchor)
+                return undefined;
+            const headSize = Math.min(options.headBytes, snapshotEnd);
+            const end = Math.min(Math.max(options.page?.nextEnd ?? snapshotEnd, headSize), snapshotEnd);
+            const rawStart = Math.max(headSize, end - options.maxBytes);
+            const head = await readAt(handle, headSize, 0);
+            let tail = await readAt(handle, end - rawStart, rawStart);
+            let start = rawStart;
+            if (rawStart > headSize) {
+                const newline = tail.indexOf(0x0a);
+                if (newline < 0) {
+                    tail = Buffer.alloc(0);
+                    start = end;
+                }
+                else {
+                    start += newline + 1;
+                    tail = tail.subarray(newline + 1);
+                }
+            }
+            if (tail.length > 0) {
+                let lines = tail.at(-1) === 0x0a ? 0 : 1;
+                for (let index = tail.length - 1; index >= 0; index -= 1) {
+                    if (tail[index] !== 0x0a)
+                        continue;
+                    lines += 1;
+                    if (lines <= options.targetLines)
+                        continue;
+                    start += index + 1;
+                    tail = tail.subarray(index + 1);
+                    break;
+                }
+            }
+            const contiguous = start === headSize;
+            return {
+                content: contiguous
+                    ? Buffer.concat([head, tail]).toString('utf8')
+                    : `${head.toString('utf8')}${headSize > 0 && tail.length > 0 ? '\n' : ''}${tail.toString('utf8')}`,
+                truncated: start > headSize,
+                pageContent: tail.toString('utf8'),
+                size: metadata.size,
+                start,
+                end,
+                snapshotEnd,
+                fileAnchor,
+                anchorBytes
+            };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Reads bounded head/tail windows without ever loading an unbounded transcript. */
 export async function readJsonlWindow(path, options) {
     try {

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

@@ -59,6 +59,16 @@ export interface NativeSessionHistory {
     readonly lastActivityAt: number;
     /** The bounded reader omitted bytes between its header and tail windows. */
     readonly truncated?: boolean;
+    /** Opaque paging facts for reading the preceding newline-aligned JSONL window. */
+    readonly windowStart?: number;
+    readonly windowEnd?: number;
+    readonly snapshotEnd?: number;
+    readonly fileAnchor?: string;
+    readonly anchorBytes?: number;
+    /** The supplied page cursor no longer matched this transcript. */
+    readonly cursorReset?: boolean;
+    /** Page-size input used to derive the stable JSONL line window. */
+    readonly windowReadLimit?: number;
 }
 /** Actual context-window facts emitted by the Codex native transcript. */
 export interface NativeCodexContextUsage {
@@ -78,12 +88,19 @@ 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. */
-export declare function readNativeSession(runner: RunnerName, workspacePath: string, externalSessionId: string): Promise<NativeSessionHistory | undefined>;
+export declare function readNativeSession(runner: RunnerName, workspacePath: string, externalSessionId: string, page?: {
+    readonly snapshotEnd: number;
+    readonly nextEnd: number;
+    readonly fileAnchor: string;
+    readonly anchorBytes: number;
+    readonly readLimit?: number;
+}, limit?: number): Promise<NativeSessionHistory | undefined>;
 /**
  * Codex records the most recent prompt token count alongside the model context
  * window in `event_msg/token_count`.  Read only the tail of an already