@bbigbang/agent-node 0.1.0

package/dist/codexAppServerRuntime.js

@@ -0,0 +1,3495 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { clearAcpSessionId, getSession, log, updateSessionRuntimeState, WorkspaceLockManager, } from '@bbigbang/runtime-acp';
+import { extractAttachmentIdFromUri, RuntimeAttachmentMaterializer, } from './attachmentMaterializer.js';
+import { formatAttachmentTextReference, promptAlreadyReferencesAttachment, resolveLocalAttachmentPath, resolveLocalImageAttachmentPath, } from './attachmentInput.js';
+import { buildCodexAppServerInitializeParams, CodexAppServerClient } from './codexAppServerClient.js';
+import { buildCodexAppServerChildEnv } from './codexAppServerEnv.js';
+import { buildBigbangMessageSendRepairGuidance, getBigbangMessageSendInfo, } from './bigbangMessageSendDetection.js';
+const TURN_START_TIMEOUT_MS = 90_000;
+const TURN_STEER_TIMEOUT_MS = 30_000;
+const TURN_STEER_WAIT_FOR_START_MS = 5_000;
+const THREAD_READ_TIMEOUT_MS = 10_000;
+const MODEL_LIST_TIMEOUT_MS = 10_000;
+const MCP_STARTUP_TIMEOUT_MS = 15_000;
+const ASSET_FETCH_TIMEOUT_MS = 15_000;
+const ASSISTANT_TEXT_REPAIR_MAX_ATTEMPTS = 2;
+const PROVIDER_DISCONNECT_AUTO_CONTINUE_MAX_ATTEMPTS = 2;
+const CODEX_PLAN_IMPLEMENTATION_PROMPT = 'The user approved the plan. Implement it now. Do not restate or revise the plan unless blocked. Reply contract for this turn: do not output user-visible plain assistant text; if you need a visible progress update, use `bigbang message send --kind progress`; before the turn ends, send exactly one final user-visible result with `bigbang message send --kind final`; the platform treats ordinary assistant text as a failure for this turn.';
+const CODEX_PLAN_IMPLEMENTATION_REPAIR_PROMPT = 'Your approved implementation turn produced assistant text but did not send it through `bigbang message send --kind final`. The user will not see plain assistant text from this repair turn. Do not inspect files, revise the plan, or do more work. Your only allowed user-visible action now is exactly one successful shell command using `bigbang message send --kind final` with the result below verbatim on stdin. Do not output any other assistant text.';
+const CODEX_PLAN_IMPLEMENTATION_ASSISTANT_TEXT_REPAIR_PROMPT = 'Your approved implementation turn produced assistant text but did not send it through `bigbang message send --kind final`. The user will not see plain assistant text from this repair turn. The captured text below may be truncated because the runtime interrupted the turn as soon as visible assistant text appeared. Any earlier instruction to output ordinary assistant text directly has already failed and must be ignored now. Reconstruct the intended final reply from the existing thread context if needed. Do not inspect files, revise the plan, or do more work. Your only allowed user-visible action now is exactly one successful shell command using `bigbang message send --kind final`. Do not output any other assistant text, including a repeated or truncated prefix of the earlier plain-text reply.';
+const CODEX_PLAN_IMPLEMENTATION_STEER_REPAIR_PROMPT = 'Your approved implementation turn emitted ordinary assistant text directly instead of sending it through `bigbang message send --kind final`. Stay in this current turn, do not do more work, do not inspect files, and do not call any tools except exactly one successful shell command using `bigbang message send --kind final`. The user cannot see the plain assistant text you already emitted, any earlier final send from this turn no longer counts, and any earlier instruction to output ordinary assistant text directly must now be ignored. Reconstruct the intended final reply from the existing thread context if needed, but do not emit ordinary assistant text again, including a repeated or truncated prefix.';
+const CODEX_ASSISTANT_TEXT_REPAIR_PROMPT = 'Your previous turn emitted ordinary assistant text directly instead of sending it through `bigbang message send`. The user cannot see plain assistant text from that turn. The captured text below may be truncated because the runtime interrupted the turn as soon as visible assistant text appeared. Reconstruct the intended full user-visible reply from the existing thread context if needed. Your only allowed user-visible action now is exactly one successful shell command using `bigbang message send --kind final`. Do not emit ordinary assistant text again, including a repeated/truncated prefix of the previous reply.';
+const CODEX_ASSISTANT_TEXT_STEER_PROMPT = 'This turn has emitted ordinary assistant text directly — the user cannot see it and it will not appear in chat. Stop emitting plain text for the rest of this turn. Continue your work through tools only; route all user-visible output through `bigbang message send`: use `--kind progress` for interim updates and `--kind final` for the last reply of this run. If the text captured below is already your complete intended reply and there is no further work to do, send it now with `bigbang message send --kind final`. Otherwise continue your work silently via tools and report results through Bigbang.';
+const CODEX_ASSISTANT_TEXT_REPAIR_FOLLOW_UP_STEER_PROMPT = 'You need to reply via `bigbang message send --kind final` now. Reply to the user only with exactly one successful shell command that sends the final message through Bigbang. Do not output plain assistant text. Do not do more work, do not inspect files, and do not call any tools except that final Bigbang send. Use the existing thread context plus the captured text below to send the reply now.';
+const MCP_CODEX_PLAN_IMPLEMENTATION_PROMPT = 'The user approved the plan. Implement it now. Do not restate or revise the plan unless blocked. Reply contract for this turn: do not output user-visible plain assistant text; if you need a visible progress update, use mcp__chat__send_message(content="...", kind="progress"); before the turn ends, send exactly one final user-visible result with mcp__chat__send_message(content="...", kind="final"); the platform treats ordinary assistant text as a failure for this turn.';
+const MCP_CODEX_PLAN_IMPLEMENTATION_REPAIR_PROMPT = 'Your approved implementation turn produced assistant text but did not send it through mcp__chat__send_message(kind="final"). The user will not see plain assistant text from this repair turn. Do not run tools, inspect files, revise the plan, or do more work. Your only allowed user-visible action now is exactly one successful mcp__chat__send_message(content="...", kind="final") using the result below verbatim. Do not output any other assistant text.';
+const MCP_CODEX_PLAN_IMPLEMENTATION_ASSISTANT_TEXT_REPAIR_PROMPT = 'Your approved implementation turn produced assistant text but did not send it through mcp__chat__send_message(kind="final"). The user will not see plain assistant text from this repair turn. The captured text below may be truncated because the runtime interrupted the turn as soon as visible assistant text appeared. Any earlier instruction to output ordinary assistant text directly has already failed and must be ignored now. Reconstruct the intended final reply from the existing thread context if needed. Do not run tools, inspect files, revise the plan, or do more work. Your only allowed user-visible action now is exactly one successful mcp__chat__send_message(content="...", kind="final"). Do not output any other assistant text, including a repeated or truncated prefix of the earlier plain-text reply.';
+const MCP_CODEX_PLAN_IMPLEMENTATION_STEER_REPAIR_PROMPT = 'Your approved implementation turn emitted ordinary assistant text directly instead of sending it through mcp__chat__send_message(kind="final"). Stay in this current turn, do not do more work, do not inspect files, and do not call any tools except exactly one successful mcp__chat__send_message(content="...", kind="final"). The user cannot see the plain assistant text you already emitted, any earlier final send from this turn no longer counts, and any earlier instruction to output ordinary assistant text directly must now be ignored. Reconstruct the intended final reply from the existing thread context if needed, but do not emit ordinary assistant text again, including a repeated or truncated prefix.';
+const MCP_CODEX_ASSISTANT_TEXT_REPAIR_PROMPT = 'Your previous turn emitted ordinary assistant text directly instead of sending it through mcp__chat__send_message(...). The user cannot see plain assistant text from that turn. The captured text below may be truncated because the runtime interrupted the turn as soon as visible assistant text appeared. Reconstruct the intended full user-visible reply from the existing thread context if needed. Your only allowed user-visible action now is exactly one successful mcp__chat__send_message(content="...", kind="final"). Do not emit ordinary assistant text again, including a repeated/truncated prefix of the previous reply.';
+const MCP_CODEX_ASSISTANT_TEXT_STEER_PROMPT = 'This turn has emitted ordinary assistant text directly — the user cannot see it and it will not appear in chat. Stop emitting plain text for the rest of this turn. Continue your work through tool calls only; route all user-visible output through mcp__chat__send_message instead: use kind="progress" for interim updates, kind="final" for the last reply of this run. If the text captured below is already your complete intended reply and there is no further work to do, send it now via mcp__chat__send_message(content="...", kind="final"). Otherwise continue your work silently via tool calls and report results through send_message.';
+const MCP_CODEX_ASSISTANT_TEXT_REPAIR_FOLLOW_UP_STEER_PROMPT = 'You need to reply via mcp__chat__send_message now. Reply to the user only with exactly one successful mcp__chat__send_message(content="...", kind="final"). Do not output plain assistant text. Do not do more work, do not inspect files, and do not call any tools except that final send_message. Use the existing thread context plus the captured text below to send the reply now.';
+const CODEX_PROVIDER_DISCONNECT_AUTO_CONTINUE_PROMPT = '继续，接着刚才的工作';
+const CODEX_PLAN_REVISION_FALLBACK = 'Please refine the plan further.';
+const CODEX_PLAN_MODE_PROMPT = 'Plan mode is active for this turn. Do not execute tools, inspect files, run shell commands, call MCP tools, send chat messages, or make changes. Only propose a concise implementation/research plan for the user to approve. Use the runtime plan/proposed-plan channel when available; otherwise return only <proposed_plan>...</proposed_plan>.';
+export class CodexAppServerRuntime {
+    db;
+    sessionKey;
+    bindingKey;
+    toolAuth;
+    workspaceRoot;
+    agentCommand;
+    agentArgs;
+    env;
+    model;
+    reasoningEffort;
+    defaultCodexMode;
+    serviceTier;
+    disabledToolKinds;
+    channelBridgeMcpEntry;
+    agentSurfaceMode;
+    assetAccessConfig;
+    workspaceLockManager;
+    spawnImpl;
+    assetFetchTimeoutMs;
+    attachmentMaterializer;
+    client = null;
+    child = null;
+    sessionId;
+    sessionSystemPromptText = null;
+    threadLoaded = false;
+    loadedThreadPolicySignature = null;
+    memoryModeDisabledThreadId = null;
+    persistExtendedHistorySupportByMethod = {
+        'thread/start': 'unknown',
+        'thread/resume': 'unknown',
+    };
+    activeRunId = null;
+    currentTurnId = null;
+    activeSink = null;
+    activeUiMode = 'summary';
+    activeCodexMode = null;
+    activeCompiledPolicy = null;
+    cancelRequested = false;
+    turnStartInFlight = false;
+    awaitingTurnStartedNotification = false;
+    activeTurnCompletion = null;
+    activeTurnWorkspaceLease = null;
+    activeTurnWorkspaceLeasePromise = null;
+    workspaceLockAbortController = null;
+    pendingUserInput = null;
+    pendingPlanApproval = null;
+    closeInProgress = false;
+    closePromise = null;
+    notificationChain = Promise.resolve();
+    pendingNotificationCount = 0;
+    activeBlockedKinds = null;
+    policyViolationError = null;
+    latestPlanText = null;
+    pendingPlanApprovalAfterTurn = false;
+    planImplementationActive = false;
+    planImplementationRepairAttempted = false;
+    planImplementationVisibleReplySent = false;
+    planImplementationDeltaBuffer = '';
+    planImplementationRepairSourceText = null;
+    assistantTextRepairActive = false;
+    assistantTextRepairSteerActive = false;
+    assistantTextRepairFallbackPending = false;
+    assistantTextRepairRequiresFinal = false;
+    assistantTextRepairSteerChatSendCount = 0;
+    assistantTextRepairSteerFinalChatSendCount = 0;
+    assistantTextRepairAttempts = 0;
+    assistantTextRepairSourceText = '';
+    assistantTextRepairStage = 'idle';
+    currentTurnAssistantTextBuffer = '';
+    currentTurnAssistantTextRepairTriggered = false;
+    currentTurnSuccessfulChatSend = false;
+    currentTurnSuccessfulChatSendCount = 0;
+    currentTurnSuccessfulFinalChatSendCount = 0;
+    currentTurnSuccessfulBigbangFinalChatSendCount = 0;
+    currentTurnCompletionSafeNonPostedChatSend = false;
+    currentTurnBigbangMessageSendFailures = [];
+    lastBigbangMessageSendFailureForRepair = null;
+    runSuccessfulChatSendCount = 0;
+    runSuccessfulFinalChatSendCount = 0;
+    autoContinueAttempts = 0;
+    deliveryAckSent = false;
+    providerOutputSeen = false;
+    shouldBackfillCompletedTurnTools = false;
+    sawNonChatToolThisRun = false;
+    cachedCollaborationModeModel = null;
+    agentMessageBuffers = new Map();
+    planItemBuffers = new Map();
+    reasoningBuffers = new Map();
+    commandOutputBuffers = new Map();
+    fileChangeOutputBuffers = new Map();
+    toolStartedIds = new Set();
+    toolCompletedIds = new Set();
+    toolSnapshots = new Map();
+    shellToolCallInputs = new Map();
+    compactEventKeys = new Set();
+    mcpServerStartupStates = new Map();
+    mcpStatusChangeWaiters = new Set();
+    soloMode;
+    constructor(params) {
+        this.db = params.db;
+        this.sessionKey = params.sessionKey;
+        this.bindingKey = normalizeOptionalString(params.bindingKey) ?? null;
+        this.toolAuth = params.toolAuth ?? null;
+        this.workspaceRoot = params.workspaceRoot;
+        this.agentCommand = params.agentCommand;
+        this.agentArgs = [...params.agentArgs];
+        this.env = { ...(params.env ?? {}) };
+        this.model = normalizeOptionalString(params.model);
+        this.reasoningEffort = normalizeCodexReasoningEffort(params.reasoningEffort);
+        this.defaultCodexMode = normalizeCodexMode(params.codexMode);
+        this.serviceTier = normalizeCodexServiceTier(params.serviceTier);
+        this.disabledToolKinds = [...(params.disabledToolKinds ?? [])];
+        this.channelBridgeMcpEntry = params.channelBridgeMcpEntry;
+        this.agentSurfaceMode = params.agentSurfaceMode ?? 'bigbang';
+        this.assetAccessConfig = params.assetAccessConfig;
+        this.workspaceLockManager = params.workspaceLockManager ?? new WorkspaceLockManager();
+        this.spawnImpl = params.spawnImpl ?? spawn;
+        this.assetFetchTimeoutMs = params.assetFetchTimeoutMs ?? ASSET_FETCH_TIMEOUT_MS;
+        this.soloMode = params.soloMode === true;
+        this.attachmentMaterializer = new RuntimeAttachmentMaterializer({
+            sessionKey: this.sessionKey,
+            runtimeLabel: 'codex-app-server',
+            assetAccessConfig: this.assetAccessConfig,
+            assetCacheRoot: params.assetCacheRoot,
+            fetchTimeoutMs: this.assetFetchTimeoutMs,
+            isCancelled: () => this.cancelRequested,
+            onMaterialized: params.onAssetMaterialized,
+        });
+        const existingSession = getSession(this.db, this.sessionKey);
+        this.sessionId = existingSession?.acpSessionId?.trim() || null;
+        this.sessionSystemPromptText = existingSession?.systemPromptText?.trim() || null;
+    }
+    hasPendingPermission() {
+        return Boolean(this.pendingUserInput || this.pendingPlanApproval);
+    }
+    updateConfig(config) {
+        const previousModel = this.model;
+        this.model = normalizeOptionalString(config.model);
+        this.reasoningEffort = normalizeCodexReasoningEffort(config.reasoningEffort);
+        this.serviceTier = normalizeCodexServiceTier(config.codexServiceTier);
+        if (this.model !== previousModel) {
+            this.cachedCollaborationModeModel = null;
+        }
+    }
+    async respondToPermission(requestId, decision, selectedActionId, responseText, answers) {
+        const pendingPlanApproval = this.pendingPlanApproval;
+        if (pendingPlanApproval?.requestId === requestId) {
+            this.pendingPlanApproval = null;
+            if (decision === 'deny' || selectedActionId === 'reject') {
+                this.activeCodexMode = 'default';
+                this.latestPlanText = null;
+                this.clearPlanImplementationState();
+                this.activeTurnCompletion?.resolve({ stopReason: 'approval_denied' });
+                return true;
+            }
+            if (selectedActionId === 'continue_planning') {
+                void this.startPlanRevisionTurn(pendingPlanApproval.planText, responseText).catch((error) => {
+                    this.activeTurnCompletion?.resolve({
+                        stopReason: 'failed',
+                        error: String(error?.message ?? error),
+                    });
+                });
+                return true;
+            }
+            try {
+                await this.emitPlanPhase('implementation');
+            }
+            catch (error) {
+                this.activeTurnCompletion?.resolve({
+                    stopReason: 'failed',
+                    error: String(error?.message ?? error),
+                });
+                return true;
+            }
+            void this.startPlanImplementationTurn(pendingPlanApproval.planText).catch((error) => {
+                this.activeTurnCompletion?.resolve({
+                    stopReason: 'failed',
+                    error: String(error?.message ?? error),
+                });
+            });
+            return true;
+        }
+        const pending = this.pendingUserInput;
+        if (!pending || pending.requestId !== requestId) {
+            return false;
+        }
+        this.pendingUserInput = null;
+        pending.resolve(decision === 'allow'
+            ? buildUserInputResponse(pending.params, answers)
+            : { answers: {} });
+        return true;
+    }
+    async emitPlanPhase(phase) {
+        await this.activeSink?.sendUi?.({
+            kind: 'plan_phase',
+            mode: this.activeUiMode,
+            phase,
+        });
+    }
+    async startPlanRevisionTurn(planText, feedbackText) {
+        if (!this.client || !this.sessionId) {
+            throw new Error('Codex app-server plan revision cannot continue without an active thread.');
+        }
+        if (!this.activeCompiledPolicy) {
+            throw new Error('Codex app-server plan revision lost the active tool policy.');
+        }
+        this.activeCodexMode = 'plan';
+        this.clearPlanImplementationState();
+        this.currentTurnId = null;
+        this.latestPlanText = null;
+        this.resetRunBuffers();
+        if (this.cancelRequested)
+            return;
+        await this.emitPlanPhase('planning');
+        const turnStartParams = await this.buildTurnStartParams({
+            threadId: this.sessionId,
+            compiledPolicy: this.activeCompiledPolicy,
+            promptText: buildCodexPlanRevisionPrompt(planText, feedbackText),
+            codexMode: 'plan',
+        });
+        if (this.cancelRequested)
+            return;
+        await this.requestTurnStart(this.client, turnStartParams);
+        if (this.cancelRequested && this.currentTurnId) {
+            await this.interruptActiveTurn();
+        }
+    }
+    async cancelCurrentRun(runId) {
+        if (this.activeRunId !== runId)
+            return false;
+        this.cancelRequested = true;
+        this.abortWorkspaceLockWait();
+        this.abortAssetFetch();
+        this.resolvePendingUserInputAsCancelled();
+        this.pendingPlanApproval = null;
+        this.clearDeferredPlanApproval();
+        if (!this.currentTurnId
+            && this.activeTurnCompletion
+            && !this.turnStartInFlight
+            && !this.awaitingTurnStartedNotification) {
+            this.activeTurnCompletion.resolve({ stopReason: 'cancelled' });
+            return true;
+        }
+        if (this.currentTurnId) {
+            await this.interruptActiveTurn();
+        }
+        return true;
+    }
+    async steerCurrentRun(runId, promptText, attachments) {
+        if (this.activeRunId !== runId)
+            return false;
+        if (!this.client || !this.sessionId)
+            return false;
+        if (this.assistantTextRepairSteerActive)
+            return false;
+        return this.requestTurnSteer(promptText, attachments);
+    }
+    async requestTurnSteer(promptText, attachments) {
+        if (!this.client || !this.sessionId)
+            return false;
+        const turnId = await this.waitForActiveTurnId(TURN_STEER_WAIT_FOR_START_MS);
+        if (!turnId || this.cancelRequested)
+            return false;
+        const materializedAttachments = await this.materializeAssetAttachments(attachments, this.activeRunId);
+        if (this.cancelRequested)
+            return false;
+        await this.client.request('turn/steer', {
+            threadId: this.sessionId,
+            expectedTurnId: turnId,
+            input: buildCodexTurnInput(promptText, materializedAttachments),
+        }, TURN_STEER_TIMEOUT_MS);
+        return true;
+    }
+    async startPlanImplementationTurn(planText) {
+        if (!this.client || !this.sessionId) {
+            throw new Error('Codex app-server plan approval cannot continue without an active thread.');
+        }
+        if (!this.activeCompiledPolicy) {
+            throw new Error('Codex app-server plan approval lost the active tool policy.');
+        }
+        this.activeCodexMode = 'default';
+        this.currentTurnId = null;
+        this.latestPlanText = null;
+        this.resetRunBuffers();
+        this.planImplementationActive = true;
+        this.planImplementationRepairAttempted = false;
+        this.planImplementationVisibleReplySent = false;
+        this.planImplementationDeltaBuffer = '';
+        this.planImplementationRepairSourceText = null;
+        if (this.cancelRequested)
+            return;
+        const turnStartParams = await this.buildTurnStartParams({
+            threadId: this.sessionId,
+            compiledPolicy: this.activeCompiledPolicy,
+            promptText: buildCodexPlanImplementationPrompt(this.agentSurfaceMode, planText),
+            codexMode: 'default',
+        });
+        if (this.cancelRequested)
+            return;
+        await this.requestTurnStart(this.client, turnStartParams);
+        if (this.cancelRequested && this.currentTurnId) {
+            await this.interruptActiveTurn();
+        }
+    }
+    async requestTurnStart(client, params) {
+        this.turnStartInFlight = true;
+        this.awaitingTurnStartedNotification = true;
+        try {
+            await client.request('turn/start', params, TURN_START_TIMEOUT_MS);
+        }
+        catch (error) {
+            this.awaitingTurnStartedNotification = false;
+            throw error;
+        }
+        finally {
+            this.turnStartInFlight = false;
+        }
+    }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closeInProgress = true;
+        this.cancelRequested = true;
+        this.activeBlockedKinds = null;
+        this.policyViolationError = null;
+        this.abortWorkspaceLockWait();
+        this.abortAssetFetch();
+        this.resolvePendingUserInputAsCancelled();
+        this.pendingPlanApproval = null;
+        this.clearDeferredPlanApproval();
+        this.clearPlanImplementationState();
+        this.clearAssistantTextRepairState();
+        this.toolStartedIds.clear();
+        this.toolCompletedIds.clear();
+        this.toolSnapshots.clear();
+        this.shellToolCallInputs.clear();
+        this.compactEventKeys.clear();
+        this.agentMessageBuffers.clear();
+        this.reasoningBuffers.clear();
+        this.commandOutputBuffers.clear();
+        this.fileChangeOutputBuffers.clear();
+        this.resetLoadedThreadState();
+        this.sessionId = null;
+        this.mcpServerStartupStates.clear();
+        this.resolvePendingMcpStatusWaiters();
+        const client = this.client;
+        const activeTurnCompletion = this.activeTurnCompletion;
+        this.client = null;
+        this.child = null;
+        const finalizeClose = () => {
+            activeTurnCompletion?.reject(new Error('Codex app-server runtime closed.'));
+            if (!activeTurnCompletion) {
+                this.releaseActiveTurnWorkspaceLock();
+            }
+            this.activeTurnCompletion = null;
+            this.activeRunId = null;
+            this.currentTurnId = null;
+            this.activeSink = null;
+            this.activeUiMode = 'summary';
+            this.activeCodexMode = null;
+            this.activeCompiledPolicy = null;
+            this.turnStartInFlight = false;
+            this.awaitingTurnStartedNotification = false;
+        };
+        this.closePromise = (async () => {
+            if (!client) {
+                finalizeClose();
+                return;
+            }
+            try {
+                await client.dispose();
+            }
+            catch (error) {
+                log.warn('[codex-app-server] failed to dispose app-server during close', {
+                    sessionKey: this.sessionKey,
+                    error: String(error?.message ?? error),
+                });
+            }
+            finally {
+                finalizeClose();
+            }
+        })();
+        return this.closePromise;
+    }
+    async prompt(params) {
+        if (this.activeRunId) {
+            throw new Error('Codex app-server runtime already has an active run.');
+        }
+        this.activeRunId = params.runId;
+        this.activeSink = params.sink;
+        this.activeUiMode = params.uiMode;
+        this.activeCodexMode = normalizeCodexMode(params.runtimeOverrides?.codexMode) ?? this.defaultCodexMode;
+        this.cancelRequested = false;
+        this.currentTurnId = null;
+        this.runSuccessfulChatSendCount = 0;
+        this.runSuccessfulFinalChatSendCount = 0;
+        this.resetRunBuffers();
+        const compiledPolicy = this.buildCompiledToolPolicy(params.disabledToolKinds ?? []);
+        this.activeCompiledPolicy = compiledPolicy;
+        this.activeBlockedKinds = compiledPolicy.blockedKinds;
+        this.autoContinueAttempts = 0;
+        this.deliveryAckSent = false;
+        this.providerOutputSeen = false;
+        const effectiveSystemPromptText = normalizeOptionalString(params.systemPromptText) ?? undefined;
+        try {
+            const preparedSession = await this.ensureSession({
+                systemPromptText: effectiveSystemPromptText,
+                policy: compiledPolicy,
+            });
+            this.shouldBackfillCompletedTurnTools = !preparedSession.isFreshSession;
+            const baseContextText = preparedSession.isFreshSession
+                ? joinPromptContext(params.resumeContextText, params.recoveryContextText, params.contextText)
+                : joinPromptContext(params.contextText);
+            const effectiveContextText = joinPromptContext(compiledPolicy.promptPreamble, baseContextText);
+            updateSessionRuntimeState(this.db, {
+                sessionKey: this.sessionKey,
+                acpSessionId: preparedSession.sessionId,
+                systemPromptText: effectiveSystemPromptText ?? null,
+            });
+            this.sessionSystemPromptText = effectiveSystemPromptText ?? null;
+            const preparedResult = {
+                sessionId: preparedSession.sessionId,
+                isFreshSession: preparedSession.isFreshSession,
+                effectiveSystemPromptText,
+                effectiveContextText: effectiveContextText || undefined,
+            };
+            const buildPromptResult = (stopReason) => ({
+                stopReason,
+                isFreshSession: preparedResult.isFreshSession,
+                sessionId: preparedResult.sessionId,
+                effectiveSystemPromptText,
+                effectiveContextText: effectiveContextText || undefined,
+            });
+            await params.onPrepared?.(preparedResult);
+            if (this.cancelRequested) {
+                return buildPromptResult('cancelled');
+            }
+            let turnPromptText = joinPromptContext(effectiveContextText, params.promptText);
+            let turnAttachments = params.attachments ?? params.promptResources;
+            while (true) {
+                try {
+                    const outcome = await this.runTurnAttempt({
+                        sessionId: preparedSession.sessionId,
+                        compiledPolicy,
+                        promptText: turnPromptText,
+                        attachments: turnAttachments,
+                        onDelivered: params.onDelivered,
+                    });
+                    return buildPromptResult(outcome.stopReason);
+                }
+                catch (error) {
+                    await this.notificationChain.catch(() => { });
+                    this.releaseActiveTurnWorkspaceLock();
+                    if (this.closeInProgress) {
+                        throw new Error('Codex app-server runtime closed.');
+                    }
+                    if (this.cancelRequested) {
+                        return buildPromptResult('cancelled');
+                    }
+                    if (!this.shouldAutoContinueAfterProviderDisconnect(error)) {
+                        throw error;
+                    }
+                    const autoContinued = await this.startProviderDisconnectAutoContinue({
+                        sessionId: preparedSession.sessionId,
+                        systemPromptText: effectiveSystemPromptText,
+                        compiledPolicy,
+                    });
+                    if (this.closeInProgress) {
+                        throw new Error('Codex app-server runtime closed.');
+                    }
+                    if (!autoContinued || this.cancelRequested) {
+                        return buildPromptResult('cancelled');
+                    }
+                    turnPromptText = CODEX_PROVIDER_DISCONNECT_AUTO_CONTINUE_PROMPT;
+                    turnAttachments = undefined;
+                }
+            }
+        }
+        catch (error) {
+            const message = String(error?.message ?? error);
+            if (isLikelyMissingThreadError(message)) {
+                clearAcpSessionId(this.db, this.sessionKey);
+                this.sessionId = null;
+                this.resetLoadedThreadState();
+            }
+            throw error instanceof Error ? error : new Error(message);
+        }
+        finally {
+            await this.notificationChain.catch(() => { });
+            this.resolvePendingUserInputAsCancelled();
+            this.releaseActiveTurnWorkspaceLock();
+            this.cleanupAfterRun();
+        }
+    }
+    async runTurnAttempt(params) {
+        const client = await this.ensureClient();
+        if (this.cancelRequested) {
+            return { stopReason: 'cancelled' };
+        }
+        const turnStartParams = await this.buildTurnStartParams({
+            threadId: params.sessionId,
+            compiledPolicy: params.compiledPolicy,
+            promptText: params.promptText,
+            attachments: params.attachments,
+            codexMode: this.activeCodexMode,
+        });
+        if (this.cancelRequested) {
+            return { stopReason: 'cancelled' };
+        }
+        const completion = new Promise((resolve, reject) => {
+            this.activeTurnCompletion = { resolve, reject };
+        });
+        void completion.catch(() => { });
+        try {
+            await this.requestTurnStart(client, turnStartParams);
+            if (!this.deliveryAckSent) {
+                this.deliveryAckSent = true;
+                await params.onDelivered?.();
+            }
+            if (this.cancelRequested && this.currentTurnId) {
+                await this.interruptActiveTurn();
+            }
+            const outcome = await completion;
+            await this.notificationChain;
+            this.releaseActiveTurnWorkspaceLock();
+            if (outcome.error) {
+                throw new Error(outcome.error);
+            }
+            return outcome;
+        }
+        finally {
+            this.activeTurnCompletion = null;
+            this.currentTurnId = null;
+        }
+    }
+    shouldAutoContinueAfterProviderDisconnect(error) {
+        if (this.cancelRequested)
+            return false;
+        if (this.activeCodexMode === 'plan')
+            return false;
+        if (!this.deliveryAckSent)
+            return false;
+        if (this.providerOutputSeen)
+            return false;
+        if (this.autoContinueAttempts >= PROVIDER_DISCONNECT_AUTO_CONTINUE_MAX_ATTEMPTS)
+            return false;
+        if (this.pendingUserInput || this.pendingPlanApproval || this.pendingPlanApprovalAfterTurn)
+            return false;
+        const message = String(error?.message ?? error).toLowerCase();
+        return message.includes('stream disconnected before completion')
+            && message.includes('backend-api/codex/responses');
+    }
+    async startProviderDisconnectAutoContinue(params) {
+        if (this.cancelRequested)
+            return false;
+        this.autoContinueAttempts += 1;
+        await this.activeSink?.sendActivityText?.(`Provider disconnected before completion; auto-continuing this run (attempt ${this.autoContinueAttempts}/${PROVIDER_DISCONNECT_AUTO_CONTINUE_MAX_ATTEMPTS}).`);
+        if (this.cancelRequested)
+            return false;
+        await this.disposeDisconnectedClient();
+        if (this.cancelRequested)
+            return false;
+        this.activeCodexMode = 'default';
+        this.currentTurnId = null;
+        this.resetRunBuffers();
+        await this.ensureClient();
+        if (this.cancelRequested)
+            return false;
+        await this.resumeThread({
+            sessionId: params.sessionId,
+            systemPromptText: params.systemPromptText,
+            policy: params.compiledPolicy,
+        });
+        if (this.cancelRequested)
+            return false;
+        await this.ensureThreadMemoryModeDisabled(params.sessionId);
+        if (this.cancelRequested)
+            return false;
+        updateSessionRuntimeState(this.db, {
+            sessionKey: this.sessionKey,
+            acpSessionId: params.sessionId,
+            systemPromptText: params.systemPromptText ?? null,
+        });
+        this.sessionSystemPromptText = params.systemPromptText ?? null;
+        return true;
+    }
+    async disposeDisconnectedClient() {
+        const client = this.client;
+        this.client = null;
+        this.child = null;
+        this.activeTurnCompletion = null;
+        this.currentTurnId = null;
+        this.turnStartInFlight = false;
+        this.awaitingTurnStartedNotification = false;
+        this.resetLoadedThreadState();
+        this.releaseActiveTurnWorkspaceLock();
+        if (!client) {
+            return;
+        }
+        try {
+            await client.dispose();
+        }
+        catch (error) {
+            log.warn('[codex-app-server] failed to dispose disconnected app-server client', {
+                sessionKey: this.sessionKey,
+                error: String(error?.message ?? error),
+            });
+        }
+    }
+    cleanupAfterRun() {
+        this.activeTurnCompletion = null;
+        this.activeRunId = null;
+        this.currentTurnId = null;
+        this.activeSink = null;
+        this.activeUiMode = 'summary';
+        this.activeCodexMode = null;
+        this.activeCompiledPolicy = null;
+        this.pendingPlanApproval = null;
+        this.clearDeferredPlanApproval();
+        this.pendingNotificationCount = 0;
+        this.activeBlockedKinds = null;
+        this.clearPlanImplementationState();
+        this.clearAssistantTextRepairState();
+        this.shouldBackfillCompletedTurnTools = false;
+        this.sawNonChatToolThisRun = false;
+        this.runSuccessfulChatSendCount = 0;
+        this.runSuccessfulFinalChatSendCount = 0;
+        this.autoContinueAttempts = 0;
+        this.deliveryAckSent = false;
+        this.providerOutputSeen = false;
+        this.cancelRequested = false;
+        this.turnStartInFlight = false;
+        this.awaitingTurnStartedNotification = false;
+        this.resetRunBuffers();
+    }
+    resetRunBuffers() {
+        this.policyViolationError = null;
+        this.latestPlanText = null;
+        this.clearDeferredPlanApproval();
+        this.agentMessageBuffers.clear();
+        this.planItemBuffers.clear();
+        this.reasoningBuffers.clear();
+        this.commandOutputBuffers.clear();
+        this.fileChangeOutputBuffers.clear();
+        this.toolStartedIds.clear();
+        this.toolCompletedIds.clear();
+        this.toolSnapshots.clear();
+        this.shellToolCallInputs.clear();
+        this.currentTurnAssistantTextBuffer = '';
+        this.currentTurnAssistantTextRepairTriggered = false;
+        this.currentTurnSuccessfulChatSend = false;
+        this.currentTurnSuccessfulChatSendCount = 0;
+        this.currentTurnSuccessfulFinalChatSendCount = 0;
+        this.currentTurnSuccessfulBigbangFinalChatSendCount = 0;
+        this.currentTurnCompletionSafeNonPostedChatSend = false;
+        this.currentTurnBigbangMessageSendFailures = [];
+    }
+    buildCurrentTurnBigbangRepairGuidance() {
+        if (this.agentSurfaceMode !== 'bigbang') {
+            return null;
+        }
+        const currentFailures = this.currentTurnBigbangMessageSendFailures;
+        const latestFinalFailure = [...currentFailures].reverse().find((failure) => failure.messageKind === 'final');
+        const selectedFailure = latestFinalFailure ?? currentFailures.at(-1) ?? this.lastBigbangMessageSendFailureForRepair;
+        if (!selectedFailure)
+            return null;
+        this.lastBigbangMessageSendFailureForRepair = selectedFailure;
+        return buildBigbangMessageSendRepairGuidance(selectedFailure.failureKind);
+    }
+    markProviderOutputSeen() {
+        this.providerOutputSeen = true;
+    }
+    clearPlanImplementationState() {
+        this.planImplementationActive = false;
+        this.planImplementationRepairAttempted = false;
+        this.planImplementationVisibleReplySent = false;
+        this.planImplementationDeltaBuffer = '';
+        this.planImplementationRepairSourceText = null;
+    }
+    clearAssistantTextRepairState() {
+        this.assistantTextRepairActive = false;
+        this.assistantTextRepairSteerActive = false;
+        this.assistantTextRepairFallbackPending = false;
+        this.assistantTextRepairRequiresFinal = false;
+        this.assistantTextRepairSteerChatSendCount = 0;
+        this.assistantTextRepairSteerFinalChatSendCount = 0;
+        this.assistantTextRepairAttempts = 0;
+        this.assistantTextRepairSourceText = '';
+        this.assistantTextRepairStage = 'idle';
+        this.lastBigbangMessageSendFailureForRepair = null;
+    }
+    async ensureClient() {
+        if (this.client)
+            return this.client;
+        const child = this.spawnImpl(this.agentCommand, this.agentArgs, {
+            cwd: this.workspaceRoot,
+            env: buildCodexAppServerChildEnv(process.env, this.env),
+            detached: process.platform !== 'win32',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.child = child;
+        const client = new CodexAppServerClient({ child });
+        client.setNotificationHandler((method, params) => {
+            this.queueNotification(async () => {
+                await this.handleNotification(method, params);
+            });
+        });
+        client.setExitHandler((error) => {
+            if (this.client !== client) {
+                return;
+            }
+            this.client = null;
+            this.child = null;
+            this.awaitingTurnStartedNotification = false;
+            this.turnStartInFlight = false;
+            if (this.closeInProgress) {
+                return;
+            }
+            this.activeTurnCompletion?.reject(error);
+        });
+        client.setRequestHandler('item/commandExecution/requestApproval', (params) => (this.handleCommandExecutionApprovalRequest(params)));
+        client.setRequestHandler('item/fileChange/requestApproval', (params) => (this.handleFileChangeApprovalRequest(params)));
+        client.setRequestHandler('item/permissions/requestApproval', (params) => (this.handlePermissionsApprovalRequest(params)));
+        client.setRequestHandler('item/tool/requestUserInput', (params) => this.handleUserInputRequest(params));
+        client.setRequestHandler('tool/requestUserInput', (params) => this.handleUserInputRequest(params));
+        await client.request('initialize', buildCodexAppServerInitializeParams());
+        client.notify('initialized', {});
+        this.client = client;
+        return client;
+    }
+    async ensureSession(params) {
+        if (!this.sessionId) {
+            const sessionId = await this.startThread(params);
+            await this.ensureThreadMemoryModeDisabled(sessionId);
+            return { sessionId, isFreshSession: true };
+        }
+        if (this.threadLoaded
+            && this.loadedThreadPolicySignature === params.policy.threadPolicySignature
+            && this.memoryModeDisabledThreadId === this.sessionId) {
+            return { sessionId: this.sessionId, isFreshSession: false };
+        }
+        const existingSessionId = this.sessionId;
+        try {
+            await this.resumeThread({
+                sessionId: existingSessionId,
+                systemPromptText: params.systemPromptText,
+                policy: params.policy,
+            });
+        }
+        catch (error) {
+            const message = String(error?.message ?? error);
+            if (!isLikelyMissingThreadError(message)) {
+                log.warn('[codex-app-server] failed to resume thread', {
+                    sessionKey: this.sessionKey,
+                    sessionId: existingSessionId,
+                    error: message,
+                });
+                throw error instanceof Error ? error : new Error(message);
+            }
+            log.warn('[codex-app-server] saved thread missing; starting new thread', {
+                sessionKey: this.sessionKey,
+                sessionId: existingSessionId,
+                error: message,
+            });
+            clearAcpSessionId(this.db, this.sessionKey);
+            this.sessionId = null;
+            this.resetLoadedThreadState();
+            const freshSessionId = await this.startThread(params);
+            await this.ensureThreadMemoryModeDisabled(freshSessionId);
+            return { sessionId: freshSessionId, isFreshSession: true };
+        }
+        await this.ensureThreadMemoryModeDisabled(existingSessionId);
+        return { sessionId: existingSessionId, isFreshSession: false };
+    }
+    async startThread(params) {
+        this.resetConfiguredMcpServerStates();
+        const response = await this.requestThreadLifecycle({
+            method: 'thread/start',
+            sessionId: null,
+            buildParams: (persistExtendedHistory) => this.buildThreadStartParams(params, { persistExtendedHistory }),
+        });
+        const sessionId = normalizeOptionalString(response?.thread?.id);
+        if (!sessionId) {
+            throw new Error('Codex app-server did not return a thread id.');
+        }
+        await this.waitForConfiguredMcpServersReady();
+        this.sessionId = sessionId;
+        this.threadLoaded = true;
+        this.loadedThreadPolicySignature = params.policy.threadPolicySignature;
+        this.memoryModeDisabledThreadId = null;
+        return sessionId;
+    }
+    async resumeThread(params) {
+        this.resetConfiguredMcpServerStates();
+        await this.requestThreadLifecycle({
+            method: 'thread/resume',
+            sessionId: params.sessionId,
+            buildParams: (persistExtendedHistory) => this.buildThreadResumeParams(params, { persistExtendedHistory }),
+        });
+        await this.waitForConfiguredMcpServersReady();
+        this.threadLoaded = true;
+        this.loadedThreadPolicySignature = params.policy.threadPolicySignature;
+    }
+    async requestThreadLifecycle(params) {
+        const client = await this.ensureClient();
+        const shouldPersistExtendedHistory = this.persistExtendedHistorySupportByMethod[params.method] !== 'unsupported';
+        try {
+            const response = await client.request(params.method, params.buildParams(shouldPersistExtendedHistory));
+            if (shouldPersistExtendedHistory) {
+                this.persistExtendedHistorySupportByMethod[params.method] = 'enabled';
+            }
+            return response;
+        }
+        catch (error) {
+            const message = String(error?.message ?? error);
+            if (!shouldPersistExtendedHistory || !isLikelyUnsupportedPersistExtendedHistoryError(message)) {
+                throw error instanceof Error ? error : new Error(message);
+            }
+            log.warn('[codex-app-server] app-server rejected persistExtendedHistory; retrying without it', {
+                sessionKey: this.sessionKey,
+                sessionId: params.sessionId,
+                method: params.method,
+                error: message,
+            });
+            this.persistExtendedHistorySupportByMethod[params.method] = 'unsupported';
+            this.resetConfiguredMcpServerStates();
+            return await client.request(params.method, params.buildParams(false));
+        }
+    }
+    async ensureThreadMemoryModeDisabled(sessionId) {
+        if (this.memoryModeDisabledThreadId === sessionId) {
+            return;
+        }
+        const client = await this.ensureClient();
+        try {
+            await client.request('thread/memoryMode/set', {
+                threadId: sessionId,
+                mode: 'disabled',
+            });
+            this.memoryModeDisabledThreadId = sessionId;
+        }
+        catch (error) {
+            this.memoryModeDisabledThreadId = null;
+            const message = String(error?.message ?? error);
+            log.warn('[codex-app-server] failed to disable provider memory', {
+                sessionKey: this.sessionKey,
+                sessionId,
+                error: message,
+            });
+            throw new Error(`Failed to disable Codex provider memory for codex_app_server thread ${sessionId}: ${message}`);
+        }
+    }
+    resetLoadedThreadState() {
+        this.threadLoaded = false;
+        this.loadedThreadPolicySignature = null;
+        this.memoryModeDisabledThreadId = null;
+    }
+    async interruptActiveTurn() {
+        if (!this.client || !this.sessionId || !this.currentTurnId)
+            return;
+        try {
+            await this.client.request('turn/interrupt', {
+                threadId: this.sessionId,
+                turnId: this.currentTurnId,
+            });
+        }
+        catch (error) {
+            log.warn('[codex-app-server] failed to interrupt active turn', {
+                sessionKey: this.sessionKey,
+                sessionId: this.sessionId,
+                turnId: this.currentTurnId,
+                error: String(error?.message ?? error),
+            });
+        }
+    }
+    async ensureActiveTurnWorkspaceWriteLock() {
+        if (this.activeTurnWorkspaceLease) {
+            return;
+        }
+        if (this.activeTurnWorkspaceLeasePromise) {
+            await this.activeTurnWorkspaceLeasePromise;
+            return;
+        }
+        const abortController = new AbortController();
+        this.workspaceLockAbortController = abortController;
+        const acquirePromise = (async () => {
+            const lease = await this.workspaceLockManager.acquire(this.workspaceRoot, {
+                signal: abortController.signal,
+                onWaitStart: () => {
+                    void this.activeSink?.sendUi?.({
+                        kind: 'task',
+                        mode: this.activeUiMode,
+                        title: 'waiting for workspace lock',
+                        detail: `Waiting for exclusive workspace access: ${this.workspaceRoot}`,
+                        silent: true,
+                    }).catch((error) => {
+                        log.warn('[codex-app-server] failed to emit workspace lock wait event', {
+                            sessionKey: this.sessionKey,
+                            error: String(error?.message ?? error),
+                        });
+                    });
+                },
+            });
+            this.activeTurnWorkspaceLease = lease;
+        })();
+        this.activeTurnWorkspaceLeasePromise = acquirePromise;
+        try {
+            await acquirePromise;
+        }
+        finally {
+            if (this.workspaceLockAbortController === abortController) {
+                this.workspaceLockAbortController = null;
+            }
+            if (this.activeTurnWorkspaceLeasePromise === acquirePromise) {
+                this.activeTurnWorkspaceLeasePromise = null;
+            }
+        }
+    }
+    async waitForWorkspaceWritesBeforeRead() {
+        await this.ensureActiveTurnWorkspaceWriteLock();
+    }
+    abortWorkspaceLockWait() {
+        const controller = this.workspaceLockAbortController;
+        if (!controller)
+            return;
+        this.workspaceLockAbortController = null;
+        controller.abort();
+    }
+    abortAssetFetch() {
+        this.attachmentMaterializer.abort();
+    }
+    releaseActiveTurnWorkspaceLock() {
+        this.activeTurnWorkspaceLeasePromise = null;
+        const lease = this.activeTurnWorkspaceLease;
+        if (!lease)
+            return;
+        this.activeTurnWorkspaceLease = null;
+        lease.release();
+    }
+    resolvePendingUserInputAsCancelled() {
+        const pending = this.pendingUserInput;
+        if (!pending)
+            return;
+        this.pendingUserInput = null;
+        pending.resolve({ answers: {} });
+    }
+    queueNotification(task) {
+        this.pendingNotificationCount += 1;
+        this.notificationChain = this.notificationChain
+            .then(async () => {
+            try {
+                await task();
+            }
+            finally {
+                this.pendingNotificationCount = Math.max(0, this.pendingNotificationCount - 1);
+                if (this.pendingNotificationCount === 0) {
+                    this.scheduleDeferredPlanApprovalFlush();
+                }
+            }
+        })
+            .catch((error) => {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.activeTurnCompletion?.reject(err);
+        });
+    }
+    clearDeferredPlanApproval() {
+        this.pendingPlanApprovalAfterTurn = false;
+    }
+    scheduleDeferredPlanApprovalFlush() {
+        if (!this.pendingPlanApprovalAfterTurn || this.pendingNotificationCount > 0)
+            return;
+        void this.flushDeferredPlanApproval().catch((error) => {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.activeTurnCompletion?.resolve({
+                stopReason: 'failed',
+                error: err.message,
+            });
+        });
+    }
+    async flushDeferredPlanApproval() {
+        if (!this.pendingPlanApprovalAfterTurn)
+            return;
+        this.pendingPlanApprovalAfterTurn = false;
+        if (this.cancelRequested || this.closeInProgress)
+            return;
+        if (!this.activeRunId || !this.activeTurnCompletion)
+            return;
+        if (this.activeCodexMode !== 'plan')
+            return;
+        if (this.pendingPlanApproval)
+            return;
+        let planText;
+        try {
+            planText = await this.readLatestPlanTextFromThreadSnapshot();
+        }
+        catch (error) {
+            if (this.cancelRequested || this.closeInProgress)
+                return;
+            if (!this.activeRunId || !this.activeTurnCompletion)
+                return;
+            throw error;
+        }
+        if (this.cancelRequested || this.closeInProgress)
+            return;
+        if (!this.activeRunId || !this.activeTurnCompletion)
+            return;
+        if (this.activeCodexMode !== 'plan')
+            return;
+        if (this.pendingPlanApproval)
+            return;
+        if (planText) {
+            await this.emitPlanApprovalRequest(planText);
+            return;
+        }
+        this.activeTurnCompletion?.resolve({ stopReason: 'completed' });
+    }
+    async readLatestPlanTextFromThreadSnapshot() {
+        if (!this.client || !this.sessionId)
+            return null;
+        try {
+            const response = await this.client.request('thread/read', {
+                threadId: this.sessionId,
+                includeTurns: true,
+            }, THREAD_READ_TIMEOUT_MS);
+            return extractLatestPlanTextFromThreadReadResponse(response);
+        }
+        catch (error) {
+            log.warn('[codex-app-server] failed to read completed plan snapshot', {
+                sessionId: this.sessionId,
+                error: String(error?.message ?? error),
+            });
+            throw new Error(`Codex app-server failed to read completed plan snapshot: ${String(error?.message ?? error)}`);
+        }
+    }
+    async backfillCompletedTurnToolItemsFromThreadSnapshot(turnId) {
+        if (!this.client || !this.sessionId || !turnId)
+            return null;
+        try {
+            const response = await this.client.request('thread/read', {
+                threadId: this.sessionId,
+                includeTurns: true,
+            }, THREAD_READ_TIMEOUT_MS);
+            const items = extractCompletedTurnToolItems(response, turnId);
+            for (const item of items) {
+                const itemId = normalizeOptionalString(asRecord(item)?.id);
+                if (isWorkspaceSensitiveToolItem(item, this.workspaceRoot)
+                    && (!itemId || (!this.toolStartedIds.has(itemId) && !this.toolCompletedIds.has(itemId)))) {
+                    return 'Codex app-server completed a workspace-sensitive tool without live lockable tool notifications.';
+                }
+                await this.handleThreadItem(item, { stage: 'complete' });
+            }
+            return null;
+        }
+        catch (error) {
+            log.warn('[codex-app-server] failed to backfill completed turn tool snapshot', {
+                sessionId: this.sessionId,
+                turnId,
+                error: String(error?.message ?? error),
+            });
+            return null;
+        }
+    }
+    async handleDefaultTurnCompleted() {
+        const completedTurnId = this.currentTurnId;
+        this.currentTurnId = null;
+        if (this.shouldBackfillCompletedTurnTools && this.sawNonChatToolThisRun) {
+            const backfillError = await this.backfillCompletedTurnToolItemsFromThreadSnapshot(completedTurnId);
+            if (backfillError) {
+                this.activeTurnCompletion?.resolve({
+                    stopReason: 'failed',
+                    error: backfillError,
+                });
+                return;
+            }
+        }
+        if (this.soloMode) {
+            this.activeTurnCompletion?.resolve({ stopReason: 'completed' });
+            return;
+        }
+        if (await this.handleAssistantTextRepairTurnCompleted()) {
+            return;
+        }
+        if (!this.planImplementationActive) {
+            this.activeTurnCompletion?.resolve({ stopReason: 'completed' });
+            return;
+        }
+        if (this.planImplementationVisibleReplySent) {
+            this.activeTurnCompletion?.resolve({ stopReason: 'completed' });
+            return;
+        }
+        const repairSourceText = normalizeOptionalString(this.planImplementationRepairSourceText);
+        const draftText = repairSourceText ?? normalizeOptionalString(this.planImplementationDeltaBuffer);
+        if (!draftText) {
+            this.activeTurnCompletion?.resolve({
+                stopReason: 'failed',
+                error: 'Codex app-server implementation completed without sending a final chat message.',
+            });
+            return;
+        }
+        if (this.planImplementationRepairAttempted) {
+            this.activeTurnCompletion?.resolve({
+                stopReason: 'failed',
+                error: 'Codex app-server implementation repair did not send a final chat message.',
+            });
+            return;
+        }
+        await this.startPlanImplementationRepairTurn(draftText, {
+            allowReconstruction: Boolean(repairSourceText),
+        });
+    }
+    async startPlanImplementationRepairTurn(finalAnswerDraft, options) {
+        if (!this.client || !this.sessionId) {
+            throw new Error('Codex app-server plan implementation repair cannot continue without an active thread.');
+        }
+        if (!this.activeCompiledPolicy) {
+            throw new Error('Codex app-server plan implementation repair lost the active tool policy.');
+        }
+        const bigbangRepairGuidance = this.buildCurrentTurnBigbangRepairGuidance();
+        this.activeCodexMode = 'default';
+        this.currentTurnId = null;
+        this.resetRunBuffers();
+        this.planImplementationActive = true;
+        this.planImplementationRepairAttempted = true;
+        this.planImplementationVisibleReplySent = false;
+        this.planImplementationDeltaBuffer = finalAnswerDraft;
+        this.planImplementationRepairSourceText = null;
+        if (this.cancelRequested)
+            return;
+        const turnStartParams = await this.buildTurnStartParams({
+            threadId: this.sessionId,
+            compiledPolicy: this.activeCompiledPolicy,
+            promptText: buildCodexPlanImplementationRepairPrompt(this.agentSurfaceMode, finalAnswerDraft, {
+                allowReconstruction: options?.allowReconstruction === true,
+                bigbangRepairGuidance,
+            }),
+            codexMode: 'default',
+        });
+        if (this.cancelRequested)
+            return;
+        await this.requestTurnStart(this.client, turnStartParams);
+        if (this.cancelRequested && this.currentTurnId) {
+            await this.interruptActiveTurn();
+        }
+    }
+    async handleAssistantTextRepairTurnCompleted() {
+        if (this.soloMode)
+            return false;
+        if (this.activeCodexMode === 'plan')
+            return false;
+        const currentTurnAssistantText = normalizeOptionalString(this.currentTurnAssistantTextBuffer);
+        if (currentTurnAssistantText
+            && this.agentSurfaceMode === 'bigbang'
+            && this.currentTurnSuccessfulBigbangFinalChatSendCount > 0
+            && !this.planImplementationActive
+            && !this.assistantTextRepairRequiresFinal) {
+            this.clearAssistantTextRepairState();
+            return false;
+        }
+        if (currentTurnAssistantText) {
+            this.assistantTextRepairSourceText = currentTurnAssistantText;
+            if (this.planImplementationActive || this.assistantTextRepairRequiresFinal) {
+                this.planImplementationRepairSourceText = currentTurnAssistantText;
+            }
+        }
+        else if (this.assistantTextRepairActive && this.currentTurnSuccessfulChatSend) {
+            const repairTurnSatisfied = this.currentTurnSuccessfulFinalChatSendCount > 0;
+            if (repairTurnSatisfied) {
+                if (this.planImplementationActive) {
+                    this.planImplementationVisibleReplySent = true;
+                }
+                this.clearAssistantTextRepairState();
+                return false;
+            }
+        }
+        if (this.assistantTextRepairActive
+            && this.currentTurnCompletionSafeNonPostedChatSend
+            && this.runSuccessfulFinalChatSendCount > 0) {
+            if (this.planImplementationActive) {
+                this.planImplementationVisibleReplySent = true;
+            }
+            this.clearAssistantTextRepairState();
+            return false;
+        }
+        if (this.assistantTextRepairSteerActive) {
+            const sawPostSteerReply = (this.currentTurnSuccessfulFinalChatSendCount > this.assistantTextRepairSteerFinalChatSendCount);
+            if (this.currentTurnCompletionSafeNonPostedChatSend
+                && this.runSuccessfulFinalChatSendCount > 0) {
+                if (this.planImplementationActive) {
+                    this.planImplementationVisibleReplySent = true;
+                }
+                this.clearAssistantTextRepairState();
+                return false;
+            }
+            if (this.assistantTextRepairRequiresFinal
+                && sawPostSteerReply
+                && !this.assistantTextRepairFallbackPending) {
+                this.planImplementationVisibleReplySent = true;
+                this.clearAssistantTextRepairState();
+                return false;
+            }
+            if (sawPostSteerReply && !this.assistantTextRepairFallbackPending) {
+                this.clearAssistantTextRepairState();
+                return false;
+            }
+            this.assistantTextRepairSteerActive = false;
+            this.assistantTextRepairFallbackPending = false;
+            if (this.assistantTextRepairStage === 'repair_turn_follow_up_steer' && !this.planImplementationActive) {
+                this.activeTurnCompletion?.resolve({
+                    stopReason: 'failed',
+                    error: 'Codex app-server assistant text repair exceeded retry cap.',
+                });
+                return true;
+            }
+            if (this.assistantTextRepairAttempts >= ASSISTANT_TEXT_REPAIR_MAX_ATTEMPTS) {
+                this.activeTurnCompletion?.resolve({
+                    stopReason: 'failed',
+                    error: 'Codex app-server assistant text repair exceeded retry cap.',
+                });
+                return true;
+            }
+            await this.startAssistantTextRepairTurn();
+            return true;
+        }
+        if (!currentTurnAssistantText && !this.assistantTextRepairActive) {
+            return false;
+        }
+        if (this.currentTurnSuccessfulChatSend && !this.assistantTextRepairActive) {
+            await this.startAssistantTextRepairTurn();
+            return true;
+        }
+        if (this.assistantTextRepairAttempts >= ASSISTANT_TEXT_REPAIR_MAX_ATTEMPTS) {
+            this.activeTurnCompletion?.resolve({
+                stopReason: 'failed',
+                error: 'Codex app-server assistant text repair exceeded retry cap.',
+            });
+            return true;
+        }
+        await this.startAssistantTextRepairTurn();
+        return true;
+    }
+    async startAssistantTextRepairSteer(stage = 'original_turn_steer') {
+        if (!this.activeRunId || !this.currentTurnId) {
+            return false;
+        }
+        const sourceText = normalizeOptionalString(this.currentTurnAssistantTextBuffer);
+        if (!sourceText) {
+            return false;
+        }
+        this.assistantTextRepairActive = true;
+        this.assistantTextRepairSteerActive = true;
+        this.assistantTextRepairFallbackPending = false;
+        this.assistantTextRepairRequiresFinal = this.planImplementationActive;
+        this.assistantTextRepairSteerChatSendCount = this.currentTurnSuccessfulChatSendCount;
+        this.assistantTextRepairSteerFinalChatSendCount = this.currentTurnSuccessfulFinalChatSendCount;
+        this.assistantTextRepairSourceText = sourceText;
+        this.assistantTextRepairStage = stage;
+        if (stage === 'original_turn_steer') {
+            this.assistantTextRepairAttempts += 1;
+        }
+        if (this.assistantTextRepairRequiresFinal) {
+            this.planImplementationVisibleReplySent = false;
+            this.planImplementationRepairSourceText = sourceText;
+        }
+        const bigbangRepairGuidance = this.buildCurrentTurnBigbangRepairGuidance();
+        try {
+            return await this.requestTurnSteer(this.assistantTextRepairRequiresFinal
+                ? buildCodexPlanImplementationSteerRepairPrompt(this.agentSurfaceMode, sourceText, bigbangRepairGuidance)
+                : stage === 'repair_turn_follow_up_steer'
+                    ? buildCodexAssistantTextRepairFollowUpSteerPrompt(this.agentSurfaceMode, sourceText, bigbangRepairGuidance)
+                    : buildCodexAssistantTextSteerPrompt(this.agentSurfaceMode, sourceText, bigbangRepairGuidance));
+        }
+        catch (error) {
+            log.warn('[codex-app-server] assistant-text repair steer failed', {
+                sessionKey: this.sessionKey,
+                runId: this.activeRunId,
+                turnId: this.currentTurnId,
+                error: String(error?.message ?? error),
+            });
+            return false;
+        }
+    }
+    async startAssistantTextRepairTurn() {
+        if (!this.client || !this.sessionId) {
+            throw new Error('Codex app-server assistant text repair cannot continue without an active thread.');
+        }
+        if (!this.activeCompiledPolicy) {
+            throw new Error('Codex app-server assistant text repair lost the active tool policy.');
+        }
+        const sourceText = normalizeOptionalString(this.assistantTextRepairSourceText);
+        if (!sourceText) {
+            throw new Error('Codex app-server assistant text repair has no buffered assistant text to repair.');
+        }
+        const bigbangRepairGuidance = this.buildCurrentTurnBigbangRepairGuidance();
+        this.activeCodexMode = 'default';
+        this.currentTurnId = null;
+        this.resetRunBuffers();
+        this.assistantTextRepairActive = true;
+        this.assistantTextRepairSteerActive = false;
+        this.assistantTextRepairFallbackPending = false;
+        this.assistantTextRepairRequiresFinal = false;
+        this.assistantTextRepairSteerChatSendCount = 0;
+        this.assistantTextRepairSteerFinalChatSendCount = 0;
+        this.assistantTextRepairAttempts += 1;
+        this.assistantTextRepairStage = 'fresh_repair_turn';
+        if (this.cancelRequested)
+            return;
+        const turnStartParams = await this.buildTurnStartParams({
+            threadId: this.sessionId,
+            compiledPolicy: this.activeCompiledPolicy,
+            promptText: buildCodexAssistantTextRepairPrompt(this.agentSurfaceMode, sourceText, bigbangRepairGuidance),
+            codexMode: 'default',
+        });
+        if (this.cancelRequested)
+            return;
+        await this.requestTurnStart(this.client, turnStartParams);
+        if (this.cancelRequested && this.currentTurnId) {
+            await this.interruptActiveTurn();
+        }
+    }
+    async handleNotification(method, params) {
+        if (method === 'mcpServer/startupStatus/updated') {
+            const payload = params;
+            const name = normalizeOptionalString(payload?.name);
+            if (name) {
+                this.mcpServerStartupStates.set(name, {
+                    status: normalizeOptionalString(payload?.status) ?? 'starting',
+                    error: normalizeOptionalString(payload?.error) ?? null,
+                });
+                this.resolvePendingMcpStatusWaiters();
+            }
+            return;
+        }
+        if (method === 'thread/started') {
+            const sessionId = normalizeOptionalString(params?.thread?.id);
+            if (sessionId) {
+                if (this.sessionId !== sessionId) {
+                    this.memoryModeDisabledThreadId = null;
+                }
+                this.sessionId = sessionId;
+                this.threadLoaded = true;
+            }
+            return;
+        }
+        if (method === 'turn/started') {
+            const turnId = normalizeOptionalString(params?.turn?.id);
+            if (turnId) {
+                this.currentTurnId = turnId;
+                this.awaitingTurnStartedNotification = false;
+                if (this.cancelRequested) {
+                    await this.interruptActiveTurn();
+                }
+            }
+            return;
+        }
+        if (method === 'item/agentMessage/delta') {
+            const payload = params;
+            if (payload?.itemId && typeof payload.delta === 'string' && payload.delta.length > 0) {
+                this.markProviderOutputSeen();
+                this.agentMessageBuffers.set(payload.itemId, `${this.agentMessageBuffers.get(payload.itemId) ?? ''}${payload.delta}`);
+                if (this.soloMode || this.activeCodexMode === 'plan') {
+                    await this.sendAssistantText(payload.delta);
+                }
+                else {
+                    await this.captureAssistantTextViolation(payload.delta);
+                }
+            }
+            return;
+        }
+        if (method === 'item/plan/delta') {
+            const payload = params;
+            if (payload?.itemId && typeof payload.delta === 'string' && payload.delta.length > 0) {
+                this.markProviderOutputSeen();
+                this.planItemBuffers.set(payload.itemId, `${this.planItemBuffers.get(payload.itemId) ?? ''}${payload.delta}`);
+            }
+            return;
+        }
+        if (method === 'item/reasoning/textDelta' || method === 'item/reasoning/summaryTextDelta') {
+            const payload = params;
+            if (payload?.itemId && typeof payload.delta === 'string' && payload.delta.length > 0) {
+                this.markProviderOutputSeen();
+                this.reasoningBuffers.set(payload.itemId, `${this.reasoningBuffers.get(payload.itemId) ?? ''}${payload.delta}`);
+                await this.sendThinkingText(payload.delta);
+            }
+            return;
+        }
+        if (method === 'item/commandExecution/outputDelta' || method === 'command/exec/outputDelta') {
+            const payload = params;
+            const itemId = payload?.itemId ?? payload?.item_id;
+            appendBufferedDelta(this.commandOutputBuffers, itemId, payload?.delta);
+            await this.emitBufferedToolUpdate(itemId, this.commandOutputBuffers);
+            return;
+        }
+        if (method === 'item/fileChange/outputDelta' || method === 'file_change/output_delta') {
+            const payload = params;
+            const itemId = payload?.itemId ?? payload?.item_id;
+            appendBufferedDelta(this.fileChangeOutputBuffers, itemId, payload?.delta);
+            await this.emitBufferedToolUpdate(itemId, this.fileChangeOutputBuffers);
+            return;
+        }
+        if (method === 'turn/plan/updated') {
+            const mapped = mapPlanUpdate(params);
+            if (mapped) {
+                this.markProviderOutputSeen();
+                const detail = normalizeOptionalString(mapped.detail ?? mapped.title);
+                if (this.activeCodexMode === 'plan' && detail) {
+                    this.latestPlanText = detail;
+                }
+                await this.activeSink?.sendUi?.({
+                    kind: 'plan',
+                    mode: this.activeUiMode,
+                    title: mapped.title,
+                    detail: mapped.detail,
+                    silent: true,
+                });
+            }
+            return;
+        }
+        const usage = mapUsageNotification(method, params);
+        if (usage) {
+            await this.activeSink?.sendUi?.({
+                kind: 'usage',
+                mode: this.activeUiMode,
+                ...usage,
+            });
+            return;
+        }
+        if (method === 'thread/compacted') {
+            const payload = params;
+            await this.emitCompactEvent({
+                threadId: payload?.threadId,
+                turnId: payload?.turnId,
+                source: 'thread_compacted',
+            });
+            return;
+        }
+        if (method === 'rawResponseItem/completed') {
+            const payload = params;
+            const item = asRecord(payload?.item);
+            if (item?.type === 'compaction') {
+                await this.emitCompactEvent({
+                    threadId: payload?.threadId,
+                    turnId: payload?.turnId,
+                    itemId: normalizeOptionalString(item.id),
+                    source: 'raw_response_item',
+                });
+            }
+            return;
+        }
+        const task = mapTaskNotification(method, params);
+        if (task) {
+            this.markProviderOutputSeen();
+            await this.activeSink?.sendUi?.({
+                kind: 'task',
+                mode: this.activeUiMode,
+                title: task.title,
+                detail: task.detail,
+                silent: true,
+            });
+            return;
+        }
+        if (method === 'item/started') {
+            const item = params?.item;
+            await this.handleThreadItem(item, { stage: 'start' });
+            return;
+        }
+        if (method === 'item/updated') {
+            const item = params?.item;
+            await this.handleThreadItem(item, { stage: 'update' });
+            return;
+        }
+        if (method === 'item/completed') {
+            const item = params?.item;
+            await this.handleThreadItem(item, { stage: 'complete' });
+            return;
+        }
+        if (method === 'turn/completed') {
+            this.markProviderOutputSeen();
+            this.awaitingTurnStartedNotification = false;
+            const payload = params;
+            const turn = payload?.turn;
+            await this.emitCompactEventsFromThreadItems(payload?.threadId, turn);
+            const status = turn?.status ?? '';
+            if (this.policyViolationError) {
+                this.activeTurnCompletion?.resolve({
+                    stopReason: 'failed',
+                    error: this.policyViolationError,
+                });
+            }
+            else if (status === 'failed') {
+                this.activeTurnCompletion?.resolve({
+                    stopReason: 'failed',
+                    error: turn?.error?.message?.trim() || 'Codex app-server turn failed.',
+                });
+            }
+            else if (status === 'interrupted' || this.cancelRequested) {
+                if (!this.cancelRequested
+                    && (this.currentTurnAssistantTextRepairTriggered || this.assistantTextRepairSteerActive)) {
+                    await this.handleDefaultTurnCompleted();
+                    return;
+                }
+                this.activeTurnCompletion?.resolve({ stopReason: 'cancelled' });
+            }
+            else if (this.activeCodexMode === 'plan') {
+                this.currentTurnId = null;
+                this.pendingPlanApprovalAfterTurn = true;
+            }
+            else {
+                await this.handleDefaultTurnCompleted();
+            }
+            return;
+        }
+    }
+    async emitCompactEventsFromThreadItems(threadId, turn) {
+        if (!Array.isArray(turn?.items))
+            return;
+        for (const item of turn.items) {
+            const row = asRecord(item);
+            if (row?.type !== 'contextCompaction')
+                continue;
+            await this.emitCompactEvent({
+                threadId,
+                turnId: normalizeOptionalString(turn.id) ?? this.currentTurnId,
+                itemId: normalizeOptionalString(row.id),
+                source: 'thread_item',
+            });
+        }
+    }
+    async emitCompactEvent(params) {
+        const threadId = normalizeOptionalString(params.threadId) ?? this.sessionId;
+        const turnId = normalizeOptionalString(params.turnId) ?? this.currentTurnId;
+        if (!threadId || !turnId)
+            return;
+        const itemId = normalizeOptionalString(params.itemId);
+        const eventKey = [threadId, turnId, itemId ?? '-'].join(':');
+        if (this.compactEventKeys.has(eventKey))
+            return;
+        this.compactEventKeys.add(eventKey);
+        this.markProviderOutputSeen();
+        await this.activeSink?.sendUi?.({
+            kind: 'compact',
+            mode: this.activeUiMode,
+            threadId,
+            turnId,
+            ...(itemId ? { itemId } : {}),
+            source: params.source,
+            eventKey,
+        });
+    }
+    async handleThreadItem(item, options) {
+        if (!item || typeof item !== 'object')
+            return;
+        const threadItem = item;
+        const itemId = normalizeOptionalString(threadItem.id) ?? normalizeOptionalString(threadItem.toolCallId);
+        if (!itemId)
+            return;
+        this.markProviderOutputSeen();
+        this.captureShellToolCallInput(threadItem, itemId);
+        const bigbangDetectionItem = this.buildShellToolResultBigbangDetectionItem(threadItem, itemId);
+        if (isShellToolCallOrResultItem(threadItem)) {
+            this.sawNonChatToolThisRun = true;
+        }
+        if (threadItem.type === 'contextCompaction') {
+            await this.emitCompactEvent({
+                threadId: this.sessionId,
+                turnId: this.currentTurnId,
+                itemId,
+                source: 'thread_item',
+            });
+            return;
+        }
+        if (threadItem.type === 'agentMessage' && options.stage === 'complete') {
+            const fullText = typeof threadItem.text === 'string' ? threadItem.text : '';
+            const buffered = this.agentMessageBuffers.get(itemId) ?? '';
+            const delta = fullText.startsWith(buffered) ? fullText.slice(buffered.length) : fullText;
+            if (delta) {
+                if (this.soloMode || this.activeCodexMode === 'plan') {
+                    await this.sendAssistantText(delta);
+                }
+                else {
+                    await this.captureAssistantTextViolation(delta);
+                }
+            }
+            await this.captureProposedPlanFromText(fullText);
+            this.agentMessageBuffers.delete(itemId);
+            return;
+        }
+        if (threadItem.type === 'plan' && options.stage === 'complete') {
+            const fullText = normalizeOptionalString(threadItem.text)
+                ?? normalizeOptionalString(this.planItemBuffers.get(itemId))
+                ?? '';
+            await this.recordPlanText(fullText, 'plan updated');
+            this.planItemBuffers.delete(itemId);
+            return;
+        }
+        if (threadItem.type === 'reasoning' && options.stage === 'complete') {
+            const fullText = [...(threadItem.summary ?? []), ...(threadItem.content ?? [])].join('\n').trim();
+            const buffered = this.reasoningBuffers.get(itemId) ?? '';
+            const delta = fullText.startsWith(buffered) ? fullText.slice(buffered.length) : fullText;
+            if (delta) {
+                await this.sendThinkingText(delta);
+            }
+            this.reasoningBuffers.delete(itemId);
+            return;
+        }
+        const taskItem = mapTaskItem(threadItem, options.stage);
+        if (taskItem) {
+            await this.activeSink?.sendUi?.({
+                kind: 'task',
+                mode: this.activeUiMode,
+                title: taskItem.title,
+                detail: taskItem.detail,
+                silent: true,
+            });
+            return;
+        }
+        const blockedKinds = this.activeBlockedKinds ?? new Map();
+        const blockedKind = detectBlockedToolKind(threadItem, blockedKinds);
+        if (blockedKind) {
+            if (!this.policyViolationError) {
+                this.policyViolationError = formatBlockedToolMessage(blockedKind, blockedKinds.get(blockedKind) ?? 'disabled');
+                await this.interruptActiveTurn();
+            }
+            return;
+        }
+        const itemTouchesWorkspace = (threadItem.type === 'fileChange'
+            && requestWritesWorkspace(threadItem, this.workspaceRoot)) || (threadItem.type === 'commandExecution'
+            && commandExecutionTouchesWorkspace(threadItem, this.workspaceRoot));
+        if (itemTouchesWorkspace) {
+            try {
+                await this.ensureActiveTurnWorkspaceWriteLock();
+            }
+            catch (error) {
+                this.policyViolationError = `Workspace lock unavailable: ${String(error?.message ?? error)}`;
+                await this.interruptActiveTurn();
+                return;
+            }
+        }
+        await this.captureProposedPlanFromToolItem(threadItem, options.stage);
+        if (!this.soloMode) {
+            this.capturePlanImplementationVisibleReplyFromToolItem(bigbangDetectionItem ?? threadItem, options.stage);
+            this.captureSuccessfulChatSendForCurrentTurn(bigbangDetectionItem ?? threadItem, options.stage);
+        }
+        if (options.stage === 'complete' && threadItem.type === 'tool.result') {
+            this.shellToolCallInputs.delete(itemId);
+        }
+        const mapped = mapToolItem(threadItem, {
+            commandOutput: options.stage === 'complete'
+                ? consumeBufferedOutput(this.commandOutputBuffers, itemId)
+                : peekBufferedOutput(this.commandOutputBuffers, itemId),
+            fileChangeOutput: options.stage === 'complete'
+                ? consumeBufferedOutput(this.fileChangeOutputBuffers, itemId)
+                : peekBufferedOutput(this.fileChangeOutputBuffers, itemId),
+        });
+        if (!mapped)
+            return;
+        if (this.toolCompletedIds.has(mapped.toolCallId)) {
+            return;
+        }
+        if (!isChatMcpToolName(mapped.name)) {
+            this.sawNonChatToolThisRun = true;
+        }
+        if (options.stage === 'start') {
+            if (this.toolStartedIds.has(mapped.toolCallId))
+                return;
+            this.toolStartedIds.add(mapped.toolCallId);
+            this.toolSnapshots.set(mapped.toolCallId, { name: mapped.name, input: mapped.input });
+            await this.activeSink?.sendUi?.({
+                kind: 'tool',
+                mode: this.activeUiMode,
+                title: mapped.name,
+                toolCallId: mapped.toolCallId,
+                input: mapped.input,
+                stage: 'start',
+                status: 'running',
+                detail: mapped.detail,
+                metadata: mapped.metadata,
+            });
+            return;
+        }
+        if (!this.toolStartedIds.has(mapped.toolCallId)) {
+            this.toolStartedIds.add(mapped.toolCallId);
+            this.toolSnapshots.set(mapped.toolCallId, { name: mapped.name, input: mapped.input });
+            await this.activeSink?.sendUi?.({
+                kind: 'tool',
+                mode: this.activeUiMode,
+                title: mapped.name,
+                toolCallId: mapped.toolCallId,
+                input: mapped.input,
+                stage: 'start',
+                status: 'running',
+                detail: mapped.detail,
+                metadata: mapped.metadata,
+            });
+        }
+        if (options.stage === 'update' || mapped.inProgress) {
+            this.toolSnapshots.set(mapped.toolCallId, { name: mapped.name, input: mapped.input });
+            await this.activeSink?.sendUi?.({
+                kind: 'tool',
+                mode: this.activeUiMode,
+                title: mapped.name,
+                toolCallId: mapped.toolCallId,
+                input: mapped.input,
+                detail: mapped.detail ?? mapped.output,
+                stage: 'update',
+                status: 'running',
+                metadata: mapped.metadata,
+            });
+            return;
+        }
+        await this.activeSink?.sendUi?.({
+            kind: 'tool',
+            mode: this.activeUiMode,
+            title: mapped.name,
+            toolCallId: mapped.toolCallId,
+            input: mapped.input,
+            output: mapped.output,
+            stage: 'complete',
+            status: mapped.status,
+            detail: mapped.output,
+            metadata: mapped.metadata,
+        });
+        this.toolCompletedIds.add(mapped.toolCallId);
+    }
+    captureShellToolCallInput(item, itemId) {
+        if (item.type !== 'tool.call' || item.name !== 'shell')
+            return;
+        const input = asRecord(item.input);
+        const command = normalizeOptionalString(input?.command) ?? normalizeOptionalString(item.command);
+        if (!command)
+            return;
+        const cwd = normalizeOptionalString(input?.cwd) ?? normalizeOptionalString(item.cwd);
+        this.shellToolCallInputs.set(itemId, { command, cwd });
+    }
+    buildShellToolResultBigbangDetectionItem(item, itemId) {
+        if (item.type !== 'tool.result')
+            return null;
+        const recorded = this.shellToolCallInputs.get(itemId);
+        const input = asRecord(item.input);
+        const command = recorded?.command
+            ?? normalizeOptionalString(input?.command)
+            ?? normalizeOptionalString(item.command);
+        if (!command)
+            return null;
+        return {
+            type: 'shellToolResult',
+            command,
+            cwd: recorded?.cwd ?? normalizeOptionalString(input?.cwd) ?? normalizeOptionalString(item.cwd),
+            status: item.status,
+            success: item.success,
+            output: item.output,
+            result: item.result,
+            error: item.error,
+        };
+    }
+    async captureProposedPlanFromText(text) {
+        const proposedPlan = extractProposedPlanText(text);
+        if (!proposedPlan)
+            return;
+        await this.recordPlanText(proposedPlan, 'Plan');
+    }
+    async captureProposedPlanFromToolItem(item, stage) {
+        if (stage !== 'complete')
+            return;
+        if (!isChatSendMessageTool(item))
+            return;
+        const args = asRecord(item.arguments);
+        const content = normalizeOptionalString(args?.content);
+        if (!content)
+            return;
+        await this.captureProposedPlanFromText(content);
+    }
+    capturePlanImplementationVisibleReplyFromToolItem(item, stage) {
+        if (stage !== 'complete')
+            return;
+        const bigbangMessageSend = getBigbangMessageSendInfo(item);
+        const mcpMessageSend = isChatSendMessageTool(item);
+        if (!bigbangMessageSend && !mcpMessageSend)
+            return;
+        if (this.agentSurfaceMode === 'bigbang' ? !bigbangMessageSend : !mcpMessageSend)
+            return;
+        const args = asRecord(item.arguments);
+        const content = normalizeOptionalString(args?.content) ?? (bigbangMessageSend ? '<bigbang-message-send>' : null);
+        const kind = bigbangMessageSend?.kind ?? normalizeOptionalString(args?.kind)?.toLowerCase() ?? null;
+        if (!content)
+            return;
+        if (kind !== 'final')
+            return;
+        const status = normalizeToolItemStatus(item.status, item.success);
+        if (bigbangMessageSend?.success !== true && (status.status !== 'completed' || item.error || bigbangMessageSend?.success === false))
+            return;
+        if (isNonPostedSendMessageResult(item.result))
+            return;
+        if (this.planImplementationActive) {
+            this.planImplementationVisibleReplySent = true;
+        }
+        this.currentTurnSuccessfulFinalChatSendCount += 1;
+        this.runSuccessfulFinalChatSendCount += 1;
+        if (bigbangMessageSend) {
+            this.currentTurnSuccessfulBigbangFinalChatSendCount += 1;
+        }
+    }
+    captureSuccessfulChatSendForCurrentTurn(item, stage) {
+        if (stage !== 'complete')
+            return;
+        const bigbangMessageSend = getBigbangMessageSendInfo(item);
+        const mcpMessageSend = isChatSendMessageTool(item);
+        if (!bigbangMessageSend && !mcpMessageSend)
+            return;
+        if (this.agentSurfaceMode === 'bigbang' ? !bigbangMessageSend : !mcpMessageSend)
+            return;
+        if (bigbangMessageSend?.success === true) {
+            this.lastBigbangMessageSendFailureForRepair = null;
+        }
+        else if (bigbangMessageSend?.failureKind) {
+            this.currentTurnBigbangMessageSendFailures.push({
+                messageKind: bigbangMessageSend.kind,
+                failureKind: bigbangMessageSend.failureKind,
+            });
+        }
+        if (isCompletionSafeNonPostedSendMessageResult({ result: item.result, error: item.error })) {
+            this.currentTurnCompletionSafeNonPostedChatSend = true;
+            return;
+        }
+        const status = normalizeToolItemStatus(item.status, item.success);
+        if (bigbangMessageSend?.success !== true && (status.status !== 'completed' || item.error || bigbangMessageSend?.success === false))
+            return;
+        if (isNonPostedSendMessageResult(item.result))
+            return;
+        this.currentTurnSuccessfulChatSend = true;
+        this.currentTurnSuccessfulChatSendCount += 1;
+        this.runSuccessfulChatSendCount += 1;
+    }
+    async recordPlanText(planText, title = 'Plan') {
+        if (this.activeCodexMode !== 'plan')
+            return;
+        const normalized = normalizeOptionalString(planText);
+        if (!normalized)
+            return;
+        this.latestPlanText = normalized;
+        await this.activeSink?.sendUi?.({
+            kind: 'plan',
+            mode: this.activeUiMode,
+            title,
+            detail: normalized,
+            silent: true,
+        });
+    }
+    async emitBufferedToolUpdate(itemId, store) {
+        const normalizedItemId = normalizeOptionalString(itemId);
+        if (!normalizedItemId || !this.toolStartedIds.has(normalizedItemId))
+            return;
+        const snapshot = this.toolSnapshots.get(normalizedItemId);
+        if (!snapshot)
+            return;
+        const detail = peekBufferedOutput(store, normalizedItemId);
+        if (!detail)
+            return;
+        await this.activeSink?.sendUi?.({
+            kind: 'tool',
+            mode: this.activeUiMode,
+            title: snapshot.name,
+            toolCallId: normalizedItemId,
+            input: snapshot.input,
+            detail,
+            stage: 'update',
+            status: 'running',
+        });
+    }
+    async sendAssistantText(text) {
+        if (!text)
+            return;
+        this.markProviderOutputSeen();
+        if (this.planImplementationActive && this.activeCodexMode !== 'plan') {
+            this.planImplementationDeltaBuffer += text;
+        }
+        if (this.activeSink?.sendAgentText) {
+            await this.activeSink.sendAgentText(text);
+            return;
+        }
+        await this.activeSink?.sendText(text);
+    }
+    async sendActivityAssistantText(text) {
+        if (!text)
+            return;
+        this.markProviderOutputSeen();
+        await this.activeSink?.sendActivityText?.(text);
+    }
+    async captureAssistantTextViolation(text) {
+        if (!text)
+            return;
+        if (this.planImplementationActive) {
+            this.planImplementationDeltaBuffer += text;
+        }
+        this.currentTurnAssistantTextBuffer += text;
+        await this.sendActivityAssistantText(text);
+        if (this.assistantTextRepairSteerActive) {
+            this.assistantTextRepairFallbackPending = true;
+        }
+        else if (this.assistantTextRepairActive
+            && !this.planImplementationActive
+            && this.assistantTextRepairStage === 'fresh_repair_turn'
+            && this.activeCodexMode !== 'plan'
+            && this.currentTurnId
+            && this.activeRunId) {
+            const steered = await this.startAssistantTextRepairSteer('repair_turn_follow_up_steer');
+            if (steered) {
+                return;
+            }
+            this.assistantTextRepairSteerActive = false;
+            this.assistantTextRepairFallbackPending = true;
+        }
+        else if (!this.assistantTextRepairActive
+            && this.activeCodexMode !== 'plan'
+            && this.currentTurnId
+            && this.activeRunId) {
+            const steered = await this.startAssistantTextRepairSteer();
+            if (steered) {
+                return;
+            }
+            this.assistantTextRepairSteerActive = false;
+            this.assistantTextRepairFallbackPending = true;
+        }
+        if (!this.currentTurnAssistantTextRepairTriggered) {
+            this.currentTurnAssistantTextRepairTriggered = true;
+            if (this.currentTurnId && !this.cancelRequested) {
+                await this.interruptActiveTurn();
+            }
+        }
+    }
+    async sendThinkingText(text) {
+        if (!text)
+            return;
+        this.markProviderOutputSeen();
+        await this.activeSink?.sendThinkingText?.(text);
+    }
+    async handleCommandExecutionApprovalRequest(params) {
+        this.markProviderOutputSeen();
+        const blockedKinds = this.getEffectiveBlockedKinds();
+        const blockedKind = detectBlockedToolKindForCommandApproval(params, blockedKinds);
+        if (blockedKind) {
+            await this.emitBlockedApprovalEvent(blockedKind, params);
+            return { decision: 'decline' };
+        }
+        if (commandExecutionTouchesWorkspace(params, this.workspaceRoot)) {
+            await this.ensureActiveTurnWorkspaceWriteLock();
+        }
+        return { decision: 'accept' };
+    }
+    async handleFileChangeApprovalRequest(params) {
+        this.markProviderOutputSeen();
+        const blockedKinds = this.getEffectiveBlockedKinds();
+        const blockedKind = detectBlockedToolKindForApproval('item/fileChange/requestApproval', params, blockedKinds);
+        if (blockedKind) {
+            await this.emitBlockedApprovalEvent(blockedKind, params);
+            return { decision: 'decline' };
+        }
+        if (requestWritesWorkspace(params, this.workspaceRoot)) {
+            await this.ensureActiveTurnWorkspaceWriteLock();
+        }
+        return { decision: 'accept' };
+    }
+    async handlePermissionsApprovalRequest(params) {
+        this.markProviderOutputSeen();
+        const blockedKinds = this.getEffectiveBlockedKinds();
+        const blockedKind = detectBlockedToolKindForApproval('item/permissions/requestApproval', params, blockedKinds);
+        if (blockedKind) {
+            await this.emitBlockedApprovalEvent(blockedKind, params);
+        }
+        if (!blockedKinds.has('edit') && permissionsRequestWritesWorkspace(params, this.workspaceRoot)) {
+            await this.ensureActiveTurnWorkspaceWriteLock();
+        }
+        else if (!blockedKinds.has('read') && permissionsRequestReadsWorkspace(params, this.workspaceRoot)) {
+            await this.waitForWorkspaceWritesBeforeRead();
+        }
+        return buildPermissionsApprovalResponse(params, blockedKinds);
+    }
+    async handleUserInputRequest(params) {
+        this.markProviderOutputSeen();
+        if (!this.activeSink?.requestPermission) {
+            return buildUserInputResponse(params);
+        }
+        if (this.pendingUserInput) {
+            throw new Error('Another Codex app-server user input request is already pending.');
+        }
+        const requestId = buildUserInputRequestId(params, this.sessionKey);
+        let resolvePending;
+        const pending = new Promise((resolve) => {
+            resolvePending = resolve;
+        });
+        this.pendingUserInput = {
+            requestId,
+            resolve: resolvePending,
+            params,
+        };
+        try {
+            await this.activeSink.requestPermission({
+                uiMode: this.activeUiMode,
+                sessionKey: this.sessionKey,
+                requestId,
+                toolTitle: 'Codex requested user input',
+                toolKind: 'other',
+                toolName: 'request_user_input',
+                toolArgs: params,
+                approvalKind: 'question',
+                title: 'Question',
+                input: { questions: normalizeCodexQuestionPrompts(params) },
+            });
+        }
+        catch (error) {
+            if (this.pendingUserInput?.requestId === requestId) {
+                this.pendingUserInput = null;
+            }
+            throw error;
+        }
+        return await pending;
+    }
+    async emitPlanApprovalRequest(planText) {
+        this.markProviderOutputSeen();
+        if (!this.activeSink?.requestPermission) {
+            this.activeTurnCompletion?.resolve({ stopReason: 'completed' });
+            return;
+        }
+        const requestId = `codex-plan:${randomUUID()}`;
+        this.pendingPlanApproval = {
+            requestId,
+            planText,
+        };
+        await this.activeSink.requestPermission({
+            uiMode: this.activeUiMode,
+            sessionKey: this.sessionKey,
+            requestId,
+            toolTitle: 'Codex plan approval',
+            toolKind: 'other',
+            toolName: 'CodexPlanApproval',
+            toolArgs: { plan: planText },
+            approvalKind: 'plan',
+            title: 'Plan',
+            description: 'Review the proposed plan before implementation starts.',
+            input: { plan: planText },
+            actions: buildPlanApprovalActions(),
+        });
+    }
+    async emitBlockedApprovalEvent(toolKind, params) {
+        const blockedKinds = this.getEffectiveBlockedKinds();
+        const message = formatBlockedToolMessage(toolKind, blockedKinds.get(toolKind) ?? 'disabled');
+        const toolCallId = extractApprovalItemId(params) ?? `approval-denied-${randomUUID()}`;
+        await this.activeSink?.sendUi?.({
+            kind: 'tool',
+            mode: this.activeUiMode,
+            title: 'permission_denied',
+            toolCallId,
+            input: params,
+            stage: 'start',
+        });
+        await this.activeSink?.sendUi?.({
+            kind: 'tool',
+            mode: this.activeUiMode,
+            title: 'permission_denied',
+            toolCallId,
+            input: params,
+            output: message,
+            detail: message,
+            stage: 'complete',
+            status: 'failed',
+        });
+    }
+    getEffectiveBlockedKinds() {
+        return this.activeBlockedKinds
+            ? this.activeBlockedKinds
+            : this.buildCompiledToolPolicy().blockedKinds;
+    }
+    buildThreadStartParams(params, options) {
+        return {
+            ...(this.model ? { model: this.model } : {}),
+            ...(this.serviceTier ? { serviceTier: this.serviceTier } : {}),
+            cwd: this.workspaceRoot,
+            approvalPolicy: 'never',
+            ...(params.policy.permissionProfile
+                ? { permissionProfile: params.policy.permissionProfile }
+                : { sandbox: 'danger-full-access' }),
+            ...(params.systemPromptText ? { developerInstructions: params.systemPromptText } : {}),
+            ...(params.policy.threadConfig ? { config: params.policy.threadConfig } : {}),
+            experimentalRawEvents: false,
+            ...(options.persistExtendedHistory ? { persistExtendedHistory: true } : {}),
+        };
+    }
+    buildThreadResumeParams(params, options) {
+        return {
+            threadId: params.sessionId,
+            ...(this.model ? { model: this.model } : {}),
+            ...(this.serviceTier ? { serviceTier: this.serviceTier } : {}),
+            cwd: this.workspaceRoot,
+            approvalPolicy: 'never',
+            ...(params.policy.permissionProfile
+                ? { permissionProfile: params.policy.permissionProfile }
+                : { sandbox: 'danger-full-access' }),
+            ...(params.systemPromptText ? { developerInstructions: params.systemPromptText } : {}),
+            ...(params.policy.threadConfig ? { config: params.policy.threadConfig } : {}),
+            ...(options.persistExtendedHistory ? { persistExtendedHistory: true } : {}),
+        };
+    }
+    async buildTurnStartParams(params) {
+        const codexMode = params.codexMode ?? this.activeCodexMode;
+        const collaborationMode = await this.buildCollaborationMode(codexMode);
+        const promptText = codexMode === 'plan'
+            ? joinPromptContext(CODEX_PLAN_MODE_PROMPT, params.promptText)
+            : params.promptText;
+        const materializedAttachments = await this.materializeAssetAttachments(params.attachments, this.activeRunId);
+        return {
+            threadId: params.threadId,
+            input: buildCodexTurnInput(promptText, materializedAttachments),
+            cwd: this.workspaceRoot,
+            approvalPolicy: 'never',
+            ...(params.compiledPolicy.permissionProfile
+                ? { permissionProfile: params.compiledPolicy.permissionProfile }
+                : { sandboxPolicy: { type: 'dangerFullAccess' } }),
+            ...(this.model ? { model: this.model } : {}),
+            ...(this.serviceTier ? { serviceTier: this.serviceTier } : {}),
+            ...(this.reasoningEffort ? { effort: this.reasoningEffort } : {}),
+            ...(collaborationMode ? { collaborationMode } : {}),
+        };
+    }
+    async materializeAssetAttachments(attachments, runId) {
+        return this.attachmentMaterializer.materialize(attachments, { runId });
+    }
+    async buildCollaborationMode(codexMode) {
+        const mode = codexMode === 'plan' ? 'plan' : 'default';
+        if (mode === 'default' && !this.model && !this.cachedCollaborationModeModel) {
+            return null;
+        }
+        const model = await this.resolveCollaborationModeModel({ strict: mode === 'plan' });
+        return {
+            mode,
+            settings: {
+                model,
+                reasoning_effort: this.reasoningEffort,
+                developer_instructions: null,
+            },
+        };
+    }
+    async resolveCollaborationModeModel(options) {
+        if (this.model)
+            return this.model;
+        if (this.cachedCollaborationModeModel)
+            return this.cachedCollaborationModeModel;
+        if (!options.strict)
+            return 'default';
+        const client = await this.ensureClient();
+        let defaultModel = null;
+        try {
+            const response = await client.request('model/list', { limit: 100 }, MODEL_LIST_TIMEOUT_MS);
+            defaultModel = extractDefaultCodexModel(response);
+        }
+        catch (error) {
+            if (options.strict) {
+                throw error;
+            }
+            log.warn('[codex-app-server] failed to resolve default collaboration mode model; using app-server default sentinel', {
+                sessionKey: this.sessionKey,
+                error: String(error?.message ?? error),
+            });
+        }
+        if (!defaultModel) {
+            if (!options.strict) {
+                this.cachedCollaborationModeModel = 'default';
+                return this.cachedCollaborationModeModel;
+            }
+            throw new Error('Codex plan mode requires a model, but model/list did not return a default model.');
+        }
+        this.cachedCollaborationModeModel = defaultModel;
+        return defaultModel;
+    }
+    buildCompiledToolPolicy(overrideDisabledToolKinds = []) {
+        const blockedKinds = new Map();
+        for (const toolKind of overrideDisabledToolKinds) {
+            blockedKinds.set(toolKind, 'disabled');
+        }
+        if (this.toolAuth && this.bindingKey) {
+            for (const policy of this.toolAuth.listPersistentPolicies(this.bindingKey, 'reject')) {
+                if (!blockedKinds.has(policy.toolKind)) {
+                    blockedKinds.set(policy.toolKind, 'policy_reject');
+                }
+            }
+        }
+        const permissionProfile = buildPermissionProfile({
+            workspaceRoot: this.workspaceRoot,
+            blockedKinds,
+        });
+        const threadConfig = this.buildThreadConfig({
+            blockedKinds,
+            permissionProfile,
+        });
+        return {
+            blockedKinds,
+            permissionProfile,
+            threadConfig,
+            promptPreamble: buildToolPolicyPromptPreamble(blockedKinds),
+            threadPolicySignature: JSON.stringify({
+                blockedKinds: [...blockedKinds.entries()].sort(([left], [right]) => left.localeCompare(right)),
+                permissionProfile,
+                threadConfig,
+            }),
+        };
+    }
+    buildThreadConfig(params) {
+        const channelBridgeConfig = this.agentSurfaceMode === 'mcp'
+            ? toCodexMcpServerConfig(this.channelBridgeMcpEntry, this.workspaceRoot)
+            : null;
+        const config = {};
+        if (channelBridgeConfig) {
+            config.mcp_servers = {
+                [channelBridgeConfig.name]: channelBridgeConfig.config,
+            };
+        }
+        if (params.blockedKinds.has('fetch') || params.permissionProfile?.network?.enabled === false) {
+            config.web_search = 'disabled';
+        }
+        return Object.keys(config).length > 0 ? config : null;
+    }
+    resetConfiguredMcpServerStates() {
+        for (const name of this.getConfiguredMcpServerNames()) {
+            this.mcpServerStartupStates.delete(name);
+        }
+        this.resolvePendingMcpStatusWaiters();
+    }
+    getConfiguredMcpServerNames() {
+        if (this.agentSurfaceMode !== 'mcp')
+            return [];
+        const entry = toCodexMcpServerConfig(this.channelBridgeMcpEntry, this.workspaceRoot);
+        return entry ? [entry.name] : [];
+    }
+    async waitForConfiguredMcpServersReady() {
+        const configuredServerNames = this.getConfiguredMcpServerNames();
+        if (configuredServerNames.length === 0)
+            return;
+        const deadline = Date.now() + MCP_STARTUP_TIMEOUT_MS;
+        for (const serverName of configuredServerNames) {
+            for (;;) {
+                const state = this.mcpServerStartupStates.get(serverName);
+                if (state?.status === 'ready')
+                    break;
+                if (state && state.status !== 'starting') {
+                    throw new Error(state.error ?? `Codex MCP server ${serverName} failed to start (${state.status}).`);
+                }
+                const remainingMs = deadline - Date.now();
+                if (remainingMs <= 0) {
+                    throw new Error(`Timed out waiting for Codex MCP server ${serverName} to become ready.`);
+                }
+                await this.waitForMcpStatusChange(Math.min(remainingMs, 250));
+            }
+        }
+    }
+    waitForMcpStatusChange(timeoutMs) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const done = () => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                this.mcpStatusChangeWaiters.delete(done);
+                resolve();
+            };
+            const timer = setTimeout(done, timeoutMs);
+            this.mcpStatusChangeWaiters.add(done);
+        });
+    }
+    async waitForActiveTurnId(timeoutMs) {
+        if (this.currentTurnId)
+            return this.currentTurnId;
+        const deadline = Date.now() + timeoutMs;
+        while (!this.currentTurnId && this.activeRunId && !this.cancelRequested && Date.now() < deadline) {
+            await delay(25);
+        }
+        return this.currentTurnId;
+    }
+    resolvePendingMcpStatusWaiters() {
+        const waiters = [...this.mcpStatusChangeWaiters];
+        this.mcpStatusChangeWaiters.clear();
+        for (const waiter of waiters) {
+            waiter();
+        }
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeOptionalString(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim();
+    return normalized ? normalized : null;
+}
+function normalizeCodexReasoningEffort(value) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized)
+        return null;
+    switch (normalized) {
+        case 'none':
+        case 'minimal':
+        case 'low':
+        case 'medium':
+        case 'high':
+        case 'xhigh':
+            return normalized;
+        default:
+            return null;
+    }
+}
+function normalizeCodexMode(value) {
+    return value === 'default' || value === 'plan' ? value : null;
+}
+function normalizeCodexServiceTier(value) {
+    return value === 'fast' || value === 'flex' ? value : null;
+}
+function extractDefaultCodexModel(value) {
+    const data = Array.isArray(value?.data)
+        ? value.data
+        : [];
+    const defaultModel = data.find((entry) => entry?.isDefault === true)
+        ?? data[0];
+    if (!defaultModel || typeof defaultModel !== 'object')
+        return null;
+    const model = defaultModel;
+    return normalizeOptionalString(model.model) ?? normalizeOptionalString(model.id);
+}
+function toCodexMcpServerConfig(entry, workspaceRoot) {
+    if (!entry)
+        return null;
+    if ('command' in entry) {
+        return {
+            name: entry.name,
+            config: {
+                command: entry.command,
+                args: [...entry.args],
+                cwd: workspaceRoot,
+                env: Object.fromEntries((entry.env ?? []).map((item) => [item.name, item.value])),
+                enabled: true,
+                required: true,
+                default_tools_approval_mode: 'approve',
+            },
+        };
+    }
+    if (entry.type === 'http' || entry.type === 'sse') {
+        return {
+            name: entry.name,
+            config: {
+                url: entry.url,
+                http_headers: Object.fromEntries((entry.headers ?? []).map((item) => [item.name, item.value])),
+                enabled: true,
+                required: true,
+                default_tools_approval_mode: 'approve',
+            },
+        };
+    }
+    return null;
+}
+function joinPromptContext(...parts) {
+    return parts
+        .map((part) => part?.trim())
+        .filter((part) => Boolean(part))
+        .join('\n\n');
+}
+function buildCodexTurnInput(promptText, attachments) {
+    const blocks = [
+        { type: 'text', text: promptText, text_elements: [] },
+    ];
+    for (const [index, attachment] of (attachments ?? []).entries()) {
+        const imagePath = resolveLocalImageAttachmentPath(attachment);
+        if (imagePath) {
+            blocks.push({ type: 'localImage', path: imagePath });
+            continue;
+        }
+        const localPath = normalizeOptionalString(attachment.preferredLocalPath) ?? resolveLocalAttachmentPath(attachment);
+        const attachmentId = normalizeOptionalString(attachment.assetId) ?? extractAttachmentIdFromUri(attachment.uri);
+        if (!localPath && attachmentId && promptAlreadyReferencesAttachment(promptText, attachmentId)) {
+            continue;
+        }
+        blocks.push({
+            type: 'text',
+            text: formatAttachmentTextReference(attachment, index, localPath, attachmentId),
+            text_elements: [],
+        });
+    }
+    return blocks;
+}
+function appendBufferedDelta(store, itemId, delta) {
+    if (!itemId || !delta)
+        return;
+    const existing = store.get(itemId) ?? [];
+    existing.push(delta);
+    store.set(itemId, existing);
+}
+function consumeBufferedOutput(store, itemId) {
+    const chunks = store.get(itemId);
+    if (!chunks || chunks.length === 0)
+        return null;
+    store.delete(itemId);
+    return chunks.join('');
+}
+function peekBufferedOutput(store, itemId) {
+    const chunks = store.get(itemId);
+    if (!chunks || chunks.length === 0)
+        return null;
+    return chunks.join('');
+}
+function mergeAggregatedAndBufferedOutput(aggregated, buffered) {
+    if (aggregated && buffered) {
+        if (aggregated.includes(buffered))
+            return aggregated;
+        if (buffered.includes(aggregated))
+            return buffered;
+        return [aggregated, buffered].join('\n\n');
+    }
+    return aggregated ?? buffered ?? null;
+}
+function summarizeJson(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        const json = JSON.stringify(value, null, 2);
+        return typeof json === 'string' ? json : String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function isHeldStaleSendMessageResult(value) {
+    if (isHeldStaleResultShape(value))
+        return true;
+    const text = summarizeJson(value);
+    return text.includes('Draft held; nothing was posted')
+        || text.includes('Your draft was not sent because newer messages exist on this surface');
+}
+function isNonPostedSendMessageResult(value) {
+    if (isHeldStaleSendMessageResult(value))
+        return true;
+    const text = summarizeJson(value);
+    return text.includes('Nothing was confirmed posted')
+        || text.includes('success without a messageId');
+}
+function isCompletionSafeNonPostedSendMessageResult(value) {
+    if (isTaskThreadPostFinalDuplicateResultShape(value))
+        return true;
+    const record = asRecord(value);
+    const errorTexts = [
+        normalizeOptionalString(record?.error),
+        normalizeOptionalString(asRecord(record?.error)?.message),
+        normalizeOptionalString(asRecord(record?.result)?.error),
+        normalizeOptionalString(asRecord(record?.result)?.message),
+    ].filter((text) => Boolean(text));
+    if (errorTexts.some(isCompletionSafePostFinalDuplicateText))
+        return true;
+    return isCompletionSafePostFinalDuplicateText(summarizeJson(value));
+}
+function isCompletionSafePostFinalDuplicateText(text) {
+    return (text.includes('task_thread_post_final_duplicate')
+        && text.includes('completionSafe')) || (text.includes('already sent its substantive final reply')
+        && text.includes('another user-visible message'));
+}
+function isTaskThreadPostFinalDuplicateResultShape(value, depth = 0) {
+    if (depth > 4 || value == null)
+        return false;
+    if (Array.isArray(value)) {
+        return value.some((item) => isTaskThreadPostFinalDuplicateResultShape(item, depth + 1));
+    }
+    if (typeof value !== 'object')
+        return false;
+    const record = value;
+    if (record.blockedReason === 'task_thread_post_final_duplicate'
+        && record.nonPosted === true
+        && record.completionSafe === true) {
+        return true;
+    }
+    for (const key of ['structuredContent', 'result', 'data', 'content', 'text', 'output', 'error']) {
+        if (isTaskThreadPostFinalDuplicateResultShape(record[key], depth + 1))
+            return true;
+    }
+    return false;
+}
+function isHeldStaleResultShape(value, depth = 0) {
+    if (depth > 4 || value == null)
+        return false;
+    if (Array.isArray(value)) {
+        return value.some((item) => isHeldStaleResultShape(item, depth + 1));
+    }
+    if (typeof value !== 'object')
+        return false;
+    const record = value;
+    if (record.held === true && record.stale === true)
+        return true;
+    for (const key of ['structuredContent', 'result', 'data', 'content', 'text', 'output']) {
+        if (isHeldStaleResultShape(record[key], depth + 1))
+            return true;
+    }
+    return false;
+}
+function summarizeFileChanges(changes) {
+    if (!Array.isArray(changes) || changes.length === 0) {
+        return 'Applied file changes.';
+    }
+    return changes
+        .map((change) => `${change.kind ?? 'update'} ${change.path ?? '(unknown file)'}`)
+        .join('\n');
+}
+function mapPlanUpdate(params) {
+    const payload = asRecord(params);
+    if (!payload)
+        return { title: 'plan updated' };
+    if (Array.isArray(payload.plan)) {
+        const detailParts = [
+            normalizeOptionalString(payload.explanation),
+            formatPlanChecklist(payload.plan),
+        ].filter((value) => Boolean(value));
+        return {
+            title: 'plan updated',
+            ...(detailParts.length ? { detail: detailParts.join('\n\n') } : {}),
+        };
+    }
+    const plan = asRecord(payload.plan) ?? payload;
+    const title = normalizeOptionalString(plan.title)
+        ?? normalizeOptionalString(plan.name)
+        ?? 'plan updated';
+    const detail = normalizeOptionalString(plan.markdown)
+        ?? normalizeOptionalString(plan.detail)
+        ?? formatPlanChecklist(plan.items ?? plan.steps ?? plan.todos ?? plan.tasks);
+    return { title, ...(detail ? { detail } : {}) };
+}
+function formatPlanChecklist(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const lines = value
+        .map((item) => {
+        const record = asRecord(item);
+        const text = normalizeOptionalString(record?.text)
+            ?? normalizeOptionalString(record?.step)
+            ?? normalizeOptionalString(record?.title)
+            ?? normalizeOptionalString(record?.description)
+            ?? (typeof item === 'string' ? normalizeOptionalString(item) : null);
+        if (!text)
+            return null;
+        const status = normalizeOptionalString(record?.status)?.toLowerCase() ?? '';
+        const checked = ['done', 'completed', 'complete', 'success', 'succeeded'].includes(status);
+        return `- [${checked ? 'x' : ' '}] ${text}`;
+    })
+        .filter((line) => Boolean(line));
+    return lines.length > 0 ? lines.join('\n') : undefined;
+}
+function extractProposedPlanText(text) {
+    const match = /<proposed_plan>\s*([\s\S]*?)\s*<\/proposed_plan>/i.exec(text);
+    return normalizeOptionalString(match?.[1]);
+}
+function isChatSendMessageTool(item) {
+    const toolName = item.server && item.tool
+        ? `${item.server}/${item.tool}`
+        : item.namespace && item.tool
+            ? `${item.namespace}.${item.tool}`
+            : item.tool ?? '';
+    return toolName === 'chat/send_message'
+        || toolName === 'chat.send_message'
+        || toolName === 'send_message';
+}
+function isChatMcpToolName(name) {
+    return name === 'send_message'
+        || name.startsWith('chat/')
+        || name.startsWith('chat.');
+}
+function extractLatestPlanTextFromThreadReadResponse(value) {
+    const payload = asRecord(value);
+    const thread = asRecord(payload?.thread) ?? payload;
+    if (!thread)
+        return null;
+    const turns = Array.isArray(thread.turns) ? thread.turns : [];
+    for (let index = turns.length - 1; index >= 0; index -= 1) {
+        const planText = extractPlanTextFromSnapshotValue(turns[index], 0);
+        if (planText)
+            return planText;
+    }
+    return extractPlanTextFromSnapshotValue(thread, 0);
+}
+function extractCompletedTurnToolItems(value, turnId) {
+    if (!turnId)
+        return [];
+    const payload = asRecord(value);
+    const thread = asRecord(payload?.thread) ?? payload;
+    if (!thread)
+        return [];
+    const turns = Array.isArray(thread.turns) ? thread.turns : [];
+    const selectedTurn = selectSnapshotTurn(turns, turnId);
+    if (!selectedTurn)
+        return [];
+    return collectToolItemsFromSnapshotValue(selectedTurn, 0);
+}
+function selectSnapshotTurn(turns, turnId) {
+    if (turns.length === 0 || !turnId)
+        return null;
+    for (let index = turns.length - 1; index >= 0; index -= 1) {
+        const turn = asRecord(turns[index]);
+        const id = normalizeOptionalString(turn?.id)
+            ?? normalizeOptionalString(turn?.turnId)
+            ?? normalizeOptionalString(turn?.turn_id);
+        if (id === turnId)
+            return turns[index];
+    }
+    return null;
+}
+function collectToolItemsFromSnapshotValue(value, depth) {
+    if (depth > 8 || value == null)
+        return [];
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => collectToolItemsFromSnapshotValue(item, depth + 1));
+    }
+    const record = asRecord(value);
+    if (!record)
+        return [];
+    if (isToolSnapshotItem(record))
+        return [record];
+    const result = [];
+    for (const key of ['items', 'entries', 'children']) {
+        const child = record[key];
+        if (Array.isArray(child)) {
+            result.push(...collectToolItemsFromSnapshotValue(child, depth + 1));
+        }
+    }
+    return result;
+}
+function isToolSnapshotItem(item) {
+    const type = normalizeOptionalString(item.type)?.toLowerCase();
+    return type === 'commandexecution'
+        || type === 'filechange'
+        || type === 'mcptoolcall'
+        || type === 'dynamictoolcall'
+        || type === 'tool.call'
+        || type === 'tool.result'
+        || type === 'websearch';
+}
+function isShellToolCallOrResultItem(item) {
+    return (item.type === 'tool.call' || item.type === 'tool.result') && item.name === 'shell';
+}
+function isWorkspaceSensitiveToolItem(item, workspaceRoot) {
+    const record = asRecord(item);
+    if (!record)
+        return false;
+    const type = normalizeOptionalString(record.type)?.toLowerCase();
+    if (type === 'filechange') {
+        return requestWritesWorkspace(record, workspaceRoot);
+    }
+    if (type === 'commandexecution') {
+        return commandExecutionTouchesWorkspace(record, workspaceRoot);
+    }
+    return false;
+}
+function extractPlanTextFromSnapshotValue(value, depth) {
+    if (depth > 8 || value == null)
+        return null;
+    if (typeof value === 'string') {
+        return extractProposedPlanText(value);
+    }
+    if (Array.isArray(value)) {
+        for (let index = value.length - 1; index >= 0; index -= 1) {
+            const planText = extractPlanTextFromSnapshotValue(value[index], depth + 1);
+            if (planText)
+                return planText;
+        }
+        return null;
+    }
+    const record = asRecord(value);
+    if (!record)
+        return null;
+    for (const key of ['plan', 'proposedPlan', 'proposed_plan']) {
+        const planText = extractPlanTextFromPlanLikeValue(record[key], depth + 1);
+        if (planText)
+            return planText;
+    }
+    const type = normalizeOptionalString(record.type)?.toLowerCase() ?? '';
+    if (type.includes('plan')) {
+        const planText = extractPlanTextFromPlanLikeValue(record, depth + 1);
+        if (planText)
+            return planText;
+    }
+    for (const key of ['content', 'text', 'message', 'markdown']) {
+        const raw = normalizeOptionalString(record[key]);
+        const planText = raw ? extractProposedPlanText(raw) : null;
+        if (planText)
+            return planText;
+    }
+    for (const key of [
+        'arguments',
+        'input',
+        'items',
+        'events',
+        'messages',
+        'output',
+        'outputs',
+        'response',
+        'result',
+        'turn',
+        'turns',
+    ]) {
+        const planText = extractPlanTextFromSnapshotValue(record[key], depth + 1);
+        if (planText)
+            return planText;
+    }
+    return null;
+}
+function extractPlanTextFromPlanLikeValue(value, depth) {
+    if (depth > 8 || value == null)
+        return null;
+    if (typeof value === 'string') {
+        return normalizeOptionalString(value);
+    }
+    if (Array.isArray(value)) {
+        return formatPlanChecklist(value) ?? extractPlanTextFromSnapshotValue(value, depth + 1);
+    }
+    const record = asRecord(value);
+    if (!record)
+        return null;
+    const direct = normalizeOptionalString(record.markdown)
+        ?? normalizeOptionalString(record.detail)
+        ?? normalizeOptionalString(record.text)
+        ?? normalizeOptionalString(record.content);
+    if (direct)
+        return extractProposedPlanText(direct) ?? direct;
+    return formatPlanChecklist(record.items ?? record.steps ?? record.todos ?? record.tasks)
+        ?? extractPlanTextFromSnapshotValue(record, depth + 1);
+}
+function mapTaskNotification(method, params) {
+    if (method !== 'codex/event/task_complete' && method !== 'codex/event')
+        return null;
+    const payload = asRecord(params);
+    if (!payload)
+        return null;
+    const eventType = normalizeOptionalString(payload.type);
+    if (method === 'codex/event' && eventType !== 'task_complete')
+        return null;
+    const task = asRecord(payload.task) ?? payload;
+    const title = normalizeOptionalString(task.title)
+        ?? normalizeOptionalString(task.name)
+        ?? 'task complete';
+    const detail = normalizeOptionalString(task.detail)
+        ?? normalizeOptionalString(task.summary)
+        ?? normalizeOptionalString(task.message);
+    return { title, ...(detail ? { detail } : {}) };
+}
+function mapTaskItem(item, stage) {
+    const type = normalizeOptionalString(item.type)?.toLowerCase();
+    if (!type || (!type.includes('task') && !type.includes('todo')))
+        return null;
+    const title = normalizeOptionalString(item.title)
+        ?? normalizeOptionalString(item.text)
+        ?? normalizeOptionalString(item.description)
+        ?? (stage === 'complete' ? 'task complete' : 'task updated');
+    const status = normalizeOptionalString(item.status);
+    const detailParts = [
+        status ? `status: ${status}` : null,
+        normalizeOptionalString(item.detail),
+        normalizeOptionalString(item.description),
+    ].filter((value) => Boolean(value));
+    return {
+        title,
+        ...(detailParts.length ? { detail: detailParts.join('\n') } : {}),
+    };
+}
+function mapUsageNotification(method, params) {
+    const payload = asRecord(params);
+    const payloadType = normalizeOptionalString(payload?.type);
+    const looksLikeUsage = method.toLowerCase().includes('usage')
+        || method.toLowerCase().includes('token')
+        || payloadType === 'token_count'
+        || payloadType === 'usage';
+    if (!looksLikeUsage)
+        return null;
+    const usage = parseUsagePayload(payload ?? {});
+    if (!usage)
+        return null;
+    return {
+        ...usage,
+        metadata: {
+            method,
+            ...(payloadType ? { eventType: payloadType } : {}),
+        },
+    };
+}
+function parseUsagePayload(payload) {
+    const info = asRecord(payload.info)
+        ?? asRecord(payload.usage)
+        ?? asRecord(payload.tokenUsage)
+        ?? payload;
+    const total = asRecord(info.total_token_usage)
+        ?? asRecord(info.totalTokenUsage)
+        ?? asRecord(info.total)
+        ?? {};
+    const last = asRecord(info.last_token_usage)
+        ?? asRecord(info.lastTokenUsage)
+        ?? asRecord(info.last)
+        ?? {};
+    const result = {
+        currentInputTokens: numberValue(info.currentInputTokens) ?? numberValue(info.current_input_tokens) ?? numberValue(last.input_tokens),
+        currentCachedInputTokens: numberValue(info.currentCachedInputTokens) ?? numberValue(info.current_cached_input_tokens) ?? numberValue(last.cached_input_tokens),
+        inputTokens: numberValue(info.inputTokens) ?? numberValue(info.input_tokens) ?? numberValue(total.input_tokens),
+        cachedInputTokens: numberValue(info.cachedInputTokens) ?? numberValue(info.cached_input_tokens) ?? numberValue(total.cached_input_tokens),
+        outputTokens: numberValue(info.outputTokens) ?? numberValue(info.output_tokens) ?? numberValue(total.output_tokens),
+        reasoningOutputTokens: numberValue(info.reasoningOutputTokens) ?? numberValue(info.reasoning_output_tokens) ?? numberValue(total.reasoning_output_tokens),
+        totalTokens: numberValue(info.totalTokens) ?? numberValue(info.total_tokens) ?? numberValue(total.total_tokens),
+        modelContextWindow: numberValue(info.modelContextWindow) ?? numberValue(info.model_context_window) ?? numberValue(info.contextWindow) ?? numberValue(info.context_window),
+    };
+    const hasUsage = Object.values(result).some((value) => typeof value === 'number');
+    return hasUsage ? result : null;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function buildPlanApprovalActions() {
+    return [
+        { id: 'reject', label: 'Reject', variant: 'danger' },
+        {
+            id: 'continue_planning',
+            label: 'Continue planning',
+            variant: 'secondary',
+            requiresInput: true,
+            inputPlaceholder: 'Tell the agent what to change or clarify in the plan...',
+        },
+        { id: 'implement', label: 'Implement', variant: 'primary' },
+    ];
+}
+function codexPromptSet(agentSurfaceMode) {
+    return agentSurfaceMode === 'mcp'
+        ? {
+            planImplementation: MCP_CODEX_PLAN_IMPLEMENTATION_PROMPT,
+            planImplementationRepair: MCP_CODEX_PLAN_IMPLEMENTATION_REPAIR_PROMPT,
+            planImplementationAssistantTextRepair: MCP_CODEX_PLAN_IMPLEMENTATION_ASSISTANT_TEXT_REPAIR_PROMPT,
+            planImplementationSteerRepair: MCP_CODEX_PLAN_IMPLEMENTATION_STEER_REPAIR_PROMPT,
+            assistantTextRepair: MCP_CODEX_ASSISTANT_TEXT_REPAIR_PROMPT,
+            assistantTextSteer: MCP_CODEX_ASSISTANT_TEXT_STEER_PROMPT,
+            assistantTextRepairFollowUpSteer: MCP_CODEX_ASSISTANT_TEXT_REPAIR_FOLLOW_UP_STEER_PROMPT,
+        }
+        : {
+            planImplementation: CODEX_PLAN_IMPLEMENTATION_PROMPT,
+            planImplementationRepair: CODEX_PLAN_IMPLEMENTATION_REPAIR_PROMPT,
+            planImplementationAssistantTextRepair: CODEX_PLAN_IMPLEMENTATION_ASSISTANT_TEXT_REPAIR_PROMPT,
+            planImplementationSteerRepair: CODEX_PLAN_IMPLEMENTATION_STEER_REPAIR_PROMPT,
+            assistantTextRepair: CODEX_ASSISTANT_TEXT_REPAIR_PROMPT,
+            assistantTextSteer: CODEX_ASSISTANT_TEXT_STEER_PROMPT,
+            assistantTextRepairFollowUpSteer: CODEX_ASSISTANT_TEXT_REPAIR_FOLLOW_UP_STEER_PROMPT,
+        };
+}
+function buildCodexPlanImplementationPrompt(agentSurfaceMode, planText) {
+    const prompts = codexPromptSet(agentSurfaceMode);
+    const normalizedPlanText = normalizeOptionalString(planText);
+    return normalizedPlanText
+        ? `${prompts.planImplementation}\n\nApproved plan:\n\n${normalizedPlanText}`
+        : prompts.planImplementation;
+}
+function buildCodexPlanImplementationRepairPrompt(agentSurfaceMode, finalAnswerDraft, options) {
+    const prompts = codexPromptSet(agentSurfaceMode);
+    const prompt = options?.allowReconstruction
+        ? `${prompts.planImplementationAssistantTextRepair}\n\nCaptured assistant text:\n\n${finalAnswerDraft}`
+        : `${prompts.planImplementationRepair}\n\nSend this exact final answer content:\n\n${finalAnswerDraft}`;
+    return appendBigbangRepairGuidance(prompt, options?.bigbangRepairGuidance);
+}
+function buildCodexPlanImplementationSteerRepairPrompt(agentSurfaceMode, finalAnswerDraft, bigbangRepairGuidance) {
+    return appendBigbangRepairGuidance(`${codexPromptSet(agentSurfaceMode).planImplementationSteerRepair}\n\nSend this exact final answer content:\n\n${finalAnswerDraft}`, bigbangRepairGuidance);
+}
+function buildCodexAssistantTextRepairPrompt(agentSurfaceMode, assistantText, bigbangRepairGuidance) {
+    return appendBigbangRepairGuidance(`${codexPromptSet(agentSurfaceMode).assistantTextRepair}\n\nPrevious plain assistant text:\n\n${assistantText}`, bigbangRepairGuidance);
+}
+function buildCodexAssistantTextSteerPrompt(agentSurfaceMode, assistantText, bigbangRepairGuidance) {
+    return appendBigbangRepairGuidance(`${codexPromptSet(agentSurfaceMode).assistantTextSteer}\n\nCaptured text so far:\n\n${assistantText}`, bigbangRepairGuidance);
+}
+function buildCodexAssistantTextRepairFollowUpSteerPrompt(agentSurfaceMode, assistantText, bigbangRepairGuidance) {
+    return appendBigbangRepairGuidance(`${codexPromptSet(agentSurfaceMode).assistantTextRepairFollowUpSteer}\n\nCaptured text so far:\n\n${assistantText}`, bigbangRepairGuidance);
+}
+function appendBigbangRepairGuidance(prompt, guidance) {
+    return guidance ? `${prompt}\n\n${guidance}` : prompt;
+}
+function buildCodexPlanRevisionPrompt(planText, feedbackText) {
+    const normalizedPlanText = normalizeOptionalString(planText);
+    const normalizedFeedbackText = normalizeOptionalString(feedbackText) ?? CODEX_PLAN_REVISION_FALLBACK;
+    return [
+        'The user has not approved the current plan yet.',
+        'Revise the plan using the feedback below. Do not implement the plan or change files.',
+        normalizedPlanText ? `Current plan:\n\n${normalizedPlanText}` : null,
+        `User feedback:\n\n${normalizedFeedbackText}`,
+    ].filter(Boolean).join('\n\n');
+}
+function buildPermissionProfile(params) {
+    const { blockedKinds, workspaceRoot } = params;
+    const needsNativePermissionProfile = blockedKinds.has('fetch') || blockedKinds.has('read') || blockedKinds.has('edit');
+    if (!needsNativePermissionProfile)
+        return null;
+    const network = blockedKinds.has('fetch')
+        ? { enabled: false }
+        : { enabled: true };
+    const fileSystem = blockedKinds.has('read') || blockedKinds.has('edit')
+        ? {
+            type: 'restricted',
+            entries: [
+                {
+                    path: { type: 'path', path: workspaceRoot },
+                    access: blockedKinds.has('read') ? 'none' : 'read',
+                },
+            ],
+        }
+        : { type: 'unrestricted' };
+    return {
+        type: 'managed',
+        network,
+        fileSystem,
+    };
+}
+function buildToolPolicyPromptPreamble(blockedKinds) {
+    if (blockedKinds.size === 0)
+        return null;
+    const blocked = [...blockedKinds.keys()].sort().join(', ');
+    return [
+        '[Platform tool policy]',
+        `The following tool kinds are blocked for this turn: ${blocked}.`,
+        'Do not call blocked tools. If the task would require one, explain the restriction instead.',
+    ].join('\n');
+}
+function detectBlockedToolKindForApproval(method, params, blockedKinds) {
+    if (method === 'item/fileChange/requestApproval') {
+        return blockedKinds.has('edit') ? 'edit' : null;
+    }
+    return detectBlockedToolKindForPermissionsRequest(params, blockedKinds);
+}
+function detectBlockedToolKindForCommandApproval(params, blockedKinds) {
+    if (blockedKinds.has('execute')) {
+        return 'execute';
+    }
+    const payload = params;
+    if (blockedKinds.has('fetch')
+        && (payload?.networkApprovalContext != null
+            || payload?.additionalPermissions?.network?.enabled === true
+            || (Array.isArray(payload?.proposedNetworkPolicyAmendments) && payload.proposedNetworkPolicyAmendments.length > 0))) {
+        return 'fetch';
+    }
+    for (const action of extractCommandActions(payload?.commandActions)) {
+        if (action.type === 'read' && blockedKinds.has('read')) {
+            return 'read';
+        }
+        if ((action.type === 'search' || action.type === 'listFiles') && blockedKinds.has('search')) {
+            return 'search';
+        }
+    }
+    return null;
+}
+function detectBlockedToolKindForPermissionsRequest(params, blockedKinds) {
+    const permissions = params?.permissions;
+    if (permissions?.network?.enabled && blockedKinds.has('fetch')) {
+        return 'fetch';
+    }
+    if (Array.isArray(permissions?.fileSystem?.entries)) {
+        if (permissions.fileSystem.entries.some((entry) => entry?.access === 'write')
+            && blockedKinds.has('edit')) {
+            return 'edit';
+        }
+        if (permissions.fileSystem.entries.some((entry) => entry?.access === 'read')
+            && blockedKinds.has('read')) {
+            return 'read';
+        }
+    }
+    if ((permissions?.fileSystem?.write?.length ?? 0) > 0 && blockedKinds.has('edit')) {
+        return 'edit';
+    }
+    if ((permissions?.fileSystem?.read?.length ?? 0) > 0 && blockedKinds.has('read')) {
+        return 'read';
+    }
+    return null;
+}
+function requestWritesWorkspace(params, workspaceRoot) {
+    const payload = params;
+    const cwd = normalizeOptionalString(payload?.cwd) ?? workspaceRoot;
+    const paths = [
+        normalizeOptionalString(payload?.path),
+        ...(payload?.changes ?? []).map((change) => normalizeOptionalString(change?.path)),
+    ].filter((value) => Boolean(value));
+    if (paths.length === 0) {
+        return isPathInsideOrEqual(cwd, workspaceRoot);
+    }
+    return paths.some((value) => pathTargetsWorkspace(value, cwd, workspaceRoot));
+}
+function commandExecutionTouchesWorkspace(params, workspaceRoot) {
+    const payload = params;
+    const cwd = normalizeOptionalString(payload?.cwd) ?? workspaceRoot;
+    if (isPathInsideOrEqual(cwd, workspaceRoot)) {
+        return true;
+    }
+    for (const action of extractCommandActions(payload?.commandActions)) {
+        for (const value of action.paths) {
+            if (pathTargetsWorkspace(value, cwd, workspaceRoot)) {
+                return true;
+            }
+        }
+    }
+    const command = normalizeOptionalString(payload?.command);
+    return Boolean(command && commandMentionsWorkspacePath(command, workspaceRoot));
+}
+function permissionsRequestWritesWorkspace(params, workspaceRoot) {
+    const payload = params;
+    const fileSystem = payload?.permissions?.fileSystem;
+    if (!fileSystem)
+        return false;
+    const cwd = normalizeOptionalString(payload?.cwd) ?? workspaceRoot;
+    for (const value of fileSystem.write ?? []) {
+        if (pathTargetsWorkspace(value, cwd, workspaceRoot)) {
+            return true;
+        }
+    }
+    for (const entry of fileSystem.entries ?? []) {
+        if (normalizeOptionalString(entry?.access)?.toLowerCase() !== 'write') {
+            continue;
+        }
+        const entryPath = entry?.path;
+        const type = normalizeOptionalString(entryPath?.type)?.toLowerCase();
+        if (type === 'path') {
+            if (pathTargetsWorkspace(entryPath?.path, cwd, workspaceRoot)) {
+                return true;
+            }
+            continue;
+        }
+        if (type === 'special') {
+            const value = normalizeOptionalString(entryPath?.value)?.toLowerCase();
+            if ((value === ':cwd' || value === 'cwd') && isPathInsideOrEqual(cwd, workspaceRoot)) {
+                return true;
+            }
+            continue;
+        }
+        if (type === 'glob_pattern' && isPathInsideOrEqual(cwd, workspaceRoot)) {
+            return true;
+        }
+    }
+    return false;
+}
+function permissionsRequestReadsWorkspace(params, workspaceRoot) {
+    const payload = params;
+    const fileSystem = payload?.permissions?.fileSystem;
+    if (!fileSystem)
+        return false;
+    const cwd = normalizeOptionalString(payload?.cwd) ?? workspaceRoot;
+    for (const value of fileSystem.read ?? []) {
+        if (pathTargetsWorkspace(value, cwd, workspaceRoot)) {
+            return true;
+        }
+    }
+    for (const entry of fileSystem.entries ?? []) {
+        if (normalizeOptionalString(entry?.access)?.toLowerCase() !== 'read') {
+            continue;
+        }
+        const entryPath = entry?.path;
+        const type = normalizeOptionalString(entryPath?.type)?.toLowerCase();
+        if (type === 'path') {
+            if (pathTargetsWorkspace(entryPath?.path, cwd, workspaceRoot)) {
+                return true;
+            }
+            continue;
+        }
+        if (type === 'special') {
+            const value = normalizeOptionalString(entryPath?.value)?.toLowerCase();
+            if ((value === ':cwd' || value === 'cwd') && isPathInsideOrEqual(cwd, workspaceRoot)) {
+                return true;
+            }
+            continue;
+        }
+        if (type === 'glob_pattern' && isPathInsideOrEqual(cwd, workspaceRoot)) {
+            return true;
+        }
+    }
+    return false;
+}
+function pathTargetsWorkspace(value, cwd, workspaceRoot) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized)
+        return false;
+    const candidate = path.isAbsolute(normalized)
+        ? normalized
+        : path.resolve(cwd, normalized);
+    return isPathInsideOrEqual(candidate, workspaceRoot);
+}
+function isPathInsideOrEqual(candidatePath, rootPath) {
+    const candidate = path.resolve(candidatePath);
+    const root = path.resolve(rootPath);
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function buildPermissionsApprovalResponse(params, blockedKinds) {
+    const requested = params?.permissions;
+    const response = {
+        permissions: {},
+        scope: 'turn',
+    };
+    if (requested?.network?.enabled === true && !blockedKinds.has('fetch')) {
+        response.permissions.network = { enabled: true };
+    }
+    const requestedFileSystem = requested?.fileSystem;
+    if (requestedFileSystem && !blockedKinds.has('read')) {
+        const read = dedupeStrings(requestedFileSystem.read);
+        const write = blockedKinds.has('edit') ? [] : dedupeStrings(requestedFileSystem.write);
+        const entries = (requestedFileSystem.entries ?? [])
+            .map((entry) => normalizeGrantedFileSystemEntry(entry))
+            .filter((entry) => Boolean(entry))
+            .filter((entry) => {
+            if (entry.access === 'read') {
+                return !blockedKinds.has('read');
+            }
+            if (entry.access === 'write') {
+                return !blockedKinds.has('edit');
+            }
+            return false;
+        });
+        if (read.length > 0 || write.length > 0 || entries.length > 0) {
+            response.permissions.fileSystem = {
+                read: read.length > 0 ? read : null,
+                write: write.length > 0 ? write : null,
+                ...(typeof requestedFileSystem.globScanMaxDepth === 'number'
+                    ? { globScanMaxDepth: requestedFileSystem.globScanMaxDepth }
+                    : {}),
+                ...(entries.length > 0 ? { entries } : {}),
+            };
+        }
+    }
+    return response;
+}
+function normalizeGrantedFileSystemEntry(entry) {
+    const access = normalizeOptionalString(entry?.access)?.toLowerCase();
+    if (access !== 'read' && access !== 'write' && access !== 'none') {
+        return null;
+    }
+    const path = entry?.path;
+    const pathType = normalizeOptionalString(path?.type)?.toLowerCase();
+    if (pathType === 'path') {
+        const normalizedPath = normalizeOptionalString(path?.path);
+        return normalizedPath ? { path: { type: 'path', path: normalizedPath }, access } : null;
+    }
+    if (pathType === 'glob_pattern') {
+        const pattern = normalizeOptionalString(path?.pattern);
+        return pattern ? { path: { type: 'glob_pattern', pattern }, access } : null;
+    }
+    if (pathType === 'special') {
+        const value = normalizeOptionalString(path?.value);
+        return value ? { path: { type: 'special', value }, access } : null;
+    }
+    return null;
+}
+function dedupeStrings(values) {
+    const out = [];
+    const seen = new Set();
+    for (const value of values ?? []) {
+        const normalized = normalizeOptionalString(value);
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+function detectBlockedToolKind(item, blockedKinds) {
+    if (blockedKinds.size === 0)
+        return null;
+    switch (item.type) {
+        case 'commandExecution': {
+            if (blockedKinds.has('execute')) {
+                return 'execute';
+            }
+            for (const action of extractCommandActions(item.commandActions)) {
+                if (action.type === 'read' && blockedKinds.has('read')) {
+                    return 'read';
+                }
+                if ((action.type === 'search' || action.type === 'listFiles') && blockedKinds.has('search')) {
+                    return 'search';
+                }
+            }
+            return null;
+        }
+        case 'fileChange': {
+            const changes = item.changes ?? [];
+            for (const change of changes) {
+                const normalizedKind = normalizeFileChangeKind(change.kind);
+                if (normalizedKind === 'delete' && blockedKinds.has('delete')) {
+                    return 'delete';
+                }
+                if (normalizedKind === 'move' && blockedKinds.has('move')) {
+                    return 'move';
+                }
+            }
+            if (blockedKinds.has('edit')) {
+                return 'edit';
+            }
+            return null;
+        }
+        case 'webSearch':
+            return blockedKinds.has('fetch') ? 'fetch' : null;
+        default:
+            return null;
+    }
+}
+function normalizeFileChangeKind(value) {
+    const normalized = normalizeOptionalString(value)?.toLowerCase();
+    if (normalized === 'delete' || normalized === 'remove') {
+        return 'delete';
+    }
+    if (normalized === 'move' || normalized === 'rename') {
+        return 'move';
+    }
+    return 'edit';
+}
+function extractCommandActions(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((action) => {
+        const record = asRecord(action);
+        const type = normalizeOptionalString(record?.type);
+        if (type === 'read' || type === 'listFiles' || type === 'search' || type === 'unknown') {
+            return { type, paths: extractPathStringsFromUnknown(record) };
+        }
+        return null;
+    })
+        .filter(Boolean);
+}
+function extractPathStringsFromUnknown(value, depth = 0) {
+    if (depth > 4 || value == null)
+        return [];
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => extractPathStringsFromUnknown(item, depth + 1));
+    }
+    const record = asRecord(value);
+    if (!record)
+        return [];
+    const result = [];
+    for (const key of ['path', 'paths', 'file', 'files', 'file_path', 'filePath', 'cwd', 'root', 'directory', 'pattern']) {
+        result.push(...extractPathStringsFromUnknown(record[key], depth + 1));
+    }
+    return result.filter((item) => item.length > 0);
+}
+function commandMentionsWorkspacePath(command, workspaceRoot) {
+    const normalizedRoot = path.resolve(workspaceRoot);
+    const normalizedCommand = command.replace(/\\ /g, ' ');
+    return normalizedCommand.includes(normalizedRoot);
+}
+function formatBlockedToolMessage(toolKind, reason) {
+    return reason === 'policy_reject'
+        ? `Tool call denied by policy: ${toolKind}.`
+        : `Tool call denied by agent settings: ${toolKind} disabled.`;
+}
+function mapToolItem(item, buffers) {
+    const toolCallId = normalizeOptionalString(item.id);
+    if (!toolCallId)
+        return null;
+    switch (item.type) {
+        case 'commandExecution': {
+            const normalized = normalizeToolItemStatus(item.status);
+            const commandOutput = mergeAggregatedAndBufferedOutput(normalizeOptionalString(item.aggregatedOutput ?? undefined), normalizeOptionalString(buffers.commandOutput ?? undefined));
+            const output = [
+                commandOutput,
+                typeof item.exitCode === 'number' ? `exit_code=${item.exitCode}` : null,
+            ].filter((value) => Boolean(value)).join('\n\n') || (normalized.status === 'failed' ? 'Command failed.' : 'Command completed.');
+            return {
+                toolCallId,
+                name: 'shell',
+                input: {
+                    command: item.command ?? '',
+                    cwd: item.cwd ?? null,
+                },
+                output,
+                detail: output,
+                inProgress: normalized.inProgress,
+                status: normalized.status,
+                metadata: buildToolMetadata(item),
+            };
+        }
+        case 'fileChange': {
+            const normalized = normalizeToolItemStatus(item.status);
+            const output = normalizeOptionalString(buffers.fileChangeOutput ?? undefined) ?? summarizeFileChanges(item.changes);
+            return {
+                toolCallId,
+                name: 'apply_patch',
+                input: item.changes ?? [],
+                output,
+                detail: output,
+                inProgress: normalized.inProgress,
+                status: normalized.status,
+                metadata: buildToolMetadata(item),
+            };
+        }
+        case 'mcpToolCall': {
+            const normalized = normalizeToolItemStatus(item.status);
+            const output = item.error?.message?.trim() || summarizeJson(item.result ?? '');
+            return {
+                toolCallId,
+                name: item.server && item.tool ? `${item.server}/${item.tool}` : item.tool ?? 'mcp_tool',
+                input: item.arguments ?? null,
+                output,
+                detail: output,
+                inProgress: normalized.inProgress,
+                status: normalized.status,
+                metadata: buildToolMetadata(item),
+            };
+        }
+        case 'dynamicToolCall': {
+            const normalized = normalizeToolItemStatus(item.status, item.success);
+            const output = summarizeJson(item.contentItems ?? '');
+            return {
+                toolCallId,
+                name: item.namespace ? `${item.namespace}.${item.tool ?? 'tool'}` : item.tool ?? 'tool',
+                input: item.arguments ?? null,
+                output,
+                detail: output,
+                inProgress: normalized.inProgress,
+                status: normalized.status,
+                metadata: buildToolMetadata(item),
+            };
+        }
+        case 'webSearch': {
+            const normalized = normalizeToolItemStatus(item.status, item.success);
+            const output = normalized.status === 'failed'
+                ? item.error?.message?.trim() || 'Web search failed.'
+                : normalized.status === 'cancelled'
+                    ? 'Web search cancelled.'
+                    : 'Web search completed.';
+            return {
+                toolCallId,
+                name: 'web_search',
+                input: {
+                    query: item.query ?? '',
+                    action: item.action ?? null,
+                },
+                output,
+                detail: output,
+                inProgress: normalized.inProgress,
+                status: normalized.status,
+                metadata: buildToolMetadata(item),
+            };
+        }
+        default:
+            return null;
+    }
+}
+function normalizeToolItemStatus(status, success) {
+    const normalized = normalizeOptionalString(status)?.toLowerCase();
+    if (normalized === 'inprogress' || normalized === 'in_progress' || normalized === 'running') {
+        return { status: 'completed', inProgress: true };
+    }
+    if (normalized === 'cancelled' || normalized === 'canceled') {
+        return { status: 'cancelled', inProgress: false };
+    }
+    if (normalized === 'failed' || normalized === 'error' || normalized === 'declined' || success === false) {
+        return { status: 'failed', inProgress: false };
+    }
+    return { status: 'completed', inProgress: false };
+}
+function buildToolMetadata(item) {
+    return {
+        source: 'codex_app_server',
+        itemType: item.type ?? null,
+        ...(item.status ? { appStatus: item.status } : {}),
+        ...(typeof item.success === 'boolean' ? { success: item.success } : {}),
+        ...(typeof item.exitCode === 'number' ? { exitCode: item.exitCode } : {}),
+    };
+}
+function normalizeCodexQuestionPrompts(params) {
+    const questions = Array.isArray(params?.questions)
+        ? (params.questions)
+        : [];
+    const normalized = [];
+    questions.forEach((question, index) => {
+        const record = asRecord(question);
+        if (!record)
+            return;
+        const id = normalizeOptionalString(record.id) ?? `question_${index + 1}`;
+        const questionText = normalizeOptionalString(record.question);
+        if (!questionText)
+            return;
+        const header = normalizeOptionalString(record.header) ?? id;
+        const options = Array.isArray(record.options)
+            ? record.options.flatMap((option) => {
+                const optionRecord = asRecord(option);
+                if (!optionRecord)
+                    return [];
+                const label = normalizeOptionalString(optionRecord.label);
+                if (!label)
+                    return [];
+                const description = normalizeOptionalString(optionRecord.description);
+                return [{ label, ...(description ? { description } : {}) }];
+            })
+            : [];
+        normalized.push({
+            id,
+            header,
+            question: questionText,
+            options,
+            ...(record.multiSelect === true ? { multiSelect: true } : {}),
+            ...(record.isOther === true ? { isOther: true } : {}),
+            ...(record.isSecret === true ? { isSecret: true } : {}),
+        });
+    });
+    return normalized;
+}
+function buildUserInputResponse(params, submittedAnswers) {
+    const questions = normalizeCodexQuestionPrompts(params);
+    const answers = {};
+    for (const question of questions) {
+        const submitted = submittedAnswers?.[question.id]
+            ?.map((answer) => answer.trim())
+            .filter((answer) => answer.length > 0);
+        if (submitted?.length) {
+            answers[question.id] = { answers: submitted };
+            continue;
+        }
+        const firstOption = question.options.find((option) => normalizeOptionalString(option.label));
+        answers[question.id] = { answers: firstOption ? [firstOption.label] : [] };
+    }
+    return { answers };
+}
+function buildUserInputRequestId(params, sessionKey) {
+    const payload = params;
+    const stableId = normalizeOptionalString(payload?.requestId) ?? normalizeOptionalString(payload?.itemId);
+    const scopedId = stableId ?? randomUUID();
+    return `codex-app-input:${sessionKey}:${scopedId}`;
+}
+function extractApprovalItemId(params) {
+    const payload = params;
+    return normalizeOptionalString(payload?.itemId) ?? normalizeOptionalString(payload?.requestId);
+}
+function isLikelyMissingThreadError(message) {
+    const normalized = message.toLowerCase();
+    return normalized.includes('thread') && (normalized.includes('not found')
+        || normalized.includes('missing')
+        || normalized.includes('unknown'));
+}
+function isLikelyUnsupportedPersistExtendedHistoryError(message) {
+    const normalized = message.toLowerCase();
+    const referencesField = normalized.includes('persistextendedhistory')
+        || normalized.includes('persist_extended_history')
+        || normalized.includes('persist extended history');
+    if (!referencesField) {
+        return false;
+    }
+    return (normalized.includes('unknown field')
+        || normalized.includes('unrecognized field')
+        || normalized.includes('unexpected field')
+        || normalized.includes('unexpected property')
+        || normalized.includes('unknown property')
+        || normalized.includes('unrecognized property')
+        || normalized.includes('additional properties')
+        || normalized.includes('unknown key')
+        || normalized.includes('unrecognized key')
+        || normalized.includes('unexpected key')
+        || normalized.includes('unknown argument')
+        || normalized.includes('unrecognized argument')
+        || normalized.includes('unexpected argument'));
+}