@myagentroam/node 0.11.36 → 0.11.38

package/dist/runner/codex/codex-app-server.js

@@ -0,0 +1,471 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { minimalRunnerEnvironment, platformCliInvocation, runRunnerProbe } from '../../operational.js';
+const REQUEST_TIMEOUT_MS = 15_000;
+/**
+ * Maps the facts that the Node can establish to the unified session controls.
+ * Native-session activation is validated atomically with the first message.
+ */
+export function codexSessionControl(input) {
+    void [input.available, input.nativeThreadId, input.nativeControl];
+    if (input.activeTurn) {
+        return {
+            level: 'MANAGED',
+            capabilities: ['history.read', 'events.live', 'turn.steer', 'turn.interrupt']
+        };
+    }
+    return {
+        level: 'MANAGED',
+        capabilities: ['history.read', 'turn.start']
+    };
+}
+export class CodexAppServerRpcError extends Error {
+    code;
+    rpcMessage;
+    data;
+    constructor(payload) {
+        const rpcMessage = typeof payload.message === 'string' ? payload.message : 'Codex App Server request failed';
+        super(`CODEX_APP_SERVER_RPC_ERROR:${JSON.stringify(payload)}`);
+        this.name = 'CodexAppServerRpcError';
+        this.code = payload.code;
+        this.rpcMessage = rpcMessage;
+        this.data = payload.data;
+    }
+}
+export function isCodexRolloutMissingError(error) {
+    return (error instanceof CodexAppServerRpcError &&
+        error.code === -32600 &&
+        (/^no rollout found for thread id\b/i.test(error.rpcMessage) ||
+            /^thread not loaded:\s*/i.test(error.rpcMessage)));
+}
+/**
+ * Local JSON-RPC client for a Node-supervised Codex App Server over stdio.
+ * The transport is not exposed to MAR Server or the browser.
+ */
+export class CodexAppServerClient {
+    options;
+    child;
+    transport;
+    nextId = 1;
+    pending = new Map();
+    pendingDrainWaiters = new Set();
+    notifications = new Set();
+    environment = {};
+    starting;
+    restarting;
+    lifecycleRevision = 0;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    configureEnvironment(environment) {
+        if (this.child !== undefined)
+            throw new Error('CODEX_APP_SERVER_ALREADY_STARTED');
+        this.environment = { ...environment };
+    }
+    clearEnvironment() {
+        if (this.child !== undefined)
+            throw new Error('CODEX_APP_SERVER_ALREADY_STARTED');
+        this.environment = {};
+    }
+    start() {
+        if (this.restarting !== undefined)
+            return this.restarting;
+        if (this.starting !== undefined)
+            return this.starting;
+        if (this.child !== undefined)
+            return Promise.resolve();
+        const starting = this.startManaged();
+        this.starting = starting;
+        const clearStarting = () => {
+            if (this.starting === starting)
+                this.starting = undefined;
+        };
+        void starting.then(clearStarting, clearStarting);
+        return starting;
+    }
+    restart() {
+        if (this.restarting !== undefined)
+            return this.restarting;
+        const restarting = this.restartManaged(this.lifecycleRevision);
+        this.restarting = restarting;
+        const clearRestarting = () => {
+            if (this.restarting === restarting)
+                this.restarting = undefined;
+        };
+        void restarting.then(clearRestarting, clearRestarting);
+        return restarting;
+    }
+    async startManaged() {
+        const command = this.options.command ?? 'codex';
+        const args = this.options.args ?? ['app-server'];
+        const spawnProcess = this.options.spawnProcess ?? defaultSpawn;
+        const child = spawnProcess(command, args, {
+            ...(this.options.cwd === undefined ? {} : { cwd: this.options.cwd }),
+            env: { ...minimalRunnerEnvironment(), ...this.environment }
+        });
+        this.child = child;
+        this.transport = stdioTransport(child);
+        const lines = createInterface({ input: child.stdout });
+        lines.on('line', (line) => this.handleLine(line));
+        const managedChild = child;
+        child.once('error', (error) => {
+            if (this.child !== managedChild)
+                return;
+            this.failAll(new Error(`CODEX_APP_SERVER_START_FAILED:${error.message}`));
+        });
+        child.once('exit', () => {
+            if (this.child !== managedChild)
+                return;
+            this.child = undefined;
+            this.failAll(new Error('CODEX_APP_SERVER_EXITED'));
+        });
+        await this.requestDirect('initialize', {
+            clientInfo: { name: 'codex_vscode', title: 'MyAgentRoam', version: '0.1.4' },
+            capabilities: { experimentalApi: true }
+        });
+        this.notify('initialized', {});
+    }
+    async restartManaged(lifecycleRevision) {
+        await Promise.resolve();
+        if (this.starting !== undefined)
+            await this.starting;
+        await this.waitForPendingRequests();
+        if (this.lifecycleRevision !== lifecycleRevision)
+            throw new Error('CODEX_APP_SERVER_STOPPED');
+        this.stopManaged();
+        await this.startManaged();
+    }
+    stop() {
+        this.lifecycleRevision += 1;
+        this.stopManaged();
+    }
+    async stopAndWait() {
+        const child = this.child;
+        if (child === undefined) {
+            this.stop();
+            return;
+        }
+        const exited = new Promise((resolve, reject) => {
+            if (child.exitCode !== null || child.signalCode !== null)
+                resolve();
+            else {
+                let forcedTimeout;
+                const onExit = () => {
+                    clearTimeout(timeout);
+                    if (forcedTimeout !== undefined)
+                        clearTimeout(forcedTimeout);
+                    resolve();
+                };
+                const timeout = setTimeout(() => {
+                    child.kill('SIGKILL');
+                    forcedTimeout = setTimeout(() => {
+                        child.off('exit', onExit);
+                        reject(new Error('CODEX_APP_SERVER_STOP_TIMEOUT'));
+                    }, 2_000);
+                }, 2_000);
+                child.once('exit', onExit);
+            }
+        });
+        this.stop();
+        await exited;
+    }
+    stopManaged() {
+        this.transport?.destroy();
+        this.transport = undefined;
+        this.child?.kill();
+        this.child = undefined;
+        this.failAll(new Error('CODEX_APP_SERVER_STOPPED'));
+    }
+    onNotification(listener) {
+        this.notifications.add(listener);
+        return () => this.notifications.delete(listener);
+    }
+    async request(method, params) {
+        if (this.restarting !== undefined)
+            await this.restarting;
+        else if (this.starting !== undefined)
+            await this.starting;
+        return this.requestDirect(method, params);
+    }
+    requestDirect(method, params) {
+        const transport = this.transport;
+        if (transport === undefined || !transport.writable)
+            throw new Error('CODEX_APP_SERVER_UNAVAILABLE');
+        const id = this.nextId++;
+        const timeoutMs = this.options.timeoutMs ?? REQUEST_TIMEOUT_MS;
+        const result = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                this.resolvePendingDrain();
+                reject(new Error('CODEX_APP_SERVER_TIMEOUT'));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+        });
+        transport.write(`${JSON.stringify({ method, id, params })}\n`);
+        return result;
+    }
+    waitForPendingRequests() {
+        if (this.pending.size === 0)
+            return Promise.resolve();
+        return new Promise((resolve) => this.pendingDrainWaiters.add(resolve));
+    }
+    resolvePendingDrain() {
+        if (this.pending.size !== 0)
+            return;
+        for (const resolve of this.pendingDrainWaiters)
+            resolve();
+        this.pendingDrainWaiters.clear();
+    }
+    notify(method, params) {
+        const transport = this.transport;
+        if (transport === undefined || !transport.writable)
+            throw new Error('CODEX_APP_SERVER_UNAVAILABLE');
+        transport.write(`${JSON.stringify({ method, params })}\n`);
+    }
+    respond(requestId, result) {
+        const transport = this.transport;
+        if (transport === undefined || !transport.writable)
+            throw new Error('CODEX_APP_SERVER_UNAVAILABLE');
+        transport.write(`${JSON.stringify({ id: requestId, result })}\n`);
+    }
+    startThread(cwd, configuration = {}) {
+        return this.request('thread/start', {
+            cwd,
+            experimentalRawEvents: true,
+            ...codexThreadConfiguration(cwd, configuration)
+        });
+    }
+    listThreads(params = {}) {
+        return this.request('thread/list', params);
+    }
+    readThread(threadId) {
+        return this.request('thread/read', { threadId, includeTurns: false });
+    }
+    listCollaborationModes() {
+        return this.request('collaborationMode/list', {});
+    }
+    listModels(params) {
+        return this.request('model/list', params);
+    }
+    forkThread(threadId, cwd, lastTurnId, configuration = {}) {
+        return this.request('thread/fork', {
+            threadId,
+            lastTurnId,
+            cwd,
+            ...codexThreadConfiguration(cwd, configuration)
+        });
+    }
+    revertThread(threadId, beforeTurnId) {
+        return this.request('thread/revert', { threadId, beforeTurnId });
+    }
+    listThreadTurns(threadId, input) {
+        return this.request('thread/turns/list', {
+            threadId,
+            ...input,
+            itemsView: 'full',
+            sortDirection: 'desc'
+        });
+    }
+    setThreadName(threadId, name) {
+        return this.request('thread/name/set', { threadId, name });
+    }
+    resumeThread(threadId, cwd, configuration = {}) {
+        return this.request('thread/resume', {
+            threadId,
+            cwd,
+            ...codexThreadConfiguration(cwd, configuration)
+        });
+    }
+    startTurn(threadId, text, cwd, configuration = {}, attachments = []) {
+        return this.request('turn/start', {
+            threadId,
+            cwd,
+            input: [{ type: 'text', text }, ...attachments],
+            ...codexTurnConfiguration(cwd, configuration)
+        });
+    }
+    steerTurn(threadId, expectedTurnId, text) {
+        return this.request('turn/steer', {
+            threadId,
+            expectedTurnId,
+            input: [{ type: 'text', text }]
+        });
+    }
+    interruptTurn(threadId, turnId) {
+        return this.request('turn/interrupt', { threadId, turnId });
+    }
+    handleLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if ((typeof message.id === 'number' || typeof message.id === 'string') &&
+            typeof message.method === 'string') {
+            for (const listener of this.notifications) {
+                listener({ method: message.method, params: message.params, requestId: message.id });
+            }
+            return;
+        }
+        if (typeof message.id === 'number') {
+            const pending = this.pending.get(message.id);
+            if (pending === undefined)
+                return;
+            clearTimeout(pending.timer);
+            this.pending.delete(message.id);
+            this.resolvePendingDrain();
+            if (message.error !== undefined) {
+                pending.reject(new CodexAppServerRpcError(isRecord(message.error) ? message.error : { message: String(message.error) }));
+            }
+            else {
+                pending.resolve(message.result);
+            }
+            return;
+        }
+        if (typeof message.method === 'string') {
+            for (const listener of this.notifications)
+                listener({ method: message.method, params: message.params });
+        }
+    }
+    failAll(error) {
+        for (const [id, pending] of this.pending) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+            this.pending.delete(id);
+        }
+        this.resolvePendingDrain();
+    }
+}
+function codexThreadConfiguration(cwd, configuration) {
+    return {
+        ...modelOption(configuration.model),
+        ...(configuration.developerInstructions === undefined
+            ? {}
+            : { developerInstructions: configuration.developerInstructions }),
+        ...(configuration.mcpServers === undefined
+            ? {}
+            : {
+                config: {
+                    mcp_servers: configuration.mcpServers
+                }
+            }),
+        ...codexPermissionConfiguration(cwd, configuration.access, 'thread')
+    };
+}
+function codexTurnConfiguration(cwd, configuration) {
+    const effort = typeof configuration.effort === 'string' && configuration.effort.trim().length > 0
+        ? configuration.effort
+        : null;
+    return {
+        ...modelOption(configuration.model),
+        ...(effort === null ? {} : { effort }),
+        ...(configuration.serviceTier === 'fast' ? { serviceTier: 'fast' } : {}),
+        ...(configuration.collaborationMode === undefined
+            ? {}
+            : {
+                collaborationMode: {
+                    mode: configuration.collaborationMode,
+                    settings: {
+                        model: configuration.model ?? 'gpt-5.6-sol',
+                        reasoningEffort: effort
+                    }
+                }
+            }),
+        ...codexPermissionConfiguration(cwd, configuration.access, 'turn')
+    };
+}
+function modelOption(model) {
+    return model === undefined || model === null ? {} : { model };
+}
+function codexPermissionConfiguration(cwd, access, phase) {
+    const sandbox = access === 'read-only'
+        ? 'read-only'
+        : access === 'workspace-write' || access === 'on-request'
+            ? 'workspace-write'
+            : access === 'full-access'
+                ? 'danger-full-access'
+                : undefined;
+    const approvalPolicy = access === 'workspace-write' || access === 'full-access' ? 'never' : 'on-request';
+    if (phase === 'thread')
+        return {
+            ...(sandbox === undefined ? {} : { sandbox }),
+            approvalPolicy
+        };
+    return {
+        ...(sandbox === undefined
+            ? {}
+            : {
+                sandboxPolicy: sandbox === 'read-only'
+                    ? { type: 'readOnly' }
+                    : sandbox === 'danger-full-access'
+                        ? { type: 'dangerFullAccess' }
+                        : { type: 'workspaceWrite', writableRoots: [cwd], networkAccess: true }
+            }),
+        approvalPolicy
+    };
+}
+export function probeCodex(command = 'codex') {
+    const invocation = platformCliInvocation(command, ['--version']);
+    const result = spawnSync(invocation.command, invocation.args, {
+        windowsHide: true,
+        env: minimalRunnerEnvironment(),
+        timeout: 3_000,
+        encoding: 'utf8'
+    });
+    if (result.status !== 0 || result.error !== undefined)
+        return { available: false, compatible: false };
+    const version = `${result.stdout}${result.stderr}`.trim().slice(0, 128);
+    return {
+        available: true,
+        ...(version.length === 0 ? {} : { version }),
+        // The CLI version is metadata only. Actual compatibility is established
+        // by the App Server initialize handshake when the client starts.
+        compatible: true
+    };
+}
+export async function probeCodexAsync(command = 'codex') {
+    const invocation = platformCliInvocation(command, ['--version']);
+    const result = await runRunnerProbe(invocation.command, invocation.args, {
+        env: minimalRunnerEnvironment(),
+        timeoutMs: 3_000
+    });
+    if (result.status !== 0)
+        return { available: false, compatible: false };
+    const version = `${result.stdout}${result.stderr}`.trim().slice(0, 128);
+    return {
+        available: true,
+        ...(version.length === 0 ? {} : { version }),
+        // Do not reject a newer CLI before its App Server has had a chance to
+        // negotiate the protocol it actually supports.
+        compatible: true
+    };
+}
+export function isSupportedCodexVersion(version) {
+    return version.trim().length > 0;
+}
+function defaultSpawn(command, args, options) {
+    const invocation = platformCliInvocation(command, args);
+    return spawn(invocation.command, invocation.args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: false,
+        windowsHide: true,
+        ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+        ...(options.env === undefined ? {} : { env: options.env })
+    });
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stdioTransport(child) {
+    return {
+        get writable() {
+            return child.stdin.writable;
+        },
+        write: (data) => child.stdin.write(data),
+        on: (event, listener) => child.stdout.on(event, listener),
+        once: (event, listener) => child.stdout.once(event, listener),
+        destroy: () => child.stdout.destroy()
+    };
+}

