@myagentroam/node 0.9.3 → 0.9.5

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.d.ts

@@ -6,6 +6,15 @@ import { CodexRunner } from '../codex-runner.js';
 type CodexImageInput = Extract<CodexComposerInput, {
     readonly type: 'localImage';
 }>;
+interface CodexNotificationRun {
+    readonly threadId: string;
+    readonly turnId?: string;
+}
+export declare function resolveCodexNotificationRun<T extends CodexNotificationRun>(runs: ReadonlyMap<string, T>, input: {
+    readonly threadId?: string;
+    readonly turnId?: string;
+    readonly allowUnboundFallback?: boolean;
+}): readonly [string, T] | undefined;
 export interface CodexManagedRunHost<TAttachment> {
     readonly available: () => boolean;
     readonly intercepted: () => boolean;

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

@@ -3,6 +3,25 @@ import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
 import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
+export function resolveCodexNotificationRun(runs, input) {
+    const entries = [...runs.entries()];
+    if (input.turnId !== undefined) {
+        const exact = entries.find(([, value]) => value.turnId === input.turnId &&
+            (input.threadId === undefined || value.threadId === input.threadId));
+        if (exact !== undefined)
+            return exact;
+        if (input.allowUnboundFallback !== true)
+            return undefined;
+        // `turn/started` can arrive before the `turn/start` response binds its native Turn ID. Only
+        // an unbound Run on the same thread is a valid fallback; an older bound Run is never valid.
+        return entries
+            .reverse()
+            .find(([, value]) => value.threadId === input.threadId && value.turnId === undefined);
+    }
+    if (input.threadId === undefined)
+        return undefined;
+    return entries.reverse().find(([, value]) => value.threadId === input.threadId);
+}
 export class CodexManagedRunController {
     runner;
     host;
@@ -104,8 +123,11 @@ export class CodexManagedRunController {
         const threadId = typeof params.threadId === 'string' ? params.threadId : undefined;
         if (turnId === undefined && threadId === undefined)
             return;
-        const run = [...this.runner.execution.runs.entries()].find(([, value]) => (turnId !== undefined && value.turnId === turnId) ||
-            (threadId !== undefined && value.threadId === threadId));
+        const run = resolveCodexNotificationRun(this.runner.execution.runs, {
+            ...(turnId === undefined ? {} : { turnId }),
+            ...(threadId === undefined ? {} : { threadId }),
+            ...(notification.method === 'turn/started' ? { allowUnboundFallback: true } : {})
+        });
         if (run === undefined)
             return;
         const [runId] = run;
@@ -332,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);
     }
@@ -348,30 +373,51 @@ 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 threadResult = typeof payload.externalSessionId === 'string'
-                ? await this.runner.resumeThread(payload.externalSessionId, cwd, configuration)
-                : await this.runner.startThread(cwd, configuration);
-            if (this.host.completeCancelled(runId, cwd)) {
-                this.runner.releaseEnvironment(runId);
-                return;
+            const collaborationMode = payload.collaborationMode === 'plan' || payload.collaborationMode === 'default'
+                ? payload.collaborationMode
+                : undefined;
+            const turnConfiguration = {
+                ...configuration,
+                ...(collaborationMode === undefined ? {} : { collaborationMode }),
+                ...(payload.serviceTier === 'fast' ? { serviceTier: 'fast' } : {})
+            };
+            const materializedAttachments = await this.host.materialize(runId, attachments);
+            let threadId;
+            let turnResult;
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                try {
+                    const threadResult = typeof payload.externalSessionId === 'string'
+                        ? await this.runner.resumeThread(payload.externalSessionId, cwd, configuration)
+                        : await this.runner.startThread(cwd, configuration);
+                    if (this.host.completeCancelled(runId, cwd)) {
+                        this.runner.releaseEnvironment(runId);
+                        return;
+                    }
+                    threadId = extractId(threadResult, 'thread');
+                    this.runner.execution.runs.set(runId, { sessionId, threadId, cwd });
+                    turnResult = await this.runner.startTurn(threadId, input, cwd, turnConfiguration, materializedAttachments);
+                    break;
+                }
+                catch (error) {
+                    this.runner.execution.runs.delete(runId);
+                    if (attempt === 0 && (await this.runner.recoverMissingRollout(runId, error)))
+                        continue;
+                    throw error;
+                }
             }
-            const threadId = extractId(threadResult, 'thread');
+            if (threadId === undefined || turnResult === undefined)
+                throw new Error('CODEX_RUN_FAILED');
             let publicSessionId = sessionId;
             if (typeof payload.externalSessionId !== 'string') {
                 this.host.promoteSession(sessionId, threadId);
                 publicSessionId = threadId;
                 this.host.send('session.external-id', { sessionId, externalSessionId: threadId });
             }
-            this.runner.execution.runs.set(runId, { sessionId: publicSessionId, threadId, cwd });
-            const turnResult = await this.runner.startTurn(threadId, input, cwd, {
-                ...configuration,
-                ...(payload.collaborationMode === 'plan' || payload.collaborationMode === 'default'
-                    ? { collaborationMode: payload.collaborationMode }
-                    : {}),
-                ...(payload.serviceTier === 'fast' ? { serviceTier: 'fast' } : {})
-            }, await this.host.materialize(runId, attachments));
             const turnId = extractId(turnResult, 'turn');
             this.runner.execution.runs.set(runId, { sessionId: publicSessionId, threadId, turnId, cwd });
             this.runner.execution.managedTurns.set(turnId, { sessionId: publicSessionId, runId });

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>;
@@ -58,6 +59,7 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
     presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
     onNotification(listener: (notification: JsonRpcNotification) => void): () => void;
     start(): Promise<void>;
+    recoverMissingRollout(runId: string, error: unknown): Promise<boolean>;
     prepareEnvironment(environment: Readonly<Record<string, string>>, runId: string): void;
     releaseEnvironment(runId: string): void;
     stop(): void;

package/dist/runner/codex-runner.js

@@ -1,4 +1,4 @@
-import { CodexAppServerClient } from '../codex-app-server.js';
+import { CodexAppServerClient, isCodexRolloutMissingError } from '../codex-app-server.js';
 import { AbstractRunner } from './abstract-runner.js';
 import { declaredRunnerProfiles } from '../runner-profiles.js';
 import { homedir } from 'node:os';
@@ -250,6 +250,16 @@ export class CodexRunner extends AbstractRunner {
             return undefined;
         }
     }
+    async readConversationHistory(readers) {
+        // Codex JSONL is the low-latency durable record for normal history reads,
+        // while thread/read can take seconds on large threads. Keep the official
+        // API as a fallback because a transcript can be missing or bounded/truncated.
+        const native = await readers.native();
+        if (native !== undefined)
+            return { ...native, source: 'native' };
+        const official = await readers.official();
+        return official === undefined ? undefined : { ...official, source: 'official' };
+    }
     async readExternalActivity(session) {
         if (session.nativeControl !== 'EXTERNAL' || session.externalSessionId === null)
             return undefined;
@@ -355,7 +365,7 @@ export class CodexRunner extends AbstractRunner {
         }
         const sessions = [];
         for (const thread of threads) {
-            if (thread.source !== 'cli' && thread.source !== 'vscode')
+            if (thread.derived || (thread.source !== 'cli' && thread.source !== 'vscode'))
                 continue;
             let cwd;
             try {
@@ -451,6 +461,17 @@ export class CodexRunner extends AbstractRunner {
     start() {
         return this.client.start();
     }
+    async recoverMissingRollout(runId, error) {
+        if (!isCodexRolloutMissingError(error))
+            return false;
+        if ([...this.environmentRuns].some((activeRunId) => activeRunId !== runId))
+            return false;
+        if ([...this.execution.runs.keys()].some((activeRunId) => activeRunId !== runId))
+            return false;
+        nodeLog('runner.codex.rollout.recovering', { runId });
+        await this.client.restart();
+        return true;
+    }
     prepareEnvironment(environment, runId) {
         if (Object.keys(environment).length === 0 && this.environmentFingerprint === undefined) {
             this.environmentRuns.add(runId);

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

@@ -128,6 +128,9 @@ export class OpenCodeManagedRunController {
             attachments,
             access: typeof payload.access === 'string' ? payload.access : 'default',
             agent: payload.collaborationMode === 'plan' ? 'plan' : 'build',
+            ...(typeof payload.personalInstructions === 'string'
+                ? { personalInstructions: payload.personalInstructions }
+                : {}),
             mcp
         });
     }
@@ -251,6 +254,7 @@ export class OpenCodeManagedRunController {
                 model: input.model,
                 variant: input.effort,
                 agent: input.agent,
+                ...(input.personalInstructions === undefined ? {} : { system: input.personalInstructions }),
                 attachments: input.attachments
             });
             this.promptAdmitted.add(input.runId);