@myagentroam/node 0.9.4 → 0.9.6

package/dist/native-session-history.js

@@ -1,18 +1,29 @@
 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';
+import { forEachJsonlRecord, listJsonlFiles, mapConcurrent, readJsonlBackwardWindow, readJsonlFileAnchor, readJsonlWindow } from './native-jsonl-reader.js';
 import { nodeLog } from './operational.js';
 import { stripClaudePlanTag } from './runner-command-engine.js';
 const DISCOVERY_READ_BYTES = 32 * 1024;
-const TRANSCRIPT_READ_BYTES = 4 * 1024 * 1024;
+const TRANSCRIPT_HEADER_READ_BYTES = 32 * 1024;
+const TRANSCRIPT_READ_MAX_BYTES = 16 * 1024 * 1024;
+const TRANSCRIPT_MIN_LINES = 256;
+const TRANSCRIPT_MAX_LINES = 4096;
+const TRANSCRIPT_LINES_PER_TURN = 32;
 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,76 +37,224 @@ 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) {
+export async function readNativeSession(runner, workspacePath, externalSessionId, page, limit = 30) {
     const wanted = canonical(workspacePath);
     const path = getTranscriptIndex(indexKey(runner, wanted, externalSessionId));
     if (path === undefined)
         return undefined;
-    const parsed = await readTranscript(path, runner, TRANSCRIPT_READ_BYTES);
+    const detail = await readTranscriptDetail(path, runner, page, page?.readLimit ?? limit);
+    const parsed = detail?.history;
     if (parsed === undefined ||
         parsed.externalSessionId !== externalSessionId ||
         canonical(parsed.cwd) !== wanted) {
         deleteTranscriptIndex(indexKey(runner, wanted, externalSessionId));
         return undefined;
     }
-    return parsed;
+    return detail?.cursorAccepted === false ? { ...parsed, cursorReset: true } : parsed;
+}
+async function readTranscriptDetail(path, runner, page, limit) {
+    let fingerprint;
+    try {
+        const metadata = await stat(path);
+        fingerprint = `${metadata.size}:${metadata.mtimeMs}`;
+    }
+    catch {
+        return undefined;
+    }
+    const metadataSize = Number(fingerprint.slice(0, fingerprint.indexOf(':')));
+    const validPage = page !== undefined &&
+        page.snapshotEnd <= metadataSize &&
+        (await readJsonlFileAnchor(path, page.anchorBytes)) === page.fileAnchor
+        ? page
+        : undefined;
+    const targetLines = Math.min(TRANSCRIPT_MAX_LINES, Math.max(TRANSCRIPT_MIN_LINES, Math.max(1, limit) * TRANSCRIPT_LINES_PER_TURN));
+    const pageKey = `${validPage === undefined
+        ? 'latest'
+        : `${validPage.fileAnchor}:${validPage.snapshotEnd}:${validPage.nextEnd}`}:${targetLines}`;
+    const key = `${runner}\u0000${path}\u0000${pageKey}`;
+    const cacheFingerprint = validPage === undefined ? fingerprint : `${validPage.fileAnchor}:${validPage.snapshotEnd}`;
+    const cached = transcriptDetailCache.get(key);
+    if (cached?.fingerprint === cacheFingerprint && cached.expiresAt > Date.now()) {
+        cached.expiresAt = Date.now() + TRANSCRIPT_DETAIL_CACHE_TTL_MS;
+        transcriptDetailCache.delete(key);
+        transcriptDetailCache.set(key, cached);
+        return {
+            history: cached.parsed,
+            cursorAccepted: page === undefined || validPage !== undefined
+        };
+    }
+    transcriptDetailCache.delete(key);
+    const current = transcriptDetailReads.get(key);
+    if (current?.fingerprint === cacheFingerprint) {
+        nodeLog('native.session.history.single-flight-joined', { runner });
+        return {
+            history: await current.read,
+            cursorAccepted: page === undefined || validPage !== undefined
+        };
+    }
+    const startedAt = performance.now();
+    const read = readTranscript(path, runner, TRANSCRIPT_READ_MAX_BYTES, validPage, targetLines)
+        .then((parsed) => parsed === undefined ? undefined : { ...parsed, windowReadLimit: page?.readLimit ?? limit })
+        .then((parsed) => {
+        if (transcriptDetailReads.get(key)?.read === read) {
+            transcriptDetailCache.set(key, {
+                fingerprint: cacheFingerprint,
+                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: cacheFingerprint, read });
+    return { history: await read, cursorAccepted: page === undefined || validPage !== undefined };
+}
+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
@@ -216,7 +375,7 @@ export async function removeNativeSession(runner, workspacePath, externalSession
     }
     if (path === undefined)
         throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
-    const parsed = await readTranscript(path, runner, TRANSCRIPT_READ_BYTES);
+    const parsed = await readTranscript(path, runner, DISCOVERY_READ_BYTES);
     if (parsed === undefined ||
         parsed.externalSessionId !== externalSessionId ||
         canonical(parsed.cwd) !== wanted) {
@@ -232,26 +391,53 @@ export async function removeNativeSession(runner, workspacePath, externalSession
         throw error;
     }
     deleteTranscriptIndex(indexKey(runner, wanted, externalSessionId));
+    const detailKeyPrefix = `${runner}\u0000${path}\u0000`;
+    for (const key of transcriptDetailCache.keys())
+        if (key.startsWith(detailKeyPrefix))
+            transcriptDetailCache.delete(key);
+    for (const key of transcriptDetailReads.keys())
+        if (key.startsWith(detailKeyPrefix))
+            transcriptDetailReads.delete(key);
+    invalidateNativeDiscovery(runner);
 }
 function transcriptRoot(runner) {
     return runner === 'codex'
         ? join(homedir(), '.codex', 'sessions')
         : join(homedir(), '.claude', 'projects');
 }
-async function readTranscript(path, runner, byteLimit) {
-    const window = await readJsonlWindow(path, { headBytes: byteLimit, tailBytes: byteLimit });
+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, page, targetLines = Number.MAX_SAFE_INTEGER) {
+    const window = await readJsonlBackwardWindow(path, {
+        headBytes: Math.min(byteLimit, TRANSCRIPT_HEADER_READ_BYTES),
+        targetLines,
+        maxBytes: byteLimit,
+        ...(page === undefined ? {} : { page })
+    });
     if (window === undefined)
         return undefined;
     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);
+    });
+    forEachJsonlRecord(truncated ? window.pageContent : content, (value) => {
         const recordId = typeof value['uuid'] === 'string' ? value['uuid'] : undefined;
         const parentId = typeof value['parentUuid'] === 'string' ? value['parentUuid'] : undefined;
         if (value['isMeta'] === true && recordId !== undefined)
@@ -284,6 +470,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',
@@ -315,9 +503,28 @@ async function readTranscript(path, runner, byteLimit) {
         digest: createHash('sha256').update(content).digest('hex'),
         items,
         lastActivityAt: Math.max(0, ...items.map((item) => item.createdAt ?? 0)),
-        truncated
+        truncated,
+        windowStart: window.start,
+        windowEnd: window.end,
+        snapshotEnd: window.snapshotEnd,
+        fileAnchor: window.fileAnchor,
+        anchorBytes: window.anchorBytes
     };
 }
+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>;

package/dist/runner/codex-runner.js

@@ -250,6 +250,17 @@ 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. A bounded tail is a
+        // valid recent-history page; use the official API only when JSONL is absent
+        // or cannot produce any visible history.
+        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;
@@ -262,7 +273,7 @@ export class CodexRunner extends AbstractRunner {
         }
     }
     acceptsTruncatedNativeHistory() {
-        return false;
+        return true;
     }
     async readManagedRunnerTitle(session, nativeSessionId) {
         void session;
@@ -355,7 +366,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 {

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

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

@@ -1,7 +1,7 @@
 import type { NodeCapabilities, RunnerDefaultConfiguration, RunnerProfile } from '@myagentroam/protocol';
 import type { NodeAgentSession, NodeDatabase, NodeWorkspace } from '../database.js';
 import { OpenCodeServerClient } from '../opencode-server.js';
-import { AbstractRunner, type ExternalResumeContext, type ExternalResumeResult, type RunnerDiscoveryContext, type RunnerSessionPresentation, type RunnerSessionPresentationContext } from './abstract-runner.js';
+import { AbstractRunner, type ExternalResumeContext, type ExternalResumeResult, type RunnerDiscoveryContext, type RunnerConversationHistoryPage, type RunnerConversationHistoryReaders, type RunnerSessionPresentation, type RunnerSessionPresentationContext } from './abstract-runner.js';
 export interface OpenCodeManagedExecution {
     readonly runId: string;
     readonly sessionId: string;
@@ -20,6 +20,8 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
     private readonly modelsByWorkspace;
     private readonly contextLimitsByWorkspace;
     private readonly profileTimersByWorkspace;
+    private readonly profileCache;
+    private readonly profileRefreshes;
     readonly execution: Map<string, OpenCodeManagedExecution>;
     readonly managedTurns: Map<string, string>;
     private readonly environmentClients;
@@ -27,10 +29,14 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
     constructor(client?: OpenCodeServerClient, clientFactory?: () => OpenCodeServerClient);
     profile(capabilities: NodeCapabilities): RunnerProfile;
     refreshProfile(capabilities: NodeCapabilities, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<RunnerProfile>;
+    private fetchProfile;
+    private profileCacheKey;
+    private environmentFingerprint;
     available(capabilities: NodeCapabilities): boolean;
     protected profileForValidation(): RunnerProfile;
-    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: NodeWorkspace): boolean;
-    defaultConfiguration(workspace?: NodeWorkspace): RunnerDefaultConfiguration;
+    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): boolean;
+    defaultConfiguration(workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): RunnerDefaultConfiguration;
+    private cachedModels;
     mcpConfiguration(raw: unknown, secrets: Readonly<Record<string, string>>): unknown;
     discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
     resumeExternal(external: NodeAgentSession, context: ExternalResumeContext): Promise<ExternalResumeResult>;
@@ -42,6 +48,7 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
         readonly turns: readonly import("../database.js").NodeConversationTurn[];
         readonly nextCursor: string | null;
     } | undefined>;
+    readConversationHistory(readers: RunnerConversationHistoryReaders): Promise<RunnerConversationHistoryPage | undefined>;
     managedRunForNativeTurn(nativeTurnId: string): string | undefined;
     presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
     renameNative(session: NodeAgentSession, input: {