@myagentroam/node 0.9.4 → 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,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-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. */

package/dist/native-session-history.js

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { readFile, readdir, unlink } from 'node:fs/promises';
+import { readFile, readdir, stat, unlink } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, join, resolve } from 'node:path';
 import { forEachJsonlRecord, listJsonlFiles, mapConcurrent, readJsonlWindow } from './native-jsonl-reader.js';
@@ -10,9 +10,16 @@ const TRANSCRIPT_READ_BYTES = 4 * 1024 * 1024;
 const CONTEXT_USAGE_READ_BYTES = 256 * 1024;
 const CLAUDE_CONTEXT_USAGE_READ_BYTES = [CONTEXT_USAGE_READ_BYTES, 1024 * 1024, 4 * 1024 * 1024];
 const TRANSCRIPT_INDEX_TTL_MS = 60 * 60_000;
+const DISCOVERY_SNAPSHOT_TTL_MS = 15_000;
+const TRANSCRIPT_DETAIL_CACHE_TTL_MS = 60_000;
+const TRANSCRIPT_DETAIL_CACHE_MAX_ENTRIES = 16;
 const transcriptIndex = new Map();
 const transcriptIndexTimers = new Map();
+const transcriptDetailCache = new Map();
+const transcriptDetailReads = new Map();
 const discoveryReads = new Map();
+const discoverySnapshots = new Map();
+const discoveryGenerations = new Map();
 const DEFAULT_CLAUDE_CONTEXT_WINDOW_TOKENS = 200_000;
 const CLAUDE_CONTEXT_WINDOW_ENV = 'MAR_CLAUDE_CONTEXT_WINDOW_TOKENS';
 /**
@@ -26,61 +33,128 @@ export async function discoverNativeSessions(runner, workspacePath) {
 }
 /**
  * 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 async function discoverAllNativeSessions(runner) {
-    const current = discoveryReads.get(runner);
-    if (current !== undefined)
+    const key = discoveryKey(runner);
+    const snapshot = discoverySnapshots.get(key);
+    if (snapshot !== undefined && snapshot.expiresAt > Date.now()) {
+        snapshot.cacheHits += 1;
+        return snapshot.sessions;
+    }
+    const current = discoveryReads.get(key);
+    if (current !== undefined) {
+        nodeLog('native.session.discovery.single-flight-joined', { runner });
         return current;
-    const discovery = performNativeSessionDiscovery(runner).finally(() => discoveryReads.delete(runner));
-    discoveryReads.set(runner, discovery);
+    }
+    const generation = discoveryGenerations.get(key) ?? 0;
+    const discovery = performNativeSessionDiscovery(runner, snapshot)
+        .then((next) => {
+        if ((discoveryGenerations.get(key) ?? 0) === generation)
+            discoverySnapshots.set(key, next);
+        return next.sessions;
+    })
+        .finally(() => {
+        if (discoveryReads.get(key) === discovery)
+            discoveryReads.delete(key);
+    });
+    discoveryReads.set(key, discovery);
     return discovery;
 }
-async function performNativeSessionDiscovery(runner) {
+async function performNativeSessionDiscovery(runner, previous) {
     const startedAt = performance.now();
     const found = new Map();
     nodeLog('native.session.discovery.started', { runner });
-    const files = await listJsonlFiles(transcriptRoot(runner));
+    const files = (await listJsonlFiles(transcriptRoot(runner))).filter((path) => runner !== 'claude-code' || !path.split(/[\\/]/u).includes('subagents'));
     nodeLog('native.session.discovery.files-listed', {
         runner,
         files: files.length,
         durationMs: Math.round(performance.now() - startedAt)
     });
-    const parsedFiles = await readDiscoveryHeaders(files, runner);
-    for (const [index, parsed] of parsedFiles.entries()) {
+    let completed = 0;
+    let parsedCount = 0;
+    let reusedCount = 0;
+    let metadataFailures = 0;
+    let metadataWorkMs = 0;
+    let parseWorkMs = 0;
+    const discoveredFiles = await mapConcurrent(files, 32, async (path) => {
+        let fingerprint;
+        const metadataStartedAt = performance.now();
+        try {
+            const metadata = await stat(path);
+            fingerprint = `${metadata.size}:${metadata.mtimeMs}`;
+        }
+        catch {
+            metadataFailures += 1;
+            return undefined;
+        }
+        finally {
+            metadataWorkMs += performance.now() - metadataStartedAt;
+        }
+        const cached = previous?.files.get(path);
+        let parsed;
+        if (cached?.fingerprint === fingerprint) {
+            parsed = cached.parsed;
+            reusedCount += 1;
+        }
+        else {
+            const parseStartedAt = performance.now();
+            parsed = await readTranscript(path, runner, DISCOVERY_READ_BYTES);
+            parseWorkMs += performance.now() - parseStartedAt;
+            parsedCount += 1;
+        }
+        completed += 1;
+        if (completed % 250 === 0)
+            nodeLog('native.session.discovery.progress', {
+                runner,
+                completed,
+                files: files.length,
+                parsedFiles: parsedCount,
+                reusedFiles: reusedCount,
+                metadataFailures,
+                metadataWorkMs: Math.round(metadataWorkMs),
+                parseWorkMs: Math.round(parseWorkMs),
+                durationMs: Math.round(performance.now() - startedAt)
+            });
+        return { path, fingerprint, parsed };
+    });
+    const snapshotFiles = new Map();
+    for (const file of discoveredFiles) {
+        if (file === undefined)
+            continue;
+        snapshotFiles.set(file.path, { fingerprint: file.fingerprint, parsed: file.parsed });
+        const parsed = file.parsed;
         // Discovery only needs a session identity, cwd and an optional early
         // title. Loading entire JSONL files here made opening a Workspace depend
         // on the total history of every other project on the Node.
         if (parsed === undefined)
             continue;
         const cwd = canonical(parsed.cwd);
-        setTranscriptIndex(indexKey(runner, cwd, parsed.externalSessionId), files[index]);
+        setTranscriptIndex(indexKey(runner, cwd, parsed.externalSessionId), file.path);
         found.set(`${cwd}\u0000${parsed.externalSessionId}`, parsed);
     }
     nodeLog('native.session.discovery.completed', {
         runner,
         files: files.length,
         sessions: found.size,
+        parsedFiles: parsedCount,
+        reusedFiles: reusedCount,
+        unparsedFiles: [...snapshotFiles.values()].filter((file) => file.parsed === undefined).length,
+        metadataFailures,
+        metadataWorkMs: Math.round(metadataWorkMs),
+        parseWorkMs: Math.round(parseWorkMs),
+        cacheMode: previous === undefined ? 'cold' : 'refresh',
+        previousCacheHits: previous?.cacheHits ?? 0,
         durationMs: Math.round(performance.now() - startedAt)
     });
-    return [...found.values()];
-}
-async function readDiscoveryHeaders(files, runner) {
-    let completed = 0;
-    const startedAt = performance.now();
-    return mapConcurrent(files, 32, async (path) => {
-        const value = await readTranscript(path, runner, DISCOVERY_READ_BYTES);
-        completed += 1;
-        if (completed % 250 === 0)
-            nodeLog('native.session.discovery.progress', {
-                runner,
-                completed,
-                files: files.length,
-                durationMs: Math.round(performance.now() - startedAt)
-            });
-        return value;
-    });
+    return {
+        expiresAt: Date.now() + DISCOVERY_SNAPSHOT_TTL_MS,
+        files: snapshotFiles,
+        sessions: [...found.values()],
+        cacheHits: 0
+    };
 }
 /** Reads one already-discovered external session again to follow appended JSONL records. */
 export async function readNativeSession(runner, workspacePath, externalSessionId) {
@@ -88,7 +162,7 @@ export async function readNativeSession(runner, workspacePath, externalSessionId
     const path = getTranscriptIndex(indexKey(runner, wanted, externalSessionId));
     if (path === undefined)
         return undefined;
-    const parsed = await readTranscript(path, runner, TRANSCRIPT_READ_BYTES);
+    const parsed = await readTranscriptDetail(path, runner);
     if (parsed === undefined ||
         parsed.externalSessionId !== externalSessionId ||
         canonical(parsed.cwd) !== wanted) {
@@ -97,6 +171,70 @@ export async function readNativeSession(runner, workspacePath, externalSessionId
     }
     return parsed;
 }
+async function readTranscriptDetail(path, runner) {
+    const key = `${runner}\u0000${path}`;
+    let fingerprint;
+    try {
+        const metadata = await stat(path);
+        fingerprint = `${metadata.size}:${metadata.mtimeMs}`;
+    }
+    catch {
+        transcriptDetailCache.delete(key);
+        transcriptDetailReads.delete(key);
+        return undefined;
+    }
+    const cached = transcriptDetailCache.get(key);
+    if (cached?.fingerprint === fingerprint && cached.expiresAt > Date.now()) {
+        cached.expiresAt = Date.now() + TRANSCRIPT_DETAIL_CACHE_TTL_MS;
+        transcriptDetailCache.delete(key);
+        transcriptDetailCache.set(key, cached);
+        return cached.parsed;
+    }
+    transcriptDetailCache.delete(key);
+    const current = transcriptDetailReads.get(key);
+    if (current?.fingerprint === fingerprint) {
+        nodeLog('native.session.history.single-flight-joined', { runner });
+        return current.read;
+    }
+    const startedAt = performance.now();
+    const read = readTranscript(path, runner, TRANSCRIPT_READ_BYTES)
+        .then((parsed) => {
+        if (transcriptDetailReads.get(key)?.read === read) {
+            transcriptDetailCache.set(key, {
+                fingerprint,
+                parsed,
+                expiresAt: Date.now() + TRANSCRIPT_DETAIL_CACHE_TTL_MS
+            });
+            pruneTranscriptDetailCache();
+        }
+        const durationMs = Math.round(performance.now() - startedAt);
+        if (durationMs >= 250)
+            nodeLog('native.session.history.detail-parse.completed', {
+                runner,
+                bytes: Number(fingerprint.slice(0, fingerprint.indexOf(':'))),
+                durationMs
+            });
+        return parsed;
+    })
+        .finally(() => {
+        if (transcriptDetailReads.get(key)?.read === read)
+            transcriptDetailReads.delete(key);
+    });
+    transcriptDetailReads.set(key, { fingerprint, read });
+    return read;
+}
+function pruneTranscriptDetailCache() {
+    const now = Date.now();
+    for (const [key, cached] of transcriptDetailCache)
+        if (cached.expiresAt <= now)
+            transcriptDetailCache.delete(key);
+    while (transcriptDetailCache.size > TRANSCRIPT_DETAIL_CACHE_MAX_ENTRIES) {
+        const oldest = transcriptDetailCache.keys().next().value;
+        if (oldest === undefined)
+            return;
+        transcriptDetailCache.delete(oldest);
+    }
+}
 /**
  * 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
@@ -232,12 +370,24 @@ export async function removeNativeSession(runner, workspacePath, externalSession
         throw error;
     }
     deleteTranscriptIndex(indexKey(runner, wanted, externalSessionId));
+    transcriptDetailCache.delete(`${runner}\u0000${path}`);
+    transcriptDetailReads.delete(`${runner}\u0000${path}`);
+    invalidateNativeDiscovery(runner);
 }
 function transcriptRoot(runner) {
     return runner === 'codex'
         ? join(homedir(), '.codex', 'sessions')
         : join(homedir(), '.claude', 'projects');
 }
+function discoveryKey(runner) {
+    return `${runner}\u0000${transcriptRoot(runner)}`;
+}
+function invalidateNativeDiscovery(runner) {
+    const key = discoveryKey(runner);
+    discoveryGenerations.set(key, (discoveryGenerations.get(key) ?? 0) + 1);
+    discoverySnapshots.delete(key);
+    discoveryReads.delete(key);
+}
 async function readTranscript(path, runner, byteLimit) {
     const window = await readJsonlWindow(path, { headBytes: byteLimit, tailBytes: byteLimit });
     if (window === undefined)
@@ -245,11 +395,14 @@ async function readTranscript(path, runner, byteLimit) {
     const { content, truncated } = window;
     let cwd;
     let id;
+    let derivedSession = false;
     const items = [];
     const toolIndexes = new Map();
     const pendingToolResults = new Map();
     const metaRecordIds = new Set();
     forEachJsonlRecord(content, (value) => {
+        if (derivedTranscriptRecord(runner, value))
+            derivedSession = true;
         cwd ??= workspacePath(value);
         id ??= sessionId(value);
         const recordId = typeof value['uuid'] === 'string' ? value['uuid'] : undefined;
@@ -284,6 +437,8 @@ async function readTranscript(path, runner, byteLimit) {
             items.push(item);
         }
     });
+    if (derivedSession)
+        return undefined;
     for (const result of pendingToolResults.values())
         items.push({
             kind: 'tool_call',
@@ -318,6 +473,20 @@ async function readTranscript(path, runner, byteLimit) {
         truncated
     };
 }
+function derivedTranscriptRecord(runner, value) {
+    if (runner === 'claude-code')
+        return value['isSidechain'] === true;
+    if (runner !== 'codex' || value['type'] !== 'session_meta')
+        return false;
+    const payload = isRecord(value['payload']) ? value['payload'] : undefined;
+    if (payload === undefined)
+        return false;
+    if (payload['thread_source'] === 'subagent')
+        return true;
+    const source = payload['source'];
+    return (source === 'subagent' ||
+        (isRecord(source) && (source['kind'] === 'subagent' || isRecord(source['subagent']))));
+}
 function workspacePath(record) {
     return (firstString(record, ['cwd', 'working_directory', 'workspacePath']) ??
         nestedString(record, ['payload', 'cwd']) ??

package/dist/opencode-server.d.ts

@@ -36,6 +36,7 @@ export declare class OpenCodeServerClient {
         readonly model: string;
         readonly variant?: string;
         readonly agent?: 'plan' | 'build';
+        readonly system?: string;
         readonly attachments?: readonly {
             readonly name: string;
             readonly mime: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';

package/dist/opencode-server.js

@@ -169,6 +169,7 @@ export class OpenCodeServerClient {
                 ? {}
                 : { variant: input.variant }),
             ...(input.agent === undefined ? {} : { agent: input.agent }),
+            ...(input.system === undefined ? {} : { system: input.system }),
             parts: [
                 { type: 'text', text: input.text },
                 ...(input.attachments ?? []).map((attachment) => ({

package/dist/runner/abstract-runner.d.ts

@@ -50,7 +50,8 @@ export declare abstract class AbstractRunner<TName extends RegisteredRunnerName
     readOfficialConversation(session: NodeAgentSession, input: {
         readonly cursor?: string;
         readonly limit?: number;
-    }, managedTurn: (nativeTurnId: string) => NodeConversationTurn | undefined): Promise<RunnerOfficialConversationPage | undefined>;
+    }, managedTurn: (nativeTurnId: string) => NodeConversationTurn | undefined): Promise<RunnerConversationPage | undefined>;
+    readConversationHistory(readers: RunnerConversationHistoryReaders): Promise<RunnerConversationHistoryPage | undefined>;
     readExternalActivity(session: NodeAgentSession): Promise<SessionActivityState | undefined>;
     acceptsTruncatedNativeHistory(): boolean;
     nativeImageRoots(session: NodeAgentSession): readonly string[];
@@ -134,10 +135,18 @@ export interface RunnerProjectionTitleInput {
     readonly title?: string;
     readonly titleOrigin?: 'OFFICIAL' | 'NATIVE';
 }
-export interface RunnerOfficialConversationPage {
+export interface RunnerConversationPage {
     readonly turns: readonly NodeConversationTurn[];
     readonly nextCursor: string | null;
 }
+export type RunnerConversationHistorySource = 'native' | 'official';
+export interface RunnerConversationHistoryReaders {
+    readonly native: () => Promise<RunnerConversationPage | undefined>;
+    readonly official: () => Promise<RunnerConversationPage | undefined>;
+}
+export interface RunnerConversationHistoryPage extends RunnerConversationPage {
+    readonly source: RunnerConversationHistorySource;
+}
 export interface RunnerSessionPresentationContext {
     readonly managedActive: boolean;
     readonly externalActivity: SessionActivityState | undefined;

package/dist/runner/abstract-runner.js

@@ -99,6 +99,10 @@ export class AbstractRunner {
         void [session, input, managedTurn];
         return undefined;
     }
+    async readConversationHistory(readers) {
+        const page = await readers.native();
+        return page === undefined ? undefined : { ...page, source: 'native' };
+    }
     async readExternalActivity(session) {
         void session;
         return undefined;

package/dist/runner/claude/managed-run-controller.js

@@ -148,6 +148,9 @@ export class ClaudeManagedRunController {
                 ...(typeof payload.effort === 'string' ? { effort: payload.effort } : {}),
                 ...(typeof payload.access === 'string' ? { access: payload.access } : {}),
                 environment: secretEnvironment,
+                ...(typeof payload.personalInstructions === 'string'
+                    ? { personalInstructions: payload.personalInstructions }
+                    : {}),
                 mcpServers: this.runner.mcpConfiguration(payload.mcpInstallations, secretEnvironment),
                 ...(attachments.length === 0
                     ? {}

package/dist/runner/claude-code-runner.d.ts

@@ -1,5 +1,5 @@
 import { ClaudeAgentSdkAdapter, type ClaudeChannelRunHandle, type ClaudeQueryInput, type ClaudeRunHandle } from '../claude-agent-sdk.js';
-import { AbstractRunner, type ExternalResumeContext, type ExternalResumeResult, type RunnerDiscoveryContext, type RunnerSessionPresentationContext, type RunnerSessionPresentation } from './abstract-runner.js';
+import { AbstractRunner, type ExternalResumeContext, type ExternalResumeResult, type RunnerDiscoveryContext, type RunnerConversationHistoryPage, type RunnerConversationHistoryReaders, type RunnerSessionPresentationContext, type RunnerSessionPresentation } from './abstract-runner.js';
 import type { NodeCapabilities, RunnerDefaultConfiguration, RunnerProfile } from '@myagentroam/protocol';
 import { ClaudeChannelGate } from '../claude-channel.js';
 import type { ChannelDelivery } from '../claude-channel.js';
@@ -21,6 +21,7 @@ export declare class ClaudeCodeRunner extends AbstractRunner<'claude-code'> {
     resumeExternal(external: NodeAgentSession, context: ExternalResumeContext): Promise<ExternalResumeResult>;
     discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
     readContextUsage(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeClaudeContextUsage | undefined>;
+    readConversationHistory(readers: RunnerConversationHistoryReaders): Promise<RunnerConversationHistoryPage | undefined>;
     forkNative(session: NodeAgentSession, boundary: string | null, title: string): Promise<string | null>;
     presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
     prepareMessageInput(input: string, collaborationMode: 'default' | 'plan'): string;

package/dist/runner/claude-code-runner.js

@@ -135,6 +135,10 @@ export class ClaudeCodeRunner extends AbstractRunner {
             ? Promise.resolve(undefined)
             : readClaudeNativeContextUsage(session.cwd, session.externalSessionId);
     }
+    async readConversationHistory(readers) {
+        const native = await readers.native();
+        return native === undefined ? undefined : { ...native, source: 'native' };
+    }
     forkNative(session, boundary, title) {
         if (session.externalSessionId === null)
             throw new Error('SESSION_REWIND_UNAVAILABLE');

package/dist/runner/codex/managed-run-controller.js

@@ -354,6 +354,9 @@ export class CodexManagedRunController {
             access: payload.access,
             collaborationMode: payload.collaborationMode,
             serviceTier: payload.serviceTier,
+            ...(typeof payload.personalInstructions === 'string'
+                ? { personalInstructions: payload.personalInstructions }
+                : {}),
             mcpServers: this.runner.mcpConfiguration(payload.mcpInstallations, secretEnvironment)
         }, attachments);
     }
@@ -370,6 +373,9 @@ export class CodexManagedRunController {
                 ...(typeof payload.model === 'string' ? { model: payload.model } : {}),
                 ...(typeof payload.effort === 'string' ? { effort: payload.effort } : {}),
                 ...(typeof payload.access === 'string' ? { access: payload.access } : {}),
+                ...(payload.personalInstructions === undefined
+                    ? {}
+                    : { developerInstructions: payload.personalInstructions }),
                 ...(payload.mcpServers === undefined ? {} : { mcpServers: payload.mcpServers })
             };
             const collaborationMode = payload.collaborationMode === 'plan' || payload.collaborationMode === 'default'

package/dist/runner/codex-runner.d.ts

@@ -1,5 +1,5 @@
 import { CodexAppServerClient, type CodexComposerInput, type CodexRunConfiguration, type JsonRpcNotification } from '../codex-app-server.js';
-import { AbstractRunner, type ExternalResumeContext, type ExternalResumeResult, type RunnerDiscoveryContext, type RunnerSessionPresentationContext, type RunnerSessionPresentation, type RunnerProjectionTitleInput } from './abstract-runner.js';
+import { AbstractRunner, type ExternalResumeContext, type ExternalResumeResult, type RunnerDiscoveryContext, type RunnerConversationHistoryPage, type RunnerConversationHistoryReaders, type RunnerSessionPresentationContext, type RunnerSessionPresentation, type RunnerProjectionTitleInput } from './abstract-runner.js';
 import type { NodeCapabilities, RunnerDefaultConfiguration, RunnerProfile } from '@myagentroam/protocol';
 import type { NodeAgentSession, NodeDatabase } from '../database.js';
 import type { NodeWorkspace } from '../database.js';
@@ -43,6 +43,7 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
         readonly turns: readonly import("../database.js").NodeConversationTurn[];
         readonly nextCursor: string | null;
     } | undefined>;
+    readConversationHistory(readers: RunnerConversationHistoryReaders): Promise<RunnerConversationHistoryPage | undefined>;
     readExternalActivity(session: NodeAgentSession): Promise<"UNAVAILABLE" | "MANAGED_ACTIVE" | "EXTERNAL_ACTIVE" | "IDLE" | undefined>;
     acceptsTruncatedNativeHistory(): boolean;
     readManagedRunnerTitle(session: NodeAgentSession, nativeSessionId: string): Promise<string | undefined>;