package/dist/runner/codex/conversation-parser.js

@@ -127,7 +127,7 @@ export class CodexUsageNormalizer {
     }
 }
 import { basename, extname } from 'node:path';
-import { runnerErrorProjection } from '../../util/runner-error.js';
+import { runnerErrorProjection } from '../runner-error.js';
 import { conversationImageAttachmentSchema } from '@myagentroam/protocol';
 import { parseCodexComposerImageMarkers } from './composer-image-markers.js';
 import { normalizeCodexTool } from './tool-normalizer.js';
@@ -1334,7 +1334,9 @@ export function isCodexImageBlock(value) {
         return false;
     return value.type === 'image' || value.type === 'input_image' || value.type === 'output_image';
 }
-import { compactRunnerText, compactRunnerValue, boundedConversationItemId, isCanonicalBase64, isPlainRecord, nativePageEnd } from '../../util/node-operation-parsers.js';
+import { compactRunnerText, compactRunnerValue, boundedConversationItemId, nativePageEnd } from '../normalization.js';
+import { isPlainRecord } from '../../util/records.js';
+import { isCanonicalBase64 } from '../../session/attachments.js';
 export function extractId(result, key) {
     if (typeof result === 'object' &&
         result !== null &&

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

@@ -2,12 +2,13 @@ import { NODE_MCP } from '../../mcp/naming.js';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { extractId } from './conversation-parser.js';
 import { normalizeCodexApproval } from './tool-normalizer.js';
-import { parseSecretEnvironment } from '../../util/secret-environment.js';
+import { parseSecretEnvironment } from '../../mcp/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
-import { runnerErrorProjection } from '../../util/runner-error.js';
+import { runnerErrorProjection } from '../runner-error.js';
 import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
 import { GenerationTimingTracker } from '../../service/generation-timing-tracker.js';
-import { boundedConversationItemId, compactRunnerText, isPlainRecord } from '../../util/node-operation-parsers.js';
+import { boundedConversationItemId, compactRunnerText } from '../normalization.js';
+import { isPlainRecord } from '../../util/records.js';
 import { codexImageAttachments, codexLiveConversationItem, codexSourceItemId, CodexUsageNormalizer, codexUserInputQuestions } from './conversation-parser.js';
 export function resolveCodexNotificationRun(runs, input) {
     const entries = [...runs.entries()];
@@ -107,7 +108,7 @@ export class CodexManagedRunController {
             externalSessionId: threadId,
             ...(initiatedByUserId === undefined ? {} : { initiatedByUserId })
         });
-        this.host.addActive(runId);
+        this.host.executionAccepted(runId);
         this.runner.execution.runs.set(runId, {
             sessionId: session.id,
             threadId,
@@ -131,7 +132,6 @@ export class CodexManagedRunController {
             this.usage.delete(runId);
             this.runner.execution.runs.delete(runId);
             this.runner.releaseEnvironment(runId);
-            this.host.removeActive(runId);
             throw error;
         }
     }
@@ -372,7 +372,6 @@ export class CodexManagedRunController {
                     this.runner.releaseEnvironment(runId);
                 else
                     void titleRefresh.finally(() => this.runner.releaseEnvironment(runId));
-                this.host.removeActive(runId);
                 this.finishing.delete(runId);
             };
             if (usage.hasRollout && turnId !== undefined) {
@@ -577,7 +576,7 @@ export class CodexManagedRunController {
             typeof payload.input !== 'string' ||
             typeof payload.cwd !== 'string' ||
             this.host.intercepted() ||
-            this.host.active.has(payload.runId))
+            this.host.isExecutionActive(payload.runId))
             return;
         const { runId, sessionId, input, cwd } = payload;
         let attachments;
@@ -619,7 +618,7 @@ export class CodexManagedRunController {
             this.host.emit(runId, 'run.rejected', { code: safeErrorCode(error, 'SECRET_ENVIRONMENT_INVALID') }, 'FAILED');
             return;
         }
-        this.host.addActive(runId);
+        this.host.executionAccepted(runId);
         void this.run({
             runId,
             sessionId,
@@ -739,7 +738,6 @@ export class CodexManagedRunController {
             this.usage.delete(runId);
             this.runner.execution.runs.delete(runId);
             this.runner.releaseEnvironment(runId);
-            this.host.removeActive(runId);
         }
     }
     emitError(runId, error, fallbackCode) {

package/dist/runner/codex/native-transcript.js

@@ -1,7 +1,7 @@
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { forEachJsonlRecord } from '../../native-jsonl-reader.js';
-import { compactRunnerValue as compactValue } from '../../util/node-operation-parsers.js';
+import { compactRunnerValue as compactValue } from '../normalization.js';
 import { stripGoalStartPrompt, publicGoalHistoryText } from '../../service/goal-runtime.js';
 import { parseCodexComposerImageMarkers } from './composer-image-markers.js';
 import { codexTranscriptSourceItemId } from './conversation-parser.js';

package/dist/runner/codex/tool-normalizer.js

@@ -1,4 +1,4 @@
-import { compactRunnerText } from '../../util/node-operation-parsers.js';
+import { compactRunnerText } from '../normalization.js';
 export function normalizeCodexApproval(method) {
     return method === 'item/commandExecution/requestApproval'
         ? { toolName: 'command_execution', reason: 'Command execution requires approval.' }

package/dist/runner/codex-runner.js

@@ -1,5 +1,5 @@
 import { withMarctlGuide } from '../mcp/marctl-guide.js';
-import { CodexAppServerClient, isCodexRolloutMissingError } from '../codex-app-server.js';
+import { CodexAppServerClient, isCodexRolloutMissingError } from './codex/codex-app-server.js';
 import { AbstractRunner } from './abstract-runner.js';
 import { declaredRunnerProfiles } from '../runner-profiles.js';
 import { homedir } from 'node:os';
@@ -7,12 +7,12 @@ import { resolve } from 'node:path';
 import { discoverAllNativeSessions } from '../native-session-history.js';
 import { readCodexNativeContextUsage } from './codex/native-context-usage.js';
 import { codexThreadCwd, extractCodexThreads } from './codex/conversation-parser.js';
-import { deduplicateDirectSessions, isWithinWorkspace, latestNativeActivity } from '../util/runner-native-session-parsers.js';
+import { deduplicateDirectSessions, isWithinWorkspace, latestNativeActivity } from '../session/runner-native-session-parsers.js';
 import { codexThreadHistoryModes, codexPaginatedThread, codexPaginatedCursor, codexPaginatedConversationPage } from './codex/conversation-parser.js';
-import { codexSessionControl } from '../codex-app-server.js';
+import { codexSessionControl } from './codex/codex-app-server.js';
 import { extractId } from './codex/conversation-parser.js';
 import { nodeLog } from '../operational.js';
-import { conversationClientMessageId } from '../util/conversation-identity.js';
+import { conversationClientMessageId } from '../session/conversation-identity.js';
 const CODEX_MODEL_CACHE_MS = 10 * 60 * 1_000;
 const CODEX_MODEL_FAILURE_RETRY_MS = 30 * 1_000;
 const CODEX_MODEL_PAGE_SIZE = 100;
@@ -245,40 +245,22 @@ export class CodexRunner extends AbstractRunner {
     usesRunnerTitleForRename() {
         return true;
     }
-    async renameNative(session, input, database) {
+    async renameNative(session, input) {
         if (session.externalSessionId === null)
             return;
         if (input.title !== undefined) {
             await this.start();
             await this.setThreadName(session.externalSessionId, input.title ?? '');
         }
-        database.saveNativeSessionMetadata({
-            runner: this.name,
-            externalSessionId: session.externalSessionId,
-            workspaceId: session.workspaceId,
-            ...(input.title === undefined ? {} : { runnerTitle: input.title }),
-            ...(input.title === undefined
-                ? {}
-                : { runnerTitlePending: input.title !== null && input.title.trim().length > 0 }),
-            ...(input.pinned === undefined ? {} : { pinned: input.pinned })
-        });
     }
-    projectedRunnerTitle(metadata, input, database) {
+    projectedRunnerTitle(metadata, input) {
         const cached = metadata?.runnerTitle ?? null;
         if (input.titleOrigin !== 'OFFICIAL' || input.title === undefined)
-            return cached ?? input.title ?? null;
+            return { title: cached ?? input.title ?? null, clearPending: false };
         if (metadata?.runnerTitlePending === true) {
-            if (input.title === cached)
-                database?.saveNativeSessionMetadata({
-                    runner: this.name,
-                    externalSessionId: input.externalSessionId,
-                    workspaceId: input.workspaceId,
-                    runnerTitle: cached,
-                    runnerTitlePending: false
-                });
-            return cached ?? input.title;
+            return { title: cached ?? input.title, clearPending: input.title === cached };
         }
-        return input.title;
+        return { title: input.title, clearPending: false };
     }
     async readConversationHistory(readers) {
         const page = await readers.official();

package/dist/runner/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/runner/mar-agent/conversation-normalizer.js

@@ -4,8 +4,8 @@ export function normalizeMarAgentUsage(usage) {
     const { executionId: _executionId, ...record } = usage;
     return { ...record, schemaVersion: 1, coverage: 'request' };
 }
-import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../../util/node-operation-parsers.js';
-import { runnerErrorProjection } from '../../util/runner-error.js';
+import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../normalization.js';
+import { runnerErrorProjection } from '../runner-error.js';
 import { toolPresentationSchema } from '@myagentroam/protocol';
 export class MarAgentConversationNormalizer {
     input(entry) {

package/dist/runner/mar-agent/history-projection.js

@@ -1,6 +1,6 @@
 import { MarAgentConversationNormalizer } from './conversation-normalizer.js';
 import { publicGoalHistoryText } from '../../service/goal-runtime.js';
-import { boundedConversationItemId } from '../../util/node-operation-parsers.js';
+import { boundedConversationItemId } from '../normalization.js';
 export function projectMarAgentHistory(session, entries, options = {}) {
     const turns = new Map();
     const normalizer = new MarAgentConversationNormalizer();