funolio-agent 1.0.53 → 1.1.65

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

@@ -0,0 +1,1468 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__codexAppServerTestUtils = exports.CodexAppServerManager = void 0;
+exports.getCodexAppServerManager = getCodexAppServerManager;
+exports.runCodexAppServerTurnForTest = runCodexAppServerTurnForTest;
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const runtime_context_1 = require("./runtime-context");
+const sync_cli_config_1 = require("./mcp/sync-cli-config");
+const managed_process_registry_1 = require("./managed-process-registry");
+const LOCAL_ONLY_ERROR = 'Codex app-server manager is local_desktop only';
+const CODEX_APP_SERVER_WARM_TIMEOUT_MS = 10_000;
+const DEFAULT_CODEX_SETTINGS = {
+    reasoningEffort: 'low',
+    reasoningSummary: 'detailed',
+    personality: 'friendly',
+    serviceTier: 'fast',
+    sandboxPolicy: 'danger-full-access',
+    approvalPolicy: 'never',
+};
+const VALID_CODEX_REASONING_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh']);
+const VALID_CODEX_REASONING_SUMMARIES = new Set(['auto', 'concise', 'detailed', 'none']);
+const VALID_CODEX_PERSONALITIES = new Set(['friendly', 'pragmatic']);
+const VALID_CODEX_SERVICE_TIERS = new Set(['fast', 'flex']);
+const VALID_CODEX_SANDBOX_POLICIES = new Set(['read-only', 'workspace-write', 'danger-full-access']);
+const VALID_CODEX_APPROVAL_POLICIES = new Set(['untrusted', 'on-failure', 'on-request', 'never']);
+let _manager = null;
+let _prepareCodexCliConfigChain = Promise.resolve();
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildAbortError() {
+    const err = new Error('Codex app-server turn aborted');
+    err.name = 'AbortError';
+    return err;
+}
+function throwIfNotLocalDesktop(runtimeMode) {
+    if (runtimeMode && !(0, runtime_context_1.isLocalDesktopRuntime)(runtimeMode)) {
+        throw new Error(LOCAL_ONLY_ERROR);
+    }
+}
+function sessionKey(conversationId, botId) {
+    return `${conversationId}::${botId}`;
+}
+function hasProcessExited(child) {
+    const exitCode = child?.exitCode;
+    const signalCode = child?.signalCode;
+    return ((exitCode !== null && exitCode !== undefined)
+        || (signalCode !== null && signalCode !== undefined));
+}
+function collectProcessRestartReasons(session, cwd, requestedEnvFingerprint, expectedThreadId) {
+    const reasons = [];
+    if (session.cwd !== cwd)
+        reasons.push('cwd_mismatch');
+    if (session.closed || hasProcessExited(session.child))
+        reasons.push('process_unhealthy');
+    if (session.envFingerprint !== requestedEnvFingerprint)
+        reasons.push('env_mismatch');
+    if (expectedThreadId && session.threadId && session.threadId !== expectedThreadId) {
+        reasons.push('incompatible_thread_request');
+    }
+    return reasons;
+}
+function buildWarmTimeoutError(timeoutMs) {
+    const err = new Error(`codex app-server warm session timed out after ${Math.floor(timeoutMs / 1000)}s`);
+    err.code = 'CODEX_APP_SERVER_WARM_TIMEOUT';
+    err.name = 'CodexAppServerWarmTimeoutError';
+    return err;
+}
+function withWarmTimeout(promise, timeoutMs, onTimeout) {
+    let timeout = null;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeout = setTimeout(() => {
+            try {
+                onTimeout();
+            }
+            finally {
+                reject(buildWarmTimeoutError(timeoutMs));
+            }
+        }, timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]).finally(() => {
+        if (timeout)
+            clearTimeout(timeout);
+    });
+}
+function createEventLog() {
+    return {
+        schema: 'funolio.codex-app-server.event-log@1',
+        events: [],
+    };
+}
+function appendEvent(eventLog, direction, kind, payload) {
+    if (!eventLog)
+        return;
+    eventLog.events.push({
+        ts: new Date().toISOString(),
+        direction,
+        kind,
+        payload,
+    });
+}
+function serializeEventLog(eventLog) {
+    return JSON.stringify(eventLog);
+}
+function normalizeDetail(text) {
+    return String(text || '').replace(/\s+/g, ' ').trim();
+}
+function isImportantLiveDetail(text) {
+    return /\b(ERROR|Error|failed|failure|Exit code:\s*[1-9]|authentication|rate limit|timeout|timed out|denied|unauthorized)\b/i.test(text);
+}
+function isGeneratedOrDependencyNoise(text) {
+    return (/\.map(?::|\b)/i.test(text)
+        || /(?:^|[\\/])node_modules[\\/]/i.test(text)
+        || /[\\/]?\.cargo[\\/]registry[\\/]/i.test(text)
+        || /src-tauri[\\/]gen[\\/]schemas/i.test(text)
+        || /\bpackage-lock\.json\b/i.test(text)
+        || /\bCargo\.lock\b/i.test(text)
+        || /\bdist[\\/]assets[\\/][^ ]+\.(?:js|css)\b/i.test(text));
+}
+function looksLikeMinifiedBlob(text) {
+    if (text.length < 1000)
+        return false;
+    const whitespaceCount = (text.match(/\s/g) || []).length;
+    const punctuationCount = (text.match(/[{}()[\],;:=]/g) || []).length;
+    return whitespaceCount / text.length < 0.08 && punctuationCount > 80;
+}
+function looksLikeRawSourceLine(text) {
+    return /^\s*(const|let|function|import|export|type|interface|class|return|if |for |while |case |await |async |try |catch|}\)|}}|\]|\)|\{)\b/.test(text);
+}
+function looksLikeSearchOutput(text) {
+    return /^(?:src|packages|prisma|scripts|public|app|C:\\|\.github)[\\/].*:\d+/.test(text)
+        || /^\s*[\w.\-/\\]+:\d+/.test(text);
+}
+function truncateLiveDetail(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    return `${text.slice(0, maxLength)} ...[truncated raw output]`;
+}
+function prepareLiveDetailForUser(activeTurn, detail, source) {
+    const normalized = normalizeDetail(detail);
+    if (!normalized)
+        return null;
+    if (source === 'status') {
+        return truncateLiveDetail(normalized, 600);
+    }
+    if (isImportantLiveDetail(normalized)) {
+        return truncateLiveDetail(normalized, 900);
+    }
+    if (isGeneratedOrDependencyNoise(normalized) || looksLikeMinifiedBlob(normalized)) {
+        return null;
+    }
+    if (looksLikeSearchOutput(normalized)) {
+        const count = activeTurn.liveDetailCategoryCounts.get('search_output') || 0;
+        activeTurn.liveDetailCategoryCounts.set('search_output', count + 1);
+        if (count >= 25)
+            return null;
+        return truncateLiveDetail(normalized, 500);
+    }
+    if (normalized.length > 1000) {
+        return null;
+    }
+    if ((source === 'command_output' || source === 'file_output') && looksLikeRawSourceLine(normalized)) {
+        const count = activeTurn.liveDetailCategoryCounts.get('raw_source_line') || 0;
+        activeTurn.liveDetailCategoryCounts.set('raw_source_line', count + 1);
+        if (count >= 40)
+            return null;
+    }
+    return truncateLiveDetail(normalized, 600);
+}
+function scrubCodexAppServerEnv(baseEnv, extraEnv, sessionKey) {
+    const env = {};
+    for (const [key, value] of Object.entries(baseEnv)) {
+        if (value == null)
+            continue;
+        if (key === 'CODEX_THREAD_ID')
+            continue;
+        if (key === 'FUNOLIO_TOOL_TODO_ID')
+            continue;
+        env[key] = value;
+    }
+    for (const [key, value] of Object.entries(extraEnv)) {
+        if (!value)
+            continue;
+        env[key] = value;
+    }
+    if (sessionKey) {
+        const marker = (0, managed_process_registry_1.getMarkerEnv)(sessionKey);
+        for (const [k, v] of Object.entries(marker)) {
+            env[k] = v;
+        }
+    }
+    return env;
+}
+const VOLATILE_ENV_KEYS = new Set(['FUNOLIO_TOOL_TODO_ID', 'FUNOLIO_MANAGED_SESSION']);
+function computeEnvFingerprint(env) {
+    return JSON.stringify(Object.entries(env)
+        .filter(([key, value]) => typeof value === 'string' && !VOLATILE_ENV_KEYS.has(key))
+        .sort(([a], [b]) => a.localeCompare(b)));
+}
+function buildCodexAppServerToolEnv(input) {
+    const env = {};
+    const actorId = input.botName?.trim() || input.botId.trim();
+    if (actorId)
+        env.FUNOLIO_TOOL_ACTOR_ID = actorId;
+    if (input.projectId !== undefined && input.projectId !== null)
+        env.FUNOLIO_TOOL_PROJECT_ID = String(input.projectId);
+    return env;
+}
+function buildTurnMcpToolEnv(sessionEnv, currentTodoTaskId) {
+    const toolEnv = {};
+    for (const k of ['FUNOLIO_TOOL_ACTOR_ID', 'FUNOLIO_TOOL_PROJECT_ID']) {
+        if (sessionEnv[k])
+            toolEnv[k] = sessionEnv[k];
+    }
+    if (currentTodoTaskId !== undefined && currentTodoTaskId !== null) {
+        toolEnv.FUNOLIO_TOOL_TODO_ID = String(currentTodoTaskId);
+    }
+    return toolEnv;
+}
+function extractLatestUserText(messages) {
+    const renderContent = (content) => (typeof content === 'string'
+        ? content
+        : content.map((part) => (part.type === 'text'
+            ? part.text
+            : `[image:${part.mimeType};${Math.ceil((part.data?.length || 0) * 0.75)} bytes]`)).join('\n'));
+    const lastMessage = messages.length > 0 ? messages[messages.length - 1] : null;
+    if (lastMessage?.role === 'user') {
+        return renderContent(lastMessage.content);
+    }
+    if (messages.length === 0)
+        return '';
+    const rendered = messages.map((message) => {
+        const label = message.role === 'user' ? 'USER'
+            : message.role === 'assistant' ? 'ASSISTANT'
+                : message.role === 'tool' ? `TOOL (${message.toolName || 'tool'})`
+                    : String(message.role || 'MESSAGE').toUpperCase();
+        return `${label}:\n${renderContent(message.content)}`;
+    });
+    return rendered.join('\n\n');
+}
+function buildCodexAppServerInput(messages) {
+    const lastMessage = messages.length > 0 ? messages[messages.length - 1] : null;
+    const content = lastMessage?.role === 'user' ? lastMessage.content : null;
+    // If the last user message has multimodal content, build image + text blocks
+    if (content && typeof content !== 'string') {
+        const blocks = [];
+        for (const part of content) {
+            if (part.type === 'text') {
+                blocks.push({ type: 'text', text: part.text });
+            }
+            else if (part.type === 'image' && part.data) {
+                blocks.push({
+                    type: 'image',
+                    url: `data:${part.mimeType || 'image/png'};base64,${part.data}`,
+                });
+            }
+        }
+        if (blocks.length > 0)
+            return blocks;
+    }
+    // Fallback: text-only
+    return [{ type: 'text', text: extractLatestUserText(messages) }];
+}
+function buildTurnUsage(tokenUsage) {
+    const last = tokenUsage?.last;
+    if (!last || typeof last !== 'object')
+        return undefined;
+    // token.txt Change 1: keep inputTokens sum + add breakdown.
+    const fresh = Number(last.inputTokens || 0);
+    const cacheRead = Number(last.cachedInputTokens || 0);
+    const inputTokens = fresh + cacheRead;
+    const outputTokens = Number(last.outputTokens || 0) + Number(last.reasoningOutputTokens || 0);
+    if (!Number.isFinite(inputTokens) || !Number.isFinite(outputTokens))
+        return undefined;
+    return {
+        inputTokens,
+        inputTokensFresh: fresh,
+        inputTokensCacheCreation: 0,
+        inputTokensCacheRead: cacheRead,
+        outputTokens,
+    };
+}
+function extractThreadId(payload) {
+    const id = payload?.thread?.id ?? payload?.threadId ?? null;
+    return typeof id === 'string' && id.trim() ? id.trim() : null;
+}
+function extractTurnId(payload) {
+    const id = payload?.turn?.id ?? payload?.turnId ?? null;
+    return typeof id === 'string' && id.trim() ? id.trim() : null;
+}
+function extractTurnStatus(payload) {
+    const status = payload?.turn?.status ?? null;
+    return typeof status === 'string' ? status : null;
+}
+function extractTurnFailureMessage(payload) {
+    const message = payload?.turn?.error?.message ?? payload?.error?.message ?? null;
+    return typeof message === 'string' && message.trim() ? message.trim() : null;
+}
+function isResponseMessage(value) {
+    return !!value && typeof value === 'object' && value.id !== undefined && ('result' in value || 'error' in value);
+}
+function isServerRequestMessage(value) {
+    return !!value && typeof value === 'object' && value.id !== undefined && typeof value.method === 'string';
+}
+function isNotificationMessage(value) {
+    return !!value && typeof value === 'object' && value.id === undefined && typeof value.method === 'string';
+}
+function isTurnMatch(activeTurn, params) {
+    if (!activeTurn)
+        return false;
+    if (activeTurn.threadId && params?.threadId && activeTurn.threadId !== params.threadId)
+        return false;
+    if (activeTurn.turnId && params?.turnId && activeTurn.turnId !== params.turnId)
+        return false;
+    return true;
+}
+function safeJsonParse(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function describeStartupStatus(params) {
+    const name = typeof params?.name === 'string' ? params.name : 'MCP server';
+    const status = typeof params?.status === 'string' ? params.status : 'unknown';
+    const error = typeof params?.error === 'string' && params.error.trim() ? ` (${params.error.trim()})` : '';
+    return `${name}: ${status}${error}`;
+}
+function extractItemId(params) {
+    const id = params?.item?.id ?? params?.itemId ?? null;
+    return typeof id === 'string' && id.trim() ? id.trim() : null;
+}
+function extractAgentMessagePhase(params) {
+    if (params?.item?.type !== 'agentMessage')
+        return null;
+    const phase = params?.item?.phase ?? null;
+    return typeof phase === 'string' && phase.trim() ? phase.trim().toLowerCase() : null;
+}
+function describeItemProgress(method, params) {
+    if (!params?.item || typeof params.item !== 'object')
+        return null;
+    const itemType = typeof params.item.type === 'string' ? params.item.type : 'item';
+    const label = typeof params.item.name === 'string' ? params.item.name
+        : typeof params.item.title === 'string' ? params.item.title
+            : typeof params.item.serverName === 'string' ? params.item.serverName
+                : typeof params.item.toolName === 'string' ? params.item.toolName
+                    : '';
+    const status = typeof params.item.status === 'string' ? ` (${params.item.status})`
+        : '';
+    const prefix = method === 'item/started' ? 'Started' : 'Completed';
+    return `${prefix} ${itemType}${label ? `: ${label}` : ''}${status}`;
+}
+/**
+ * Build a structured tool event from a Codex app-server item/started or
+ * item/completed notification, when the item type represents a tool-like
+ * operation. Returns null for non-tool items (e.g. agent_message, reasoning).
+ *
+ * Recognized tool item types:
+ *   - command_execution → shell command (PTY exec)
+ *   - file_change       → file edit / write / delete
+ *   - mcpToolCall       → MCP tool invocation
+ *   - applyPatch        → patch apply
+ */
+function buildToolEventFromItem(kind, params) {
+    const item = params?.item;
+    if (!item || typeof item !== 'object')
+        return null;
+    const itemType = typeof item.type === 'string' ? item.type : '';
+    const toolItemTypes = new Set([
+        'command_execution',
+        'file_change',
+        'mcpToolCall',
+        'mcp_tool_call',
+        'applyPatch',
+        'apply_patch',
+    ]);
+    if (!toolItemTypes.has(itemType))
+        return null;
+    const toolName = (typeof item.name === 'string' && item.name)
+        || (typeof item.toolName === 'string' && item.toolName)
+        || (typeof item.serverName === 'string' && item.serverName)
+        || itemType;
+    const toolCallId = (typeof item.id === 'string' && item.id)
+        || (typeof item.itemId === 'string' && item.itemId)
+        || `codex-${itemType}-${Date.now()}`;
+    const event = {
+        kind,
+        toolName,
+        toolCallId,
+    };
+    if (kind === 'call') {
+        if (item.command || item.input || item.arguments || item.path || item.changes) {
+            event.arguments = {
+                ...(item.command ? { command: item.command } : {}),
+                ...(item.input ? { input: item.input } : {}),
+                ...(item.arguments ? item.arguments : {}),
+                ...(item.path ? { path: item.path } : {}),
+                ...(item.changes ? { changes: item.changes } : {}),
+            };
+        }
+    }
+    else {
+        // result
+        const output = (typeof item.output === 'string' && item.output)
+            || (typeof item.stdout === 'string' && item.stdout)
+            || (typeof item.result === 'string' && item.result)
+            || '';
+        if (output)
+            event.output = output;
+        const status = typeof item.status === 'string' ? item.status.toLowerCase() : '';
+        event.isError = status === 'failed' || status === 'error' || !!item.error;
+    }
+    return event;
+}
+function normalizeCodexSettings(settings) {
+    const reasoningEffort = String(settings?.reasoningEffort || '').trim().toLowerCase();
+    const reasoningSummary = String(settings?.reasoningSummary || '').trim().toLowerCase();
+    const personality = String(settings?.personality || '').trim().toLowerCase();
+    const serviceTier = String(settings?.serviceTier || '').trim().toLowerCase();
+    const sandboxPolicy = String(settings?.sandboxPolicy || '').trim().toLowerCase();
+    const approvalPolicy = String(settings?.approvalPolicy || '').trim().toLowerCase();
+    return {
+        reasoningEffort: VALID_CODEX_REASONING_EFFORTS.has(reasoningEffort)
+            ? reasoningEffort
+            : DEFAULT_CODEX_SETTINGS.reasoningEffort,
+        reasoningSummary: VALID_CODEX_REASONING_SUMMARIES.has(reasoningSummary)
+            ? reasoningSummary
+            : DEFAULT_CODEX_SETTINGS.reasoningSummary,
+        personality: VALID_CODEX_PERSONALITIES.has(personality)
+            ? personality
+            : DEFAULT_CODEX_SETTINGS.personality,
+        serviceTier: VALID_CODEX_SERVICE_TIERS.has(serviceTier)
+            ? serviceTier
+            : DEFAULT_CODEX_SETTINGS.serviceTier,
+        sandboxPolicy: VALID_CODEX_SANDBOX_POLICIES.has(sandboxPolicy)
+            ? sandboxPolicy
+            : DEFAULT_CODEX_SETTINGS.sandboxPolicy,
+        approvalPolicy: VALID_CODEX_APPROVAL_POLICIES.has(approvalPolicy)
+            ? approvalPolicy
+            : DEFAULT_CODEX_SETTINGS.approvalPolicy,
+    };
+}
+function buildThreadSandbox(sandboxPolicy) {
+    switch (sandboxPolicy) {
+        case 'read-only':
+            return 'read-only';
+        case 'workspace-write':
+            return 'workspace-write';
+        default:
+            return 'danger-full-access';
+    }
+}
+function buildTurnSandboxPolicy(sandboxPolicy) {
+    switch (sandboxPolicy) {
+        case 'read-only':
+            return { type: 'readOnly' };
+        case 'workspace-write':
+            return { type: 'workspaceWrite' };
+        default:
+            return { type: 'dangerFullAccess' };
+    }
+}
+/**
+ * SHA-256 of the params that, together, define a unique Codex thread.
+ * If any of these inputs differ between warm-up and Send, the warmed
+ * thread is stale and must be invalidated so a fresh one is created
+ * with the current settings. systemPrompt is hashed rather than stored
+ * directly to avoid keeping a second copy of a potentially large string.
+ */
+function computeThreadBootstrapFingerprint(opts) {
+    const settings = normalizeCodexSettings(opts.codexSettings);
+    const parts = [
+        opts.systemPrompt || '',
+        opts.model || '',
+        settings.approvalPolicy,
+        settings.sandboxPolicy,
+        settings.personality,
+        settings.reasoningEffort,
+        settings.serviceTier,
+        opts.resumeSessionId || '',
+    ];
+    return (0, crypto_1.createHash)('sha256').update(parts.join('\u0000')).digest('hex');
+}
+function buildApprovalResponse(method, params) {
+    switch (method) {
+        case 'item/commandExecution/requestApproval':
+            return { decision: 'accept' };
+        case 'item/fileChange/requestApproval':
+            return { decision: 'accept' };
+        case 'item/permissions/requestApproval':
+            return { permissions: params?.permissions || {}, scope: 'session' };
+        case 'applyPatchApproval':
+            return { decision: 'approved' };
+        case 'execCommandApproval':
+            return { decision: 'approved' };
+        case 'item/tool/requestUserInput':
+            return { answers: {} };
+        case 'mcpServer/elicitation/request':
+            return { action: 'decline' };
+        default:
+            return null;
+    }
+}
+async function defaultPrepareCliConfig() {
+    _prepareCodexCliConfigChain = _prepareCodexCliConfigChain.then(async () => {
+        await (0, sync_cli_config_1.syncMcpToCliConfig)('codex-cli');
+    });
+    return _prepareCodexCliConfigChain;
+}
+class CodexAppServerManager {
+    sessions = new Map();
+    now;
+    spawnProcess;
+    prepareCliConfig;
+    logInfo;
+    logWarn;
+    clientInfo;
+    constructor(deps = {}) {
+        this.now = deps.now || (() => Date.now());
+        this.spawnProcess = deps.spawnProcess || ((command, args, options) => (0, child_process_1.spawn)(command, args, options));
+        this.prepareCliConfig = deps.prepareCliConfig || defaultPrepareCliConfig;
+        this.logInfo = deps.logInfo || ((message) => console.log(message));
+        this.logWarn = deps.logWarn || ((message) => console.warn(message));
+        this.clientInfo = deps.clientInfo || { name: 'funolio-agent', version: '1.1.5' };
+    }
+    async warmSession(opts) {
+        throwIfNotLocalDesktop(opts.runtimeMode);
+        const key = sessionKey(opts.conversationId, opts.botId);
+        const requestedEnv = scrubCodexAppServerEnv(process.env, buildCodexAppServerToolEnv({
+            botId: opts.botId,
+            botName: opts.botName,
+            projectId: opts.projectId,
+        }), key);
+        const requestedEnvFingerprint = computeEnvFingerprint(requestedEnv);
+        const wantsThreadBootstrap = typeof opts.systemPrompt === 'string' && opts.systemPrompt.length > 0;
+        let hiddenPrimerCompleted = false;
+        const requestedBootstrapFingerprint = wantsThreadBootstrap
+            ? computeThreadBootstrapFingerprint({
+                systemPrompt: opts.systemPrompt,
+                model: opts.model,
+                codexSettings: opts.codexSettings,
+                resumeSessionId: opts.resumeSessionId,
+            })
+            : null;
+        let session = this.sessions.get(key);
+        if (session
+            && (session.cwd !== opts.cwd
+                || session.closed
+                || session.envFingerprint !== requestedEnvFingerprint)) {
+            this.closeSession(key);
+            session = undefined;
+        }
+        if (session
+            && wantsThreadBootstrap
+            && session.threadId
+            && session.threadBootstrapFingerprint
+            && session.threadBootstrapFingerprint !== requestedBootstrapFingerprint) {
+            session.threadId = null;
+            session.threadBootstrapFingerprint = null;
+            session.bootstrapPromise = null;
+            session.warmPromise = null;
+            session.warmRequestedAtMs = null;
+            session.warmReadyAtMs = null;
+            session.bootstrapGeneration++;
+        }
+        const reusedExistingSession = !!session;
+        if (!session) {
+            session = await this.createSession(key, opts.cwd, requestedEnv, opts.currentTodoTaskId);
+            this.sessions.set(key, session);
+        }
+        // Fast path: session exists, handshake already complete, AND either
+        // (a) the caller didn't ask for a thread bootstrap, or (b) the thread
+        // is already bootstrapped with the current fingerprint.
+        const bootstrapAlreadyCorrect = !wantsThreadBootstrap
+            || (!!session.threadId && session.threadBootstrapFingerprint === requestedBootstrapFingerprint);
+        if (reusedExistingSession
+            && !session.warmPromise
+            && !session.warmReadyAtMs
+            && session.readyResolved
+            && bootstrapAlreadyCorrect) {
+            (0, managed_process_registry_1.markReused)(key);
+            return {
+                reusedExistingSession,
+                readyAgeMs: Math.max(0, this.now() - session.lastUsedAtMs),
+                sessionId: session.threadId || null,
+                hiddenPrimerCompleted: false,
+            };
+        }
+        if (!session.warmPromise && !session.warmReadyAtMs) {
+            session.warmRequestedAtMs = this.now();
+            session.warmPromise = withWarmTimeout((async () => {
+                await session.readyPromise;
+                if (session.closed) {
+                    throw new Error('Codex app-server warm session closed before it was ready');
+                }
+                if (wantsThreadBootstrap && !session.threadId && !session.bootstrapPromise) {
+                    session.bootstrapPromise = this.bootstrapWarmThread(session, opts, requestedBootstrapFingerprint);
+                    const primerMessages = Array.isArray(opts.primerMessages) && opts.primerMessages.length > 0
+                        ? opts.primerMessages
+                        : null;
+                    if (primerMessages) {
+                        session.bootstrapPromise = session.bootstrapPromise.then(async () => {
+                            if (!session || session.closed || !session.threadId)
+                                return;
+                            try {
+                                await this.runTurnInternal(session, {
+                                    runtimeMode: opts.runtimeMode,
+                                    conversationId: opts.conversationId,
+                                    botId: opts.botId,
+                                    botName: opts.botName,
+                                    cwd: opts.cwd,
+                                    systemPrompt: opts.systemPrompt || '',
+                                    messages: primerMessages,
+                                    model: opts.model || null,
+                                    projectId: opts.projectId,
+                                    currentTodoTaskId: opts.currentTodoTaskId,
+                                    codexSettings: {
+                                        ...(opts.codexSettings || {}),
+                                        reasoningEffort: 'low',
+                                        reasoningSummary: 'none',
+                                    },
+                                    resumeSessionId: null,
+                                }, {
+                                    skipBootstrapWait: true,
+                                    suppressSendPathLog: true,
+                                });
+                                hiddenPrimerCompleted = true;
+                                this.logInfo(`[cli-warm] codex hidden primer completed threadId=${JSON.stringify(session.threadId)}`);
+                            }
+                            catch (err) {
+                                this.logWarn(`[cli-warm] codex hidden primer failed: ${err?.message || String(err)}`);
+                            }
+                        });
+                    }
+                }
+                if (session.bootstrapPromise) {
+                    await session.bootstrapPromise;
+                    session.bootstrapPromise = null;
+                }
+                session.warmReadyAtMs = this.now();
+            })(), opts.timeoutMs ?? CODEX_APP_SERVER_WARM_TIMEOUT_MS, () => this.closeSession(key)).catch((err) => {
+                if (this.sessions.get(key) === session) {
+                    this.closeSession(key);
+                }
+                throw err;
+            });
+        }
+        await session.warmPromise;
+        return {
+            reusedExistingSession,
+            readyAgeMs: session.warmReadyAtMs ? Math.max(0, this.now() - session.warmReadyAtMs) : 0,
+            sessionId: session.threadId || null,
+            hiddenPrimerCompleted,
+        };
+    }
+    /**
+     * Issues thread/start (or thread/resume if resumeSessionId is provided)
+     * during warm-up, populating session.threadId so runTurn can skip the
+     * call. Failure leaves the session with no thread id — runTurn will
+     * retry from scratch via its normal path.
+     */
+    async bootstrapWarmThread(session, opts, fingerprint) {
+        const settings = normalizeCodexSettings(opts.codexSettings);
+        const gen = session.bootstrapGeneration;
+        const startMs = this.now();
+        const BOOTSTRAP_TIMEOUT_MS = 30_000;
+        try {
+            const rpcParams = opts.resumeSessionId
+                ? {
+                    threadId: opts.resumeSessionId,
+                    cwd: opts.cwd,
+                    developerInstructions: opts.systemPrompt || null,
+                    approvalPolicy: settings.approvalPolicy,
+                    sandbox: buildThreadSandbox(settings.sandboxPolicy),
+                    model: opts.model || null,
+                    personality: settings.personality,
+                    modelProvider: 'openai',
+                }
+                : {
+                    cwd: opts.cwd,
+                    developerInstructions: opts.systemPrompt || null,
+                    approvalPolicy: settings.approvalPolicy,
+                    sandbox: buildThreadSandbox(settings.sandboxPolicy),
+                    model: opts.model || null,
+                    personality: settings.personality,
+                    modelProvider: 'openai',
+                    ephemeral: false,
+                };
+            const method = opts.resumeSessionId ? 'thread/resume' : 'thread/start';
+            const response = await Promise.race([
+                this.sendRequest(session, method, rpcParams),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Thread bootstrap timed out')), BOOTSTRAP_TIMEOUT_MS)),
+            ]);
+            if (session.bootstrapGeneration !== gen)
+                return;
+            session.threadId = extractThreadId(response);
+            session.threadBootstrapFingerprint = fingerprint;
+            this.logInfo(`[cli-warm] codex thread bootstrap completed in ${this.now() - startMs}ms threadId=${JSON.stringify(session.threadId)}`);
+        }
+        catch (err) {
+            if (session.bootstrapGeneration !== gen)
+                return;
+            session.threadId = null;
+            session.threadBootstrapFingerprint = null;
+            this.logWarn(`[cli-warm] codex thread bootstrap failed: ${err?.message || String(err)}`);
+        }
+    }
+    async runTurn(opts) {
+        throwIfNotLocalDesktop(opts.runtimeMode);
+        const key = sessionKey(opts.conversationId, opts.botId);
+        const requestedEnv = scrubCodexAppServerEnv(process.env, buildCodexAppServerToolEnv({
+            botId: opts.botId,
+            botName: opts.botName,
+            projectId: opts.projectId,
+        }), key);
+        const requestedEnvFingerprint = computeEnvFingerprint(requestedEnv);
+        let session = this.sessions.get(key);
+        const expectedThreadId = opts.forceFreshSession ? null : (opts.resumeSessionId || null);
+        const restartReasons = session
+            ? collectProcessRestartReasons(session, opts.cwd, requestedEnvFingerprint, expectedThreadId)
+            : [];
+        if (session && restartReasons.length > 0) {
+            this.logInfo(`[codex-app-server] codex_process_restarted conversationId=${JSON.stringify(opts.conversationId)} botId=${JSON.stringify(opts.botId)} pid=${session.child.pid ?? 'unknown'} reasons=${JSON.stringify(restartReasons)} requestedThreadId=${JSON.stringify(expectedThreadId)} existingThreadId=${JSON.stringify(session.threadId)}`);
+            this.closeSession(key);
+            session = undefined;
+        }
+        // Stale warm-thread invalidation. If warmSession bootstrapped a thread
+        // with a different systemPrompt / model / settings than this turn is
+        // using, the thread is wrong and must be discarded. Keeping the
+        // session + handshake alive; only the threadId is cleared so the
+        // existing "no thread → create one" branch of runTurnInternal fires.
+        if (session && session.threadId && session.threadBootstrapFingerprint) {
+            const currentFingerprint = computeThreadBootstrapFingerprint({
+                systemPrompt: opts.systemPrompt,
+                model: opts.model,
+                codexSettings: opts.codexSettings,
+                resumeSessionId: opts.forceFreshSession ? null : (opts.resumeSessionId || null),
+            });
+            if (currentFingerprint !== session.threadBootstrapFingerprint) {
+                session.threadId = null;
+                session.threadBootstrapFingerprint = null;
+                session.bootstrapPromise = null;
+                session.bootstrapGeneration++;
+            }
+        }
+        if (session?.warmPromise) {
+            try {
+                await session.warmPromise;
+                this.logInfo(`[cli-warm] warm_reused conversationId=${JSON.stringify(opts.conversationId)} botId=${JSON.stringify(opts.botId)} provider="codex-cli" ageMs=${session.warmReadyAtMs ? this.now() - session.warmReadyAtMs : 0}`);
+                session.warmPromise = null;
+                session.warmRequestedAtMs = null;
+                session.warmReadyAtMs = null;
+            }
+            catch {
+                if (this.sessions.get(key) === session) {
+                    this.closeSession(key);
+                }
+                session = undefined;
+            }
+        }
+        else if (session?.warmReadyAtMs) {
+            this.logInfo(`[cli-warm] warm_reused conversationId=${JSON.stringify(opts.conversationId)} botId=${JSON.stringify(opts.botId)} provider="codex-cli" ageMs=${this.now() - session.warmReadyAtMs}`);
+            session.warmPromise = null;
+            session.warmRequestedAtMs = null;
+            session.warmReadyAtMs = null;
+        }
+        if (!session) {
+            this.logInfo(`[cli-warm] send_cold conversationId=${JSON.stringify(opts.conversationId)} botId=${JSON.stringify(opts.botId)} provider="codex-cli"`);
+            session = await this.createSession(key, opts.cwd, requestedEnv, opts.currentTodoTaskId);
+            this.sessions.set(key, session);
+        }
+        else {
+            (0, managed_process_registry_1.markReused)(key);
+            this.logInfo(`[codex-app-server] codex_process_reuse conversationId=${JSON.stringify(opts.conversationId)} botId=${JSON.stringify(opts.botId)} pid=${session.child.pid ?? 'unknown'} forceFreshSession=${opts.forceFreshSession ? 'true' : 'false'} threadId=${JSON.stringify(session.threadId)}`);
+        }
+        const run = async () => this.runTurnInternal(session, opts);
+        const queued = session.chain.then(run, run);
+        session.chain = queued.then(() => undefined, () => undefined);
+        return queued;
+    }
+    hasActiveSession(conversationId, botId) {
+        const session = this.sessions.get(sessionKey(conversationId, botId));
+        return !!session && !session.closed;
+    }
+    closeSessionByConversation(conversationId, botId) {
+        this.closeSession(sessionKey(conversationId, botId));
+    }
+    closeSessionsByConversation(conversationId) {
+        const prefix = `${conversationId}::`;
+        let closed = 0;
+        for (const key of [...this.sessions.keys()]) {
+            if (key.startsWith(prefix)) {
+                this.closeSession(key);
+                closed++;
+            }
+        }
+        return closed;
+    }
+    closeWarmSessionsByConversation(conversationId) {
+        const prefix = `${conversationId}::`;
+        let closed = 0;
+        for (const [key, session] of [...this.sessions.entries()]) {
+            if (key.startsWith(prefix) && (session.warmPromise || session.warmReadyAtMs)) {
+                this.closeSession(key);
+                closed++;
+            }
+        }
+        return closed;
+    }
+    closeSessionsByBotId(botId) {
+        const suffix = `::${botId}`;
+        for (const key of [...this.sessions.keys()]) {
+            if (key.endsWith(suffix)) {
+                this.closeSession(key);
+            }
+        }
+    }
+    closeAll() {
+        for (const key of [...this.sessions.keys()]) {
+            this.closeSession(key);
+        }
+    }
+    closeSessionByKey(key) {
+        this.closeSession(key);
+    }
+    closeSession(key) {
+        const session = this.sessions.get(key);
+        if (!session)
+            return;
+        session.closed = true;
+        session.bootstrapPromise = null;
+        session.bootstrapGeneration++;
+        const pid = session.child.pid;
+        let closeFailed = false;
+        if (pid) {
+            const killResult = (0, managed_process_registry_1.killProcessTreeDetailed)(pid);
+            closeFailed = !killResult.killed || !!killResult.error;
+        }
+        else {
+            try {
+                session.child.kill();
+            }
+            catch {
+                closeFailed = true;
+            }
+        }
+        for (const pending of session.pendingRequests.values()) {
+            pending.reject(new Error('Codex app-server session closed'));
+        }
+        session.pendingRequests.clear();
+        if (session.activeTurn) {
+            session.activeTurn.rejectCompletion(new Error('Codex app-server session closed during active turn'));
+            session.activeTurn = null;
+        }
+        this.sessions.delete(key);
+        (0, managed_process_registry_1.unregisterProcess)(key, false, closeFailed);
+    }
+    async createSession(key, cwd, env, currentTodoTaskId) {
+        // Serialize config-write + spawn as an atomic unit through the global
+        // chain so concurrent Codex sessions can't interleave config.toml writes.
+        // Codex reads config.toml at startup to discover MCP servers and their env,
+        // so the write must complete before spawn AND no other write can happen
+        // between this write and the spawned process reading its config.
+        const toolEnv = buildTurnMcpToolEnv(env, currentTodoTaskId);
+        const child = await new Promise((resolve, reject) => {
+            _prepareCodexCliConfigChain = _prepareCodexCliConfigChain.then(async () => {
+                await (0, sync_cli_config_1.syncMcpToCliConfig)('codex-cli', toolEnv);
+                resolve(this.spawnProcess(process.platform === 'win32' ? 'codex' : 'codex', ['app-server'], {
+                    stdio: 'pipe',
+                    shell: process.platform === 'win32',
+                    windowsHide: true,
+                    cwd,
+                    env: env,
+                }));
+            }).catch(reject);
+        });
+        const session = {
+            key,
+            cwd,
+            env,
+            envFingerprint: computeEnvFingerprint(env),
+            child,
+            stdoutCarry: '',
+            createdAtMs: this.now(),
+            lastUsedAtMs: this.now(),
+            nextRequestId: 1,
+            pendingRequests: new Map(),
+            activeTurn: null,
+            threadId: null,
+            readyPromise: Promise.resolve(),
+            readyResolved: false,
+            warmPromise: null,
+            warmRequestedAtMs: null,
+            warmReadyAtMs: null,
+            threadBootstrapFingerprint: null,
+            bootstrapPromise: null,
+            bootstrapGeneration: 0,
+            closed: false,
+            chain: Promise.resolve(),
+        };
+        if (child.pid) {
+            this.logInfo(`[codex-app-server] spawned key=${key} pid=${child.pid} cwd=${cwd}`);
+            const keyParts = key.split('::');
+            (0, managed_process_registry_1.registerProcess)({
+                sessionKey: key,
+                provider: 'codex-app-server',
+                conversationId: keyParts[0] || '',
+                botId: keyParts[1] || '',
+                pid: child.pid,
+                cwd,
+                createdAt: new Date(session.createdAtMs).toISOString(),
+                lastUsedAt: new Date(session.lastUsedAtMs).toISOString(),
+            });
+        }
+        child.stdout.on('data', (chunk) => {
+            this.handleStdout(session, chunk.toString());
+        });
+        child.stderr.on('data', (chunk) => {
+            this.handleStderr(session, chunk.toString());
+        });
+        child.on('error', (err) => {
+            this.handleProcessError(session, err);
+        });
+        child.on('close', (code, signal) => {
+            this.handleProcessClose(session, code, signal);
+        });
+        session.readyPromise = this.initializeSession(session);
+        return session;
+    }
+    async initializeSession(session) {
+        await this.sendRequest(session, 'initialize', {
+            clientInfo: this.clientInfo,
+        });
+        this.sendNotification(session, 'initialized');
+        session.readyResolved = true;
+    }
+    syncTurnMcpConfig(session, currentTodoTaskId) {
+        const toolEnv = buildTurnMcpToolEnv(session.env, currentTodoTaskId);
+        _prepareCodexCliConfigChain = _prepareCodexCliConfigChain.then(async () => {
+            await (0, sync_cli_config_1.syncMcpToCliConfig)('codex-cli', toolEnv);
+        });
+        return _prepareCodexCliConfigChain;
+    }
+    async runTurnInternal(session, opts, internalOpts) {
+        await session.readyPromise;
+        session.lastUsedAtMs = this.now();
+        (0, managed_process_registry_1.updateLastUsed)(session.key);
+        (0, managed_process_registry_1.markTurnStarted)(session.key, 'codex_turn');
+        const codexSettings = normalizeCodexSettings(opts.codexSettings);
+        await this.syncTurnMcpConfig(session, opts.currentTodoTaskId);
+        const eventLog = createEventLog();
+        const completionPromise = new Promise((resolve, reject) => {
+            const activeTurn = {
+                threadId: session.threadId,
+                turnId: null,
+                finalContent: '',
+                thinkingText: '',
+                commentaryItemIds: new Set(),
+                commentaryTextByItemId: new Map(),
+                lastCommentaryText: '',
+                done: false,
+                aborted: false,
+                callbackChain: Promise.resolve(),
+                detailFingerprints: new Set(),
+                liveDetailCategoryCounts: new Map(),
+                eventLog,
+                onChunk: opts.onChunk,
+                onCommentary: opts.onCommentary,
+                onThinkingChunk: opts.onThinkingChunk,
+                onDetail: opts.onDetail,
+                onToolEvent: opts.onToolEvent,
+                resolveCompletion: resolve,
+                rejectCompletion: reject,
+            };
+            session.activeTurn = activeTurn;
+        });
+        const activeTurn = session.activeTurn;
+        const abortHandler = async () => {
+            activeTurn.aborted = true;
+            if (activeTurn.turnId) {
+                try {
+                    await this.sendRequest(session, 'turn/interrupt', { turnId: activeTurn.turnId });
+                }
+                catch {
+                    // best effort; close handler will reject if needed
+                }
+            }
+            activeTurn.rejectCompletion(buildAbortError());
+            session.activeTurn = null;
+        };
+        opts.abortSignal?.addEventListener('abort', abortHandler, { once: true });
+        try {
+            const requestedThreadId = opts.forceFreshSession ? null : (opts.resumeSessionId || null);
+            if (opts.forceFreshSession) {
+                const hasWarmBootstrap = !!session.threadBootstrapFingerprint || !!session.bootstrapPromise;
+                if (!hasWarmBootstrap) {
+                    session.threadId = null;
+                    session.bootstrapPromise = null;
+                    session.bootstrapGeneration++;
+                }
+            }
+            let awaitedBootstrap = false;
+            let bootstrapTimedOut = false;
+            if (!internalOpts?.skipBootstrapWait && session.bootstrapPromise) {
+                awaitedBootstrap = true;
+                try {
+                    await session.bootstrapPromise;
+                }
+                catch {
+                    bootstrapTimedOut = true;
+                }
+                session.bootstrapPromise = null;
+            }
+            let coldThreadCreated = false;
+            if (!session.threadId) {
+                if (requestedThreadId) {
+                    const response = await this.sendRequest(session, 'thread/resume', {
+                        threadId: requestedThreadId,
+                        cwd: opts.cwd,
+                        developerInstructions: opts.systemPrompt || null,
+                        approvalPolicy: codexSettings.approvalPolicy,
+                        sandbox: buildThreadSandbox(codexSettings.sandboxPolicy),
+                        model: opts.model || null,
+                        personality: codexSettings.personality,
+                        modelProvider: 'openai',
+                    });
+                    session.threadId = extractThreadId(response);
+                    coldThreadCreated = true;
+                }
+                else {
+                    const response = await this.sendRequest(session, 'thread/start', {
+                        cwd: opts.cwd,
+                        developerInstructions: opts.systemPrompt || null,
+                        approvalPolicy: codexSettings.approvalPolicy,
+                        sandbox: buildThreadSandbox(codexSettings.sandboxPolicy),
+                        model: opts.model || null,
+                        personality: codexSettings.personality,
+                        modelProvider: 'openai',
+                        ephemeral: false,
+                    });
+                    session.threadId = extractThreadId(response);
+                    coldThreadCreated = true;
+                }
+            }
+            if (!internalOpts?.suppressSendPathLog) {
+                if (bootstrapTimedOut) {
+                    this.logInfo(`[cli-warm] send_path=bootstrap_timeout fallback=cold`);
+                }
+                else if (awaitedBootstrap && session.threadId && !coldThreadCreated) {
+                    this.logInfo(`[cli-warm] send_path=waited_on_warm`);
+                }
+                else if (session.threadId && !awaitedBootstrap && !coldThreadCreated) {
+                    this.logInfo(`[cli-warm] send_path=reused_warm_thread`);
+                }
+                else {
+                    this.logInfo(`[cli-warm] send_path=cold_start`);
+                }
+            }
+            if (session.threadId && !coldThreadCreated) {
+                const reuseMode = awaitedBootstrap
+                    ? 'awaited_bootstrap'
+                    : session.threadBootstrapFingerprint
+                        ? 'warm_bootstrap'
+                        : 'existing_thread';
+                this.logInfo(`[codex-app-server] codex_thread_reuse conversationId=${JSON.stringify(opts.conversationId)} botId=${JSON.stringify(opts.botId)} threadId=${JSON.stringify(session.threadId)} mode=${reuseMode} forceFreshSession=${opts.forceFreshSession ? 'true' : 'false'}`);
+            }
+            const threadId = session.threadId;
+            if (!threadId) {
+                throw new Error('Codex app-server did not return a thread id');
+            }
+            activeTurn.threadId = threadId;
+            const turnStartParams = {
+                threadId,
+                cwd: opts.cwd,
+                approvalPolicy: codexSettings.approvalPolicy,
+                effort: codexSettings.reasoningEffort,
+                sandboxPolicy: buildTurnSandboxPolicy(codexSettings.sandboxPolicy),
+                personality: codexSettings.personality,
+                input: buildCodexAppServerInput(opts.messages),
+                model: opts.model || null,
+                serviceTier: codexSettings.serviceTier,
+            };
+            if (codexSettings.reasoningSummary && codexSettings.reasoningSummary !== 'none') {
+                turnStartParams.summary = codexSettings.reasoningSummary;
+            }
+            const turnStartResponse = await this.sendRequest(session, 'turn/start', turnStartParams);
+            activeTurn.turnId = extractTurnId(turnStartResponse);
+            (0, managed_process_registry_1.markTurnActivity)(session.key, 'codex_turn_started');
+            return await completionPromise;
+        }
+        finally {
+            opts.abortSignal?.removeEventListener('abort', abortHandler);
+            (0, managed_process_registry_1.markTurnFinished)(session.key, 'codex_turn_finished');
+        }
+    }
+    sendNotification(session, method, params) {
+        const payload = params === undefined
+            ? { jsonrpc: '2.0', method }
+            : { jsonrpc: '2.0', method, params };
+        appendEvent(session.activeTurn?.eventLog, 'out', 'notification', payload);
+        session.child.stdin.write(`${JSON.stringify(payload)}\n`);
+    }
+    sendResponse(session, id, result, error) {
+        const payload = error
+            ? { jsonrpc: '2.0', id, error }
+            : { jsonrpc: '2.0', id, result };
+        appendEvent(session.activeTurn?.eventLog, 'out', 'response', payload);
+        session.child.stdin.write(`${JSON.stringify(payload)}\n`);
+    }
+    sendRequest(session, method, params) {
+        if (session.closed) {
+            return Promise.reject(new Error('Codex app-server session is closed'));
+        }
+        const id = session.nextRequestId++;
+        const payload = params === undefined
+            ? { jsonrpc: '2.0', id, method }
+            : { jsonrpc: '2.0', id, method, params };
+        appendEvent(session.activeTurn?.eventLog, 'out', 'request', payload);
+        return new Promise((resolve, reject) => {
+            session.pendingRequests.set(id, { method, resolve, reject });
+            session.child.stdin.write(`${JSON.stringify(payload)}\n`);
+        });
+    }
+    handleStdout(session, chunk) {
+        if (chunk)
+            (0, managed_process_registry_1.markTurnActivity)(session.key, 'codex_stdout');
+        session.stdoutCarry += chunk;
+        const lines = session.stdoutCarry.split(/\r?\n/);
+        session.stdoutCarry = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const parsed = safeJsonParse(trimmed);
+            if (!parsed) {
+                appendEvent(session.activeTurn?.eventLog, 'in', 'parse_error', trimmed);
+                this.logWarn(`[codex-app-server] Non-JSON stdout line: ${trimmed}`);
+                continue;
+            }
+            if (isResponseMessage(parsed)) {
+                appendEvent(session.activeTurn?.eventLog, 'in', 'response', parsed);
+                this.handleResponse(session, parsed);
+                continue;
+            }
+            if (isServerRequestMessage(parsed)) {
+                appendEvent(session.activeTurn?.eventLog, 'in', 'server_request', parsed);
+                void this.handleServerRequest(session, parsed);
+                continue;
+            }
+            if (isNotificationMessage(parsed)) {
+                appendEvent(session.activeTurn?.eventLog, 'in', 'notification', parsed);
+                void this.handleNotification(session, parsed);
+                continue;
+            }
+            appendEvent(session.activeTurn?.eventLog, 'in', 'parse_error', parsed);
+            this.logWarn('[codex-app-server] Unrecognized stdout payload');
+        }
+    }
+    handleResponse(session, message) {
+        const pending = session.pendingRequests.get(message.id);
+        if (!pending)
+            return;
+        session.pendingRequests.delete(message.id);
+        if (message.error) {
+            pending.reject(new Error(`${pending.method} failed: ${message.error.message || 'Unknown error'}`));
+            return;
+        }
+        pending.resolve(message.result);
+    }
+    async handleServerRequest(session, message) {
+        const approvalResponse = buildApprovalResponse(message.method, message.params);
+        if (approvalResponse !== null) {
+            await this.emitDetail(session.activeTurn, `Auto-handled ${message.method}`);
+            this.sendResponse(session, message.id, approvalResponse);
+            return;
+        }
+        this.sendResponse(session, message.id, undefined, {
+            code: -32601,
+            message: `Unsupported server request: ${message.method}`,
+        });
+    }
+    async handleNotification(session, message) {
+        const params = message.params || {};
+        if (message.method === 'thread/started') {
+            const threadId = extractThreadId(params);
+            if (threadId) {
+                session.threadId = threadId;
+                if (session.activeTurn)
+                    session.activeTurn.threadId = threadId;
+            }
+            return;
+        }
+        if (message.method === 'turn/started') {
+            const turnId = extractTurnId(params);
+            if (session.activeTurn && turnId) {
+                session.activeTurn.turnId = turnId;
+            }
+            return;
+        }
+        if (message.method === 'thread/tokenUsage/updated' && isTurnMatch(session.activeTurn, params)) {
+            const usage = buildTurnUsage(params.tokenUsage);
+            if (usage && session.activeTurn) {
+                session.activeTurn.usage = usage;
+            }
+            return;
+        }
+        if (message.method === 'item/agentMessage/delta' && isTurnMatch(session.activeTurn, params) && session.activeTurn) {
+            const delta = typeof params.delta === 'string' ? params.delta : '';
+            const itemId = extractItemId(params);
+            if (delta) {
+                if (itemId && session.activeTurn.commentaryItemIds.has(itemId)) {
+                    const existing = session.activeTurn.commentaryTextByItemId.get(itemId) || '';
+                    session.activeTurn.commentaryTextByItemId.set(itemId, existing + delta);
+                    return;
+                }
+                session.activeTurn.finalContent += delta;
+                await this.emitChunk(session.activeTurn, delta);
+            }
+            return;
+        }
+        if (message.method === 'item/reasoning/summaryTextDelta' && isTurnMatch(session.activeTurn, params) && session.activeTurn) {
+            const delta = typeof params.delta === 'string' ? params.delta : '';
+            if (delta) {
+                session.activeTurn.thinkingText += delta;
+                await this.emitThinkingChunk(session.activeTurn, delta);
+            }
+            return;
+        }
+        if (message.method === 'item/commandExecution/outputDelta' && isTurnMatch(session.activeTurn, params)) {
+            const delta = typeof params.delta === 'string' ? params.delta : '';
+            if (delta) {
+                await this.emitDetail(session.activeTurn, delta, 'command_output');
+            }
+            return;
+        }
+        if (message.method === 'item/fileChange/outputDelta' && isTurnMatch(session.activeTurn, params)) {
+            const delta = typeof params.delta === 'string' ? params.delta : '';
+            if (delta) {
+                await this.emitDetail(session.activeTurn, delta, 'file_output');
+            }
+            return;
+        }
+        if (message.method === 'item/mcpToolCall/progress' && isTurnMatch(session.activeTurn, params)) {
+            if (typeof params.message === 'string') {
+                await this.emitDetail(session.activeTurn, params.message, 'mcp_progress');
+            }
+            return;
+        }
+        if (message.method === 'mcpServer/startupStatus/updated') {
+            const detail = describeStartupStatus(params);
+            if (detail)
+                await this.emitDetail(session.activeTurn, detail);
+            return;
+        }
+        if (message.method === 'item/started' && isTurnMatch(session.activeTurn, params)) {
+            const commentaryItemId = extractItemId(params);
+            if (session.activeTurn && commentaryItemId && extractAgentMessagePhase(params) === 'commentary') {
+                session.activeTurn.commentaryItemIds.add(commentaryItemId);
+                session.activeTurn.commentaryTextByItemId.set(commentaryItemId, '');
+                return;
+            }
+            // Emit structured tool call event for tool-like items (command_execution,
+            // file_change, mcpToolCall, applyPatch). Also emit a textual detail line
+            // for the live activity log.
+            const toolEvent = buildToolEventFromItem('call', params);
+            if (toolEvent && session.activeTurn?.onToolEvent) {
+                try {
+                    await session.activeTurn.onToolEvent(toolEvent);
+                }
+                catch { /* swallow */ }
+            }
+            const detail = describeItemProgress(message.method, params);
+            if (detail)
+                await this.emitDetail(session.activeTurn, detail);
+            return;
+        }
+        if (message.method === 'item/completed' && isTurnMatch(session.activeTurn, params)) {
+            const commentaryItemId = extractItemId(params);
+            if (session.activeTurn && commentaryItemId && session.activeTurn.commentaryItemIds.has(commentaryItemId)) {
+                const completedText = (typeof params?.item?.text === 'string' && params.item.text)
+                    || session.activeTurn.commentaryTextByItemId.get(commentaryItemId)
+                    || '';
+                session.activeTurn.commentaryItemIds.delete(commentaryItemId);
+                session.activeTurn.commentaryTextByItemId.delete(commentaryItemId);
+                await this.emitCommentary(session.activeTurn, completedText);
+                return;
+            }
+            // Emit structured tool result event for tool-like items.
+            const toolEvent = buildToolEventFromItem('result', params);
+            if (toolEvent && session.activeTurn?.onToolEvent) {
+                try {
+                    await session.activeTurn.onToolEvent(toolEvent);
+                }
+                catch { /* swallow */ }
+            }
+            const detail = describeItemProgress(message.method, params);
+            if (detail)
+                await this.emitDetail(session.activeTurn, detail);
+            return;
+        }
+        if (message.method === 'turn/completed' && isTurnMatch(session.activeTurn, params) && session.activeTurn) {
+            const activeTurn = session.activeTurn;
+            activeTurn.done = true;
+            try {
+                await activeTurn.callbackChain;
+            }
+            catch {
+                // Callback failures are already logged by the emit helpers.
+            }
+            const status = extractTurnStatus(params);
+            if (status === 'failed') {
+                const messageText = extractTurnFailureMessage(params) || 'Codex app-server turn failed';
+                session.activeTurn = null;
+                activeTurn.rejectCompletion(new Error(messageText));
+                return;
+            }
+            if (status === 'interrupted' && activeTurn.aborted) {
+                session.activeTurn = null;
+                activeTurn.rejectCompletion(buildAbortError());
+                return;
+            }
+            const result = {
+                content: activeTurn.finalContent.trim(),
+                sessionId: session.threadId,
+                usage: activeTurn.usage,
+                rawOutput: serializeEventLog(activeTurn.eventLog),
+                eventLog: activeTurn.eventLog,
+                thinking: activeTurn.thinkingText || undefined,
+            };
+            session.activeTurn = null;
+            activeTurn.resolveCompletion(result);
+        }
+    }
+    handleStderr(session, chunk) {
+        if (chunk)
+            (0, managed_process_registry_1.markTurnActivity)(session.key, 'codex_stderr');
+        appendEvent(session.activeTurn?.eventLog, 'stderr', 'stderr', chunk);
+        void this.emitDetail(session.activeTurn, chunk, 'stderr');
+    }
+    handleProcessError(session, err) {
+        this.logWarn(`[codex-app-server] Process error for ${session.key}: ${err.stack || err.message}`);
+        if (session.activeTurn) {
+            const activeTurn = session.activeTurn;
+            session.activeTurn = null;
+            activeTurn.rejectCompletion(err);
+        }
+        for (const pending of session.pendingRequests.values()) {
+            pending.reject(err);
+        }
+        session.pendingRequests.clear();
+        session.closed = true;
+        this.sessions.delete(session.key);
+        (0, managed_process_registry_1.unregisterProcess)(session.key, false);
+    }
+    handleProcessClose(session, code, signal) {
+        this.logWarn(`[codex-app-server] Process closed for ${session.key}: code=${code ?? 'null'} signal=${signal ?? 'null'} activeTurn=${session.activeTurn ? 'yes' : 'no'} pendingRequests=${session.pendingRequests.size}`);
+        if (session.stdoutCarry.trim()) {
+            const parsed = safeJsonParse(session.stdoutCarry.trim());
+            if (parsed) {
+                if (isResponseMessage(parsed)) {
+                    appendEvent(session.activeTurn?.eventLog, 'in', 'response', parsed);
+                    this.handleResponse(session, parsed);
+                }
+                else if (isServerRequestMessage(parsed)) {
+                    appendEvent(session.activeTurn?.eventLog, 'in', 'server_request', parsed);
+                    void this.handleServerRequest(session, parsed);
+                }
+                else if (isNotificationMessage(parsed)) {
+                    appendEvent(session.activeTurn?.eventLog, 'in', 'notification', parsed);
+                    void this.handleNotification(session, parsed);
+                }
+            }
+        }
+        session.closed = true;
+        this.sessions.delete(session.key);
+        (0, managed_process_registry_1.unregisterProcess)(session.key, false);
+        const closeError = new Error(`Codex app-server exited${code !== null ? ` with code ${code}` : ''}${signal ? ` (${signal})` : ''}`);
+        for (const pending of session.pendingRequests.values()) {
+            pending.reject(closeError);
+        }
+        session.pendingRequests.clear();
+        if (session.activeTurn) {
+            const activeTurn = session.activeTurn;
+            session.activeTurn = null;
+            if (!activeTurn.done) {
+                activeTurn.rejectCompletion(closeError);
+            }
+        }
+    }
+    async emitChunk(activeTurn, chunk) {
+        if (!activeTurn?.onChunk || !chunk)
+            return;
+        activeTurn.callbackChain = activeTurn.callbackChain.then(async () => {
+            await activeTurn.onChunk?.(chunk);
+        }).catch((err) => {
+            this.logWarn(`[codex-app-server] onChunk callback failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+        await activeTurn.callbackChain;
+    }
+    async emitCommentary(activeTurn, text) {
+        if (!activeTurn?.onCommentary)
+            return;
+        const normalized = normalizeDetail(text);
+        if (!normalized || normalized === activeTurn.lastCommentaryText)
+            return;
+        activeTurn.lastCommentaryText = normalized;
+        activeTurn.callbackChain = activeTurn.callbackChain.then(async () => {
+            await activeTurn.onCommentary?.(normalized);
+        }).catch((err) => {
+            this.logWarn(`[codex-app-server] onCommentary callback failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+        await activeTurn.callbackChain;
+    }
+    async emitThinkingChunk(activeTurn, chunk) {
+        if (!activeTurn?.onThinkingChunk || !chunk)
+            return;
+        activeTurn.callbackChain = activeTurn.callbackChain.then(async () => {
+            await activeTurn.onThinkingChunk?.(chunk);
+        }).catch((err) => {
+            this.logWarn(`[codex-app-server] onThinkingChunk callback failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+        await activeTurn.callbackChain;
+    }
+    async emitDetail(activeTurn, detail, source = 'status') {
+        if (!activeTurn?.onDetail)
+            return;
+        const normalized = prepareLiveDetailForUser(activeTurn, detail, source);
+        if (!normalized)
+            return;
+        if (activeTurn.detailFingerprints.has(normalized))
+            return;
+        activeTurn.detailFingerprints.add(normalized);
+        activeTurn.callbackChain = activeTurn.callbackChain.then(async () => {
+            await activeTurn.onDetail?.(normalized);
+        }).catch((err) => {
+            this.logWarn(`[codex-app-server] onDetail callback failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+        await activeTurn.callbackChain;
+    }
+}
+exports.CodexAppServerManager = CodexAppServerManager;
+function getCodexAppServerManager() {
+    if (!_manager) {
+        _manager = new CodexAppServerManager();
+    }
+    return _manager;
+}
+async function runCodexAppServerTurnForTest(manager, opts) {
+    return manager.runTurn(opts);
+}
+exports.__codexAppServerTestUtils = {
+    LOCAL_ONLY_ERROR,
+    buildCodexAppServerInput,
+    buildCodexAppServerToolEnv,
+    buildTurnMcpToolEnv,
+    scrubCodexAppServerEnv,
+    computeEnvFingerprint,
+    buildApprovalResponse,
+    buildTurnUsage,
+    createEventLog,
+    serializeEventLog,
+    sessionKey,
+    delay,
+};
+//# sourceMappingURL=codex-app-server-manager.js.map