factory-factory 0.3.7 → 0.3.9

package/dist/src/backend/domains/session/acp/codex-app-server-adapter/codex-app-server-acp-adapter.js

@@ -1,147 +1,17 @@
 import { Readable, Writable } from 'node:stream';
 import { AgentSideConnection, ndJsonStream, PROTOCOL_VERSION, RequestError, } from '@agentclientprotocol/sdk';
+import { asString, dedupeStrings, extractLocations, isRecord, resolveToolCallId, } from './acp-adapter-utils.js';
 import { CodexRequestError, CodexRpcClient } from './codex-rpc-client.js';
-import { collaborationModeListResponseSchema, configRequirementsReadResponseSchema, knownCodexNotificationSchema, knownCodexServerRequestSchema, modelListResponseSchema, threadReadResponseSchema, threadResumeResponseSchema, threadStartResponseSchema, turnStartResponseSchema, } from './codex-zod.js';
+import { turnStartResponseSchema } from './codex-zod.js';
+import { resolveCommandDisplay } from './command-metadata.js';
+import { handleCodexServerPermissionRequest } from './protocol-permission-handler.js';
+import { attachCloseWatcherWithRetry } from './retry-logic.js';
+import { buildConfigOptions, createSandboxPolicyFromMode, getCollaborationModeValues, getExecutionPresets, isKnownModel, isReasoningEffortSupportedForModel, resolveCollaborationModeLabel, resolveDefaultCollaborationMode, resolveDefaultModel, resolveReasoningEffortForModel, resolveSandboxPolicy, resolveSessionModel, resolveTurnCollaborationMode, } from './session-config-resolver.js';
+import { loadCollaborationModes, loadConfigRequirements, loadModelCatalog, negotiateNewSession, negotiateSessionResume, } from './session-negotiation.js';
+import { CodexAdapterSessionStateContainer } from './session-state-container.js';
+import { ShapeDriftReporter } from './shape-drift-reporter.js';
+import { CodexStreamEventHandler } from './stream-event-handler.js';
 const PENDING_TURN_ID = '__pending_turn__';
-const MAX_CLOSE_WATCHER_ATTACH_RETRIES = 50;
-const DEFAULT_APPROVAL_POLICIES = ['on-failure', 'on-request', 'never'];
-const DEFAULT_SANDBOX_MODES = ['read-only', 'workspace-write', 'danger-full-access'];
-const SHAPE_DRIFT_DETAILS_LIMIT = 700;
-const COMMAND_EXECUTION_SESSION_HANDOFF_LINE_PATTERN = /^process running with session id(?:\s*[:#-]?\s*[a-z0-9_-]+)?\.?$/i;
-function toTurnItemKey(turnId, itemId) {
-    return `${turnId}:${itemId}`;
-}
-function toShapeDriftDetails(value) {
-    try {
-        const text = JSON.stringify(value);
-        if (typeof text !== 'string') {
-            return '[unserializable]';
-        }
-        return text.length > SHAPE_DRIFT_DETAILS_LIMIT
-            ? `${text.slice(0, SHAPE_DRIFT_DETAILS_LIMIT)}...`
-            : text;
-    }
-    catch {
-        return '[unserializable]';
-    }
-}
-function isNonEmptyString(value) {
-    return typeof value === 'string' && value.trim().length > 0;
-}
-function dedupeStrings(values) {
-    return Array.from(new Set(values));
-}
-function humanizeToken(value) {
-    return value
-        .split(/[-_]/)
-        .filter((part) => part.length > 0)
-        .map((part) => part.slice(0, 1).toUpperCase() + part.slice(1))
-        .join(' ');
-}
-function sanitizeModeName(mode) {
-    return mode
-        .split('_')
-        .map((part) => part.slice(0, 1).toUpperCase() + part.slice(1))
-        .join(' ');
-}
-function formatApprovalPolicyLabel(policy) {
-    if (policy === 'on-request') {
-        return 'On Request';
-    }
-    if (policy === 'on-failure') {
-        return 'On Failure';
-    }
-    if (policy === 'never') {
-        return 'Never Ask';
-    }
-    if (policy === 'untrusted') {
-        return 'Untrusted';
-    }
-    return humanizeToken(policy);
-}
-function formatSandboxModeLabel(mode) {
-    if (mode === 'workspace-write') {
-        return 'Workspace Write';
-    }
-    if (mode === 'read-only') {
-        return 'Read-only';
-    }
-    if (mode === 'danger-full-access') {
-        return 'Full Access';
-    }
-    return humanizeToken(mode);
-}
-function formatExecutionPresetName(approvalPolicy, sandboxMode) {
-    if (approvalPolicy === 'never' && sandboxMode === 'danger-full-access') {
-        return 'YOLO (Full Access)';
-    }
-    return `${formatApprovalPolicyLabel(approvalPolicy)} (${formatSandboxModeLabel(sandboxMode)})`;
-}
-function createWorkspaceWriteSandboxPolicy(cwd) {
-    return {
-        type: 'workspaceWrite',
-        writableRoots: [cwd],
-        readOnlyAccess: { type: 'fullAccess' },
-        networkAccess: true,
-        excludeTmpdirEnvVar: false,
-        excludeSlashTmp: false,
-    };
-}
-function createDangerFullAccessSandboxPolicy() {
-    return {
-        type: 'dangerFullAccess',
-    };
-}
-function parseSandboxModeFromPolicy(policy) {
-    if (!isRecord(policy)) {
-        return null;
-    }
-    const policyType = asString(policy.type);
-    if (policyType === 'workspaceWrite') {
-        return 'workspace-write';
-    }
-    if (policyType === 'readOnly') {
-        return 'read-only';
-    }
-    if (policyType === 'dangerFullAccess') {
-        return 'danger-full-access';
-    }
-    return null;
-}
-function createSandboxPolicyFromMode(mode, cwd) {
-    if (mode === 'danger-full-access') {
-        return createDangerFullAccessSandboxPolicy();
-    }
-    if (mode === 'read-only') {
-        return {
-            type: 'readOnly',
-            access: { type: 'fullAccess' },
-        };
-    }
-    return createWorkspaceWriteSandboxPolicy(cwd);
-}
-function toSessionId(threadId) {
-    return `sess_${threadId}`;
-}
-function toThreadId(sessionId) {
-    return sessionId.startsWith('sess_') ? sessionId.slice('sess_'.length) : sessionId;
-}
-function extractToolCallIdFromUnknown(value) {
-    if (!isRecord(value)) {
-        return null;
-    }
-    return asString(value.callId) ?? asString(value.call_id) ?? null;
-}
-function resolveToolCallId(params) {
-    return extractToolCallIdFromUnknown(params.source) ?? params.itemId;
-}
-function isCommandExecutionSessionHandoffOutput(output) {
-    const trimmedOutput = output.trim();
-    if (trimmedOutput.length === 0 || /[\r\n]/.test(trimmedOutput)) {
-        return false;
-    }
-    return COMMAND_EXECUTION_SESSION_HANDOFF_LINE_PATTERN.test(trimmedOutput);
-}
 function isPlanLikeMode(mode) {
     return /plan/i.test(mode);
 }
@@ -280,393 +150,6 @@ function toCodexMcpConfigMap(mcpServers) {
     }
     return mcpServersByName;
 }
-function buildToolUserInputPermissionOptions(questions) {
-    if (questions.length !== 1) {
-        return [
-            { optionId: 'allow_once', name: 'Submit', kind: 'allow_once' },
-            { optionId: 'reject_once', name: 'Cancel', kind: 'reject_once' },
-        ];
-    }
-    const firstQuestionWithOptions = questions.find((question) => Array.isArray(question.options) && question.options.length > 0);
-    if (!firstQuestionWithOptions?.options) {
-        return [
-            { optionId: 'allow_once', name: 'Submit', kind: 'allow_once' },
-            { optionId: 'reject_once', name: 'Cancel', kind: 'reject_once' },
-        ];
-    }
-    const mappedOptions = firstQuestionWithOptions.options.slice(0, 6).map((option, index) => ({
-        optionId: `answer_${index}`,
-        name: option.label,
-        kind: 'allow_once',
-    }));
-    mappedOptions.push({ optionId: 'reject_once', name: 'Cancel', kind: 'reject_once' });
-    return mappedOptions;
-}
-function buildToolUserInputAnswers(params) {
-    if (params.selectedOptionId === null || params.selectedOptionId === 'reject_once') {
-        return {};
-    }
-    const parsedAnswers = parseToolUserInputAnswersFromPermissionMeta({
-        questions: params.questions,
-        permission: params.permission,
-    });
-    if (parsedAnswers) {
-        return parsedAnswers;
-    }
-    if (params.questions.length !== 1) {
-        throw new Error('Missing structured answers for multi-question requestUserInput');
-    }
-    const selectedIndex = params.selectedOptionId.startsWith('answer_')
-        ? Number.parseInt(params.selectedOptionId.slice('answer_'.length), 10)
-        : Number.NaN;
-    const answers = {};
-    const [question] = params.questions;
-    if (!(question && Array.isArray(question.options)) || question.options.length === 0) {
-        return answers;
-    }
-    const selectedOption = Number.isNaN(selectedIndex)
-        ? question.options[0]
-        : (question.options[selectedIndex] ?? question.options[0]);
-    if (!selectedOption) {
-        return answers;
-    }
-    answers[question.id] = { answers: [selectedOption.label] };
-    return answers;
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function parseToolUserInputAnswersFromPermissionMeta(params) {
-    const meta = params.permission._meta;
-    if (!isRecord(meta)) {
-        return null;
-    }
-    const factoryFactoryMeta = isRecord(meta.factoryFactory) ? meta.factoryFactory : null;
-    const answersRaw = (factoryFactoryMeta?.toolUserInputAnswers ?? meta.toolUserInputAnswers);
-    if (!isRecord(answersRaw)) {
-        return null;
-    }
-    const knownQuestionIds = new Set(params.questions.map((question) => question.id));
-    const answers = {};
-    for (const [questionId, value] of Object.entries(answersRaw)) {
-        if (!knownQuestionIds.has(questionId)) {
-            continue;
-        }
-        const values = (Array.isArray(value) ? value : [value])
-            .filter((entry) => typeof entry === 'string')
-            .map((entry) => entry.trim())
-            .filter((entry) => entry.length > 0);
-        if (values.length === 0) {
-            continue;
-        }
-        answers[questionId] = { answers: values };
-    }
-    return answers;
-}
-function asString(value) {
-    return typeof value === 'string' ? value : null;
-}
-function trimOptionalQuotes(token) {
-    if (token.length >= 2 && token.startsWith('"') && token.endsWith('"')) {
-        return { text: token.slice(1, -1), quote: '"' };
-    }
-    if (token.length >= 2 && token.startsWith("'") && token.endsWith("'")) {
-        return { text: token.slice(1, -1), quote: "'" };
-    }
-    return { text: token, quote: null };
-}
-function unescapeCommandToken(token, quote) {
-    if (quote === "'") {
-        return token.replace(/\\'/g, "'").replace(/\\\\/g, '\\');
-    }
-    return token.replace(/\\(["'\\\s|&;])/g, '$1');
-}
-function sanitizeCommandToken(token) {
-    const trimmed = token.trim();
-    const { text, quote } = trimOptionalQuotes(trimmed);
-    return unescapeCommandToken(text, quote).trim();
-}
-function tokenizeCommand(command) {
-    return (command.match(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S+/g) ?? [])
-        .map((token) => sanitizeCommandToken(token))
-        .filter((token) => token.length > 0);
-}
-function commandName(token) {
-    const unix = token.split('/').at(-1) ?? token;
-    return (unix.split('\\').at(-1) ?? unix).toLowerCase();
-}
-function isChainSeparatorChar(char) {
-    return char === ';' || char === '\n' || char === '|' || char === '&';
-}
-function readChainSeparatorLength(command, index) {
-    const char = command[index];
-    if (!(char && isChainSeparatorChar(char))) {
-        return 0;
-    }
-    const next = command[index + 1];
-    if ((char === '|' || char === '&') && next === char) {
-        return 2;
-    }
-    return 1;
-}
-function isLikelyPathToken(token) {
-    if (!token || token.startsWith('-')) {
-        return false;
-    }
-    if (token.startsWith('./') ||
-        token.startsWith('../') ||
-        token.startsWith('/') ||
-        token.startsWith('~')) {
-        return true;
-    }
-    return (token.includes('/') ||
-        token.includes('\\') ||
-        token.endsWith('.') ||
-        /\.[a-z0-9]+$/i.test(token));
-}
-function normalizeLocationPath(pathToken, cwd) {
-    if (pathToken.startsWith('/')) {
-        return pathToken;
-    }
-    if (pathToken.startsWith('~')) {
-        return pathToken;
-    }
-    const base = cwd.endsWith('/') ? cwd.slice(0, -1) : cwd;
-    return `${base}/${pathToken}`;
-}
-const READ_COMMANDS = new Set(['cat', 'head', 'tail', 'less', 'more']);
-const LIST_OR_FIND_COMMANDS = new Set(['ls', 'tree', 'find', 'fd']);
-const GREP_LIKE_COMMANDS = new Set(['rg', 'ripgrep', 'grep', 'ag']);
-const SHELL_META_COMMANDS = new Set(['cd', 'export', 'set', 'unset', 'alias', 'unalias', 'source']);
-function pushCommandChainPart(state) {
-    const trimmed = state.current.trim();
-    if (trimmed.length > 0) {
-        state.parts.push(trimmed);
-    }
-    state.current = '';
-}
-function consumeEscapedCommandChar(state, char) {
-    if (!state.escaped) {
-        return false;
-    }
-    state.current += char;
-    state.escaped = false;
-    return true;
-}
-function consumeEscapeInitiator(state, char) {
-    if (!(char === '\\' && state.quote !== "'")) {
-        return false;
-    }
-    state.current += char;
-    state.escaped = true;
-    return true;
-}
-function hasOddTrailingBackslashes(value) {
-    let count = 0;
-    for (let index = value.length - 1; index >= 0; index -= 1) {
-        if (value[index] !== '\\') {
-            break;
-        }
-        count += 1;
-    }
-    return count % 2 === 1;
-}
-function consumeQuotedCommandChar(state, char) {
-    if (!state.quote) {
-        return false;
-    }
-    const escapedSingleQuote = state.quote === "'" && char === "'" && hasOddTrailingBackslashes(state.current);
-    state.current += char;
-    if (char === state.quote && !escapedSingleQuote) {
-        state.quote = null;
-    }
-    return true;
-}
-function consumeQuoteStart(state, char) {
-    if (!(char === '"' || char === "'")) {
-        return false;
-    }
-    state.quote = char;
-    state.current += char;
-    return true;
-}
-function consumeCommandChainSeparator(state, command, index) {
-    const separatorLength = readChainSeparatorLength(command, index);
-    if (separatorLength <= 0) {
-        return 0;
-    }
-    pushCommandChainPart(state);
-    return separatorLength;
-}
-function splitCommandChain(command) {
-    const state = {
-        parts: [],
-        current: '',
-        quote: null,
-        escaped: false,
-    };
-    for (let index = 0; index < command.length; index += 1) {
-        const char = command[index];
-        if (!char) {
-            continue;
-        }
-        if (consumeEscapedCommandChar(state, char)) {
-            continue;
-        }
-        if (consumeEscapeInitiator(state, char)) {
-            continue;
-        }
-        if (consumeQuotedCommandChar(state, char)) {
-            continue;
-        }
-        if (consumeQuoteStart(state, char)) {
-            continue;
-        }
-        const consumedSeparatorLength = consumeCommandChainSeparator(state, command, index);
-        if (consumedSeparatorLength > 0) {
-            index += consumedSeparatorLength - 1;
-            continue;
-        }
-        state.current += char;
-    }
-    pushCommandChainPart(state);
-    return state.parts;
-}
-function buildCommandDisplayContexts(rawCommand, cwd) {
-    const command = rawCommand?.trim();
-    if (!command) {
-        return [];
-    }
-    const contexts = [];
-    const segments = splitCommandChain(command);
-    for (const segment of segments) {
-        const tokens = tokenizeCommand(segment);
-        if (tokens.length === 0) {
-            continue;
-        }
-        const [firstToken] = tokens;
-        if (!firstToken) {
-            continue;
-        }
-        const firstCommand = commandName(firstToken);
-        const nonFlagArgs = tokens.slice(1).filter((token) => !token.startsWith('-'));
-        const pathArg = nonFlagArgs.find(isLikelyPathToken) ?? null;
-        const commandPath = pathArg ? normalizeLocationPath(pathArg, cwd) : null;
-        const locations = commandPath ? [{ path: commandPath }] : [];
-        contexts.push({
-            command: segment,
-            firstCommand,
-            nonFlagArgs,
-            pathArg,
-            cwd,
-            locations,
-            isShellMeta: SHELL_META_COMMANDS.has(firstCommand),
-        });
-    }
-    return contexts;
-}
-function chooseActionableCommandContexts(contexts) {
-    const actionable = contexts.filter((context) => !context.isShellMeta);
-    return actionable.length > 0 ? actionable : contexts;
-}
-function selectCombinedCommandKind(displays) {
-    const firstNonExecute = displays.find((display) => display.kind !== 'execute');
-    return firstNonExecute?.kind ?? 'execute';
-}
-function resolveCommandDisplay(params) {
-    const contexts = chooseActionableCommandContexts(buildCommandDisplayContexts(params.command, params.cwd));
-    if (contexts.length === 0) {
-        return { title: 'commandExecution', kind: 'execute', locations: [] };
-    }
-    const [singleContext] = contexts;
-    if (singleContext && contexts.length === 1) {
-        return resolveCommandDisplayFromContext(singleContext);
-    }
-    const displays = contexts.map((context) => resolveCommandDisplayFromContext(context));
-    const title = dedupeStrings(displays.map((display) => display.title)).join(', ');
-    const kind = selectCombinedCommandKind(displays);
-    const locations = dedupeLocations(displays.flatMap((display) => display.locations)).map((location) => ({ path: location.path }));
-    return { title, kind, locations };
-}
-function resolveCommandDisplayFromContext(context) {
-    if (READ_COMMANDS.has(context.firstCommand)) {
-        const label = context.pathArg ?? context.command;
-        return { title: `Read ${label}`, kind: 'read', locations: context.locations };
-    }
-    if (LIST_OR_FIND_COMMANDS.has(context.firstCommand)) {
-        const target = context.pathArg
-            ? normalizeLocationPath(context.pathArg, context.cwd)
-            : context.cwd;
-        const title = context.firstCommand === 'find' || context.firstCommand === 'fd'
-            ? `Search ${target}`
-            : `List ${target}`;
-        return { title, kind: 'search', locations: context.locations };
-    }
-    if (GREP_LIKE_COMMANDS.has(context.firstCommand)) {
-        const query = context.nonFlagArgs.find((token) => !isLikelyPathToken(token));
-        const target = context.pathArg ? ` in ${context.pathArg}` : '';
-        const title = query ? `Search ${query}${target}` : `Search ${context.command}`;
-        return { title, kind: 'search', locations: context.locations };
-    }
-    return { title: context.command, kind: 'execute', locations: context.locations };
-}
-function normalizeCwdForScope(cwd) {
-    if (cwd.length > 1 && cwd.endsWith('/')) {
-        return cwd.slice(0, -1);
-    }
-    return cwd;
-}
-function normalizeScopeToken(token) {
-    return token.replace(/\s+/g, ' ').trim();
-}
-function buildCommandApprovalScopeKey(params) {
-    const contexts = buildCommandDisplayContexts(params.command, params.cwd);
-    if (contexts.length === 0) {
-        return null;
-    }
-    let scopeCwd = normalizeCwdForScope(params.cwd);
-    const segments = [];
-    for (const context of contexts) {
-        if (context.firstCommand === 'cd') {
-            const rawTarget = context.nonFlagArgs[0];
-            const target = rawTarget ? normalizeScopeToken(rawTarget) : '';
-            if (target.length > 0) {
-                scopeCwd = normalizeCwdForScope(normalizeLocationPath(target, scopeCwd));
-                segments.push(`cd ${target} -> ${scopeCwd}`);
-            }
-            else {
-                segments.push('cd');
-            }
-            continue;
-        }
-        const args = context.nonFlagArgs.map(normalizeScopeToken).filter((arg) => arg.length > 0);
-        const normalized = normalizeScopeToken([context.firstCommand, ...args].join(' '));
-        if (normalized.length === 0) {
-            continue;
-        }
-        segments.push(`[cwd=${scopeCwd}] ${normalized}`);
-    }
-    const normalizedSegments = segments
-        .map(normalizeScopeToken)
-        .filter((segment) => segment.length > 0);
-    if (normalizedSegments.length === 0) {
-        return null;
-    }
-    return `cwd=${normalizeCwdForScope(params.cwd)}|${normalizedSegments.join(' && ')}`;
-}
-function dedupeLocations(locations) {
-    const seen = new Set();
-    const result = [];
-    for (const location of locations) {
-        const key = `${location.path}:${location.line ?? ''}`;
-        if (seen.has(key)) {
-            continue;
-        }
-        seen.add(key);
-        result.push(location);
-    }
-    return result;
-}
 function parseTextFromPromptBlock(block) {
     if (block.type === 'text') {
         return block.text;
@@ -690,123 +173,34 @@ function parseTextFromPromptBlock(block) {
     }
     return JSON.stringify(block);
 }
-function toToolStatus(status) {
-    if (status === 'inProgress') {
-        return 'in_progress';
-    }
-    if (status === 'completed') {
-        return 'completed';
-    }
-    if (status === 'failed' || status === 'declined') {
-        return 'failed';
-    }
-    return undefined;
-}
-function createCollaborationModeConfigOption(currentMode, collaborationModes) {
-    const options = collaborationModes
-        .filter((entry) => isNonEmptyString(entry.mode))
-        .map((entry) => ({
-        value: entry.mode,
-        name: entry.name,
-    }));
-    if (!options.some((option) => option.value === currentMode)) {
-        options.unshift({ value: currentMode, name: sanitizeModeName(currentMode) });
-    }
-    return {
-        id: 'mode',
-        category: 'mode',
-        name: 'Collaboration Mode',
-        type: 'select',
-        currentValue: currentMode,
-        options,
-    };
-}
-function createModelConfigOption(currentModel, modelCatalog) {
-    const options = modelCatalog.map((model) => ({
-        value: model.id,
-        name: model.displayName,
-        description: model.description,
-    }));
-    if (!options.some((option) => option.value === currentModel)) {
-        options.unshift({ value: currentModel, name: currentModel });
-    }
-    return {
-        id: 'model',
-        category: 'model',
-        name: 'Model',
-        type: 'select',
-        currentValue: currentModel,
-        options,
-    };
-}
-function createReasoningEffortConfigOption(currentReasoningEffort, modelCatalog, currentModel) {
-    const modelEntry = modelCatalog.find((model) => model.id === currentModel);
-    if (!modelEntry) {
-        return null;
-    }
-    const supportedEntries = modelEntry.supportedReasoningEfforts.filter((entry) => isNonEmptyString(entry.reasoningEffort));
-    if (supportedEntries.length === 0) {
-        return null;
-    }
-    const supportedByValue = new Map();
-    for (const entry of supportedEntries) {
-        if (!supportedByValue.has(entry.reasoningEffort)) {
-            supportedByValue.set(entry.reasoningEffort, entry.description);
-        }
-    }
-    const supportedValues = [...supportedByValue.keys()];
-    const resolvedCurrent = currentReasoningEffort && supportedByValue.has(currentReasoningEffort)
-        ? currentReasoningEffort
-        : supportedByValue.has(modelEntry.defaultReasoningEffort)
-            ? modelEntry.defaultReasoningEffort
-            : supportedValues[0];
-    if (!resolvedCurrent) {
-        return null;
-    }
-    return {
-        id: 'reasoning_effort',
-        category: 'thought_level',
-        name: 'Reasoning Effort',
-        type: 'select',
-        currentValue: resolvedCurrent,
-        options: supportedValues.map((value) => ({
-            value,
-            name: value,
-            ...(supportedByValue.get(value) ? { description: supportedByValue.get(value) } : {}),
-        })),
-    };
-}
-function createExecutionModeConfigOption(currentPresetId, presets) {
-    return {
-        id: 'execution_mode',
-        category: 'permission',
-        name: 'Execution Mode',
-        type: 'select',
-        currentValue: currentPresetId,
-        options: presets.map((preset) => ({
-            value: preset.id,
-            name: preset.name,
-            ...(preset.description ? { description: preset.description } : {}),
-        })),
-    };
-}
-function toExecutionPresetId(approvalPolicy, sandboxMode) {
-    return JSON.stringify([approvalPolicy, sandboxMode]);
-}
 export class CodexAppServerAcpAdapter {
     connection;
     codex;
-    sessions = new Map();
-    sessionIdByThreadId = new Map();
+    stateContainer = new CodexAdapterSessionStateContainer();
     modelCatalog = [];
     allowedApprovalPolicies = [];
     allowedSandboxModes = [];
     collaborationModes = [];
-    mcpServersByThreadId = new Map();
-    appliedMcpServerConfigJson = '{}';
-    shapeDriftCounts = new Map();
-    constructor(connection, codexClient) {
+    shapeDriftReporter;
+    streamEventHandler;
+    get sessions() {
+        return this.stateContainer.sessions;
+    }
+    get sessionIdByThreadId() {
+        return this.stateContainer.sessionIdByThreadId;
+    }
+    get mcpServersByThreadId() {
+        return this.stateContainer.mcpServersByThreadId;
+    }
+    get appliedMcpServerConfigJson() {
+        return this.stateContainer.appliedMcpServerConfigJson;
+    }
+    set appliedMcpServerConfigJson(value) {
+        this.stateContainer.appliedMcpServerConfigJson = value;
+    }
+    constructor(connection, codexClient, options) {
         this.connection = connection;
+        this.shapeDriftReporter = new ShapeDriftReporter(options?.shapeDriftWarn);
         this.codex =
             codexClient ??
                 new CodexRpcClient({
@@ -832,31 +226,33 @@ export class CodexAppServerAcpAdapter {
                         process.stderr.write(`[codex-app-server-acp] protocol-error: ${error.reason}\n`);
                     },
                 });
+        this.streamEventHandler = new CodexStreamEventHandler({
+            codex: this.codex,
+            sessionIdByThreadId: this.sessionIdByThreadId,
+            sessions: this.sessions,
+            requireSession: (sessionId) => this.requireSession(sessionId),
+            emitSessionUpdate: (sessionId, update) => this.emitSessionUpdate(sessionId, update),
+            reportShapeDrift: (event, details) => this.reportShapeDrift(event, details),
+            buildToolCallState: (session, item, turnId) => this.buildToolCallState(session, item, turnId),
+            emitReasoningThoughtChunkFromItem: (sessionId, item) => this.emitReasoningThoughtChunkFromItem(sessionId, item),
+            shouldHoldTurnForPlanApproval: (session, item, turnId) => this.shouldHoldTurnForPlanApproval(session, item, turnId),
+            holdTurnUntilPlanApprovalResolves: (session, turnId) => this.holdTurnUntilPlanApprovalResolves(session, turnId),
+            maybeRequestPlanApproval: (session, item, turnId, completedPlanToolCall) => this.maybeRequestPlanApproval(session, item, turnId, completedPlanToolCall),
+            hasPendingPlanApprovals: (session, turnId) => this.hasPendingPlanApprovals(session, turnId),
+            settleTurn: (session, stopReason) => this.settleTurn(session, stopReason),
+            emitTurnFailureMessage: (sessionId, errorMessage) => this.emitTurnFailureMessage(sessionId, errorMessage),
+        });
         this.monitorConnectionClose();
     }
     monitorConnectionClose() {
-        let attachAttempts = 0;
-        const attachCloseWatcher = () => {
-            try {
-                void this.connection.closed
-                    .finally(async () => {
-                    await this.codex.stop();
-                })
-                    .catch(() => {
-                });
-            }
-            catch {
-                attachAttempts += 1;
-                if (attachAttempts >= MAX_CLOSE_WATCHER_ATTACH_RETRIES) {
-                    process.stderr.write(`[codex-app-server-acp] failed to attach close watcher after ${MAX_CLOSE_WATCHER_ATTACH_RETRIES} attempts\n`);
-                    void this.codex.stop();
-                    return;
-                }
-                const retryTimer = setTimeout(attachCloseWatcher, 0);
-                retryTimer.unref?.();
-            }
-        };
-        queueMicrotask(attachCloseWatcher);
+        attachCloseWatcherWithRetry({
+            getClosed: () => this.connection.closed,
+            onClose: async () => this.codex.stop(),
+            onAttachRetryLimitReached: (maxAttempts) => {
+                process.stderr.write(`[codex-app-server-acp] failed to attach close watcher after ${maxAttempts} attempts\n`);
+                void this.codex.stop();
+            },
+        });
     }
     async initialize(_params) {
         this.codex.start();
@@ -870,11 +266,11 @@ export class CodexAppServerAcpAdapter {
             },
         });
         this.codex.notify('initialized');
-        const configRequirements = await this.loadConfigRequirements();
+        const configRequirements = await loadConfigRequirements({ codex: this.codex });
         this.allowedApprovalPolicies = configRequirements.allowedApprovalPolicies;
         this.allowedSandboxModes = configRequirements.allowedSandboxModes;
-        this.collaborationModes = await this.loadCollaborationModes();
-        this.modelCatalog = await this.loadModelCatalog();
+        this.collaborationModes = await loadCollaborationModes({ codex: this.codex });
+        this.modelCatalog = await loadModelCatalog({ codex: this.codex });
         return {
             protocolVersion: PROTOCOL_VERSION,
             agentInfo: {
@@ -892,91 +288,42 @@ export class CodexAppServerAcpAdapter {
         };
     }
     async newSession(params) {
-        const defaultModel = this.resolveDefaultModel();
-        const responseRaw = await this.codex.request('thread/start', {
+        const negotiatedSession = await negotiateNewSession({
+            codex: this.codex,
             cwd: params.cwd,
-            model: defaultModel,
+            resolveDefaultModel: () => this.resolveDefaultModel(),
+            resolveSessionModel: (model, fallbackModel) => this.resolveSessionModel(model, fallbackModel),
+            resolveSandboxPolicy: (sandbox, cwd) => this.resolveSandboxPolicy(sandbox, cwd),
+            resolveReasoningEffortForModel: (modelId, candidateReasoningEffort) => this.resolveReasoningEffortForModel(modelId, candidateReasoningEffort),
+            resolveDefaultCollaborationMode: () => this.resolveDefaultCollaborationMode(),
         });
-        const response = threadStartResponseSchema.parse(responseRaw);
-        const sessionId = toSessionId(response.thread.id);
-        const approvalPolicy = this.requireApprovalPolicy(response.approvalPolicy, 'thread/start');
-        const model = this.resolveSessionModel(response.model, defaultModel);
-        const sandboxPolicy = this.resolveSandboxPolicy(response.sandbox, params.cwd);
-        const reasoningEffort = this.resolveReasoningEffortForModel(model, response.reasoningEffort);
-        const collaborationMode = this.resolveDefaultCollaborationMode();
-        const session = {
-            sessionId,
-            threadId: response.thread.id,
-            cwd: params.cwd,
-            defaults: {
-                model,
-                approvalPolicy,
-                sandboxPolicy,
-                reasoningEffort,
-                collaborationMode,
-            },
-            activeTurn: null,
-            toolCallsByItemId: new Map(),
-            syntheticallyCompletedToolItemIds: new Set(),
-            reasoningDeltaItemIds: new Set(),
-            planTextByItemId: new Map(),
-            planApprovalRequestedByTurnId: new Set(),
-            pendingPlanApprovalsByTurnId: new Map(),
-            pendingTurnCompletionsByTurnId: new Map(),
-            commandApprovalScopes: new Set(),
-            replayedTurnItemKeys: new Set(),
-        };
-        this.sessions.set(sessionId, session);
-        this.sessionIdByThreadId.set(session.threadId, sessionId);
+        const session = this.stateContainer.createSession(negotiatedSession);
+        this.stateContainer.registerSession(session);
         try {
             await this.applyMcpServers(session.threadId, params.mcpServers);
         }
         catch (error) {
-            this.sessions.delete(sessionId);
-            this.sessionIdByThreadId.delete(session.threadId);
+            this.stateContainer.deleteSession(negotiatedSession.sessionId);
             throw error;
         }
         return {
-            sessionId,
+            sessionId: negotiatedSession.sessionId,
             configOptions: this.buildConfigOptions(session),
         };
     }
     async loadSession(params) {
-        const threadId = toThreadId(params.sessionId);
-        const responseRaw = await this.codex.request('thread/resume', {
-            threadId,
-            cwd: params.cwd,
-        });
-        const response = threadResumeResponseSchema.parse(responseRaw);
-        const approvalPolicy = this.requireApprovalPolicy(response.approvalPolicy, 'thread/resume');
-        const model = this.resolveSessionModel(response.model, this.resolveDefaultModel());
-        const sandboxPolicy = this.resolveSandboxPolicy(response.sandbox, params.cwd);
-        const reasoningEffort = this.resolveReasoningEffortForModel(model, response.reasoningEffort);
-        const collaborationMode = this.resolveDefaultCollaborationMode();
-        const session = {
+        const negotiatedSession = await negotiateSessionResume({
+            codex: this.codex,
             sessionId: params.sessionId,
-            threadId: response.thread.id,
             cwd: params.cwd,
-            defaults: {
-                model,
-                approvalPolicy,
-                sandboxPolicy,
-                reasoningEffort,
-                collaborationMode,
-            },
-            activeTurn: null,
-            toolCallsByItemId: new Map(),
-            syntheticallyCompletedToolItemIds: new Set(),
-            reasoningDeltaItemIds: new Set(),
-            planTextByItemId: new Map(),
-            planApprovalRequestedByTurnId: new Set(),
-            pendingPlanApprovalsByTurnId: new Map(),
-            pendingTurnCompletionsByTurnId: new Map(),
-            commandApprovalScopes: new Set(),
-            replayedTurnItemKeys: new Set(),
-        };
-        this.sessions.set(session.sessionId, session);
-        this.sessionIdByThreadId.set(session.threadId, session.sessionId);
+            resolveDefaultModel: () => this.resolveDefaultModel(),
+            resolveSessionModel: (model, fallbackModel) => this.resolveSessionModel(model, fallbackModel),
+            resolveSandboxPolicy: (sandbox, cwd) => this.resolveSandboxPolicy(sandbox, cwd),
+            resolveReasoningEffortForModel: (modelId, candidateReasoningEffort) => this.resolveReasoningEffortForModel(modelId, candidateReasoningEffort),
+            resolveDefaultCollaborationMode: () => this.resolveDefaultCollaborationMode(),
+        });
+        const session = this.stateContainer.createSession(negotiatedSession);
+        this.stateContainer.registerSession(session);
         try {
             await this.applyMcpServers(session.threadId, params.mcpServers);
             await this.replayThreadHistory(session.sessionId, session.threadId);
@@ -987,8 +334,7 @@ export class CodexAppServerAcpAdapter {
             }
             catch {
             }
-            this.sessions.delete(session.sessionId);
-            this.sessionIdByThreadId.delete(session.threadId);
+            this.stateContainer.deleteSession(session.sessionId);
             throw error;
         }
         return {
@@ -1040,7 +386,7 @@ export class CodexAppServerAcpAdapter {
                 break;
             }
             case 'model': {
-                if (!this.modelCatalog.some((model) => model.id === params.value)) {
+                if (!isKnownModel(this.modelCatalog, params.value)) {
                     throw RequestError.invalidParams({
                         configId: params.configId,
                         value: params.value,
@@ -1052,12 +398,7 @@ export class CodexAppServerAcpAdapter {
             }
             case 'reasoning_effort':
             case 'thought_level': {
-                const modelEntry = this.modelCatalog.find((model) => model.id === session.defaults.model);
-                const supportedReasoningEfforts = modelEntry?.supportedReasoningEfforts ?? [];
-                const supportedValues = new Set(supportedReasoningEfforts
-                    .map((entry) => entry.reasoningEffort)
-                    .filter((effort) => isNonEmptyString(effort)));
-                if (!supportedValues.has(params.value)) {
+                if (!isReasoningEffortSupportedForModel(this.modelCatalog, session.defaults.model, params.value)) {
                     throw RequestError.invalidParams({
                         configId: params.configId,
                         value: params.value,
@@ -1207,15 +548,7 @@ export class CodexAppServerAcpAdapter {
         }
     }
     resolveDefaultModel() {
-        const preferred = this.modelCatalog.find((model) => model.isDefault);
-        const fallback = this.modelCatalog[0]?.id;
-        if (preferred?.id) {
-            return preferred.id;
-        }
-        if (fallback) {
-            return fallback;
-        }
-        throw new Error('Codex app-server model/list returned no models');
+        return resolveDefaultModel(this.modelCatalog);
     }
     buildMergedMcpServersConfig() {
         const merged = {};
@@ -1288,414 +621,41 @@ export class CodexAppServerAcpAdapter {
         }
     }
     buildConfigOptions(session) {
-        const executionPresets = this.getExecutionPresets(session);
-        const currentExecutionPreset = this.resolveExecutionPresetId(session, executionPresets);
-        const configOptions = [
-            createModelConfigOption(session.defaults.model, this.modelCatalog),
-            createCollaborationModeConfigOption(session.defaults.collaborationMode, this.collaborationModes),
-            createExecutionModeConfigOption(currentExecutionPreset, executionPresets),
-        ];
-        const reasoningOption = createReasoningEffortConfigOption(session.defaults.reasoningEffort, this.modelCatalog, session.defaults.model);
-        if (reasoningOption) {
-            configOptions.push(reasoningOption);
-        }
-        return configOptions;
-    }
-    requireApprovalPolicy(approvalPolicy, source) {
-        if (!isNonEmptyString(approvalPolicy)) {
-            throw new Error(`Codex ${source} response did not include approvalPolicy`);
-        }
-        return approvalPolicy;
+        return buildConfigOptions(session, this.modelCatalog, this.collaborationModes, this.allowedApprovalPolicies, this.allowedSandboxModes);
     }
     resolveSessionModel(model, fallbackModel) {
-        return isNonEmptyString(model) ? model : fallbackModel;
+        return resolveSessionModel(model, fallbackModel);
     }
     resolveSandboxPolicy(sandbox, cwd) {
-        return isRecord(sandbox) ? sandbox : createWorkspaceWriteSandboxPolicy(cwd);
+        return resolveSandboxPolicy(sandbox, cwd);
     }
     resolveDefaultCollaborationMode() {
-        if (this.collaborationModes.length === 0) {
-            throw new Error('Codex collaborationMode/list returned no modes');
-        }
-        const preferredDefault = this.collaborationModes.find((entry) => entry.mode === 'default');
-        const firstMode = this.collaborationModes[0]?.mode;
-        if (!firstMode) {
-            throw new Error('Codex collaborationMode/list returned an invalid mode entry');
-        }
-        return preferredDefault?.mode ?? firstMode;
+        return resolveDefaultCollaborationMode(this.collaborationModes);
     }
     resolveTurnCollaborationMode(session) {
-        const modeEntry = this.collaborationModes.find((entry) => entry.mode === session.defaults.collaborationMode);
-        return {
-            mode: modeEntry?.mode ?? session.defaults.collaborationMode,
-            settings: {
-                model: modeEntry?.model ?? session.defaults.model,
-                reasoning_effort: modeEntry?.reasoningEffort ?? session.defaults.reasoningEffort,
-                developer_instructions: modeEntry?.developerInstructions ?? null,
-            },
-        };
+        return resolveTurnCollaborationMode(this.collaborationModes, session);
     }
     resolveReasoningEffortForModel(modelId, candidateReasoningEffort) {
-        const modelEntry = this.modelCatalog.find((entry) => entry.id === modelId);
-        if (!modelEntry) {
-            return null;
-        }
-        const supportedEntries = modelEntry.supportedReasoningEfforts.filter((entry) => isNonEmptyString(entry.reasoningEffort));
-        if (supportedEntries.length === 0) {
-            return null;
-        }
-        const supportedValues = dedupeStrings(supportedEntries.map((entry) => entry.reasoningEffort));
-        if (isNonEmptyString(candidateReasoningEffort) &&
-            supportedValues.includes(candidateReasoningEffort)) {
-            return candidateReasoningEffort;
-        }
-        if (supportedValues.includes(modelEntry.defaultReasoningEffort)) {
-            return modelEntry.defaultReasoningEffort;
-        }
-        return supportedValues[0] ?? null;
+        return resolveReasoningEffortForModel(this.modelCatalog, modelId, candidateReasoningEffort);
     }
     getCollaborationModeValues(currentMode) {
-        const values = this.collaborationModes
-            .map((entry) => entry.mode)
-            .filter((mode) => isNonEmptyString(mode));
-        if (!values.includes(currentMode)) {
-            values.unshift(currentMode);
-        }
-        return dedupeStrings(values);
-    }
-    resolveCurrentSandboxMode(session) {
-        const currentSandboxMode = parseSandboxModeFromPolicy(session.defaults.sandboxPolicy);
-        if (currentSandboxMode) {
-            return currentSandboxMode;
-        }
-        const allowedSandboxMode = this.allowedSandboxModes[0];
-        if (allowedSandboxMode) {
-            return allowedSandboxMode;
-        }
-        throw new Error('Unable to resolve current sandbox mode for execution-mode options');
+        return getCollaborationModeValues(this.collaborationModes, currentMode);
     }
     getExecutionPresets(session) {
-        const currentSandboxMode = this.resolveCurrentSandboxMode(session);
-        const policies = this.allowedApprovalPolicies.length > 0
-            ? this.allowedApprovalPolicies
-            : [session.defaults.approvalPolicy];
-        const sandboxModes = this.allowedSandboxModes.length > 0 ? this.allowedSandboxModes : [currentSandboxMode];
-        const presets = [];
-        const seen = new Set();
-        const addPreset = (approvalPolicy, sandboxMode, description) => {
-            const id = toExecutionPresetId(approvalPolicy, sandboxMode);
-            if (seen.has(id)) {
-                return;
-            }
-            seen.add(id);
-            presets.push({
-                id,
-                name: formatExecutionPresetName(approvalPolicy, sandboxMode),
-                ...(description ? { description } : {}),
-                approvalPolicy,
-                sandboxMode,
-            });
-        };
-        addPreset(session.defaults.approvalPolicy, currentSandboxMode, `Current session: ${formatExecutionPresetName(session.defaults.approvalPolicy, currentSandboxMode)}`);
-        for (const policy of policies) {
-            for (const sandboxMode of sandboxModes) {
-                addPreset(policy, sandboxMode);
-            }
-        }
-        return presets;
-    }
-    resolveExecutionPresetId(session, presets) {
-        const currentSandboxMode = this.resolveCurrentSandboxMode(session);
-        const currentPresetId = toExecutionPresetId(session.defaults.approvalPolicy, currentSandboxMode);
-        const fallbackPresetId = presets[0]?.id;
-        if (!fallbackPresetId) {
-            throw new Error('Execution-mode presets are unavailable for this session');
-        }
-        return presets.some((preset) => preset.id === currentPresetId)
-            ? currentPresetId
-            : fallbackPresetId;
+        return getExecutionPresets(session, this.allowedApprovalPolicies, this.allowedSandboxModes);
     }
     requireSession(sessionId) {
-        const session = this.sessions.get(sessionId);
+        const session = this.stateContainer.getSession(sessionId);
         if (!session) {
             throw RequestError.invalidParams({ sessionId });
         }
         return session;
     }
-    async loadConfigRequirements() {
-        const raw = await this.codex.request('configRequirements/read', undefined);
-        const parsed = configRequirementsReadResponseSchema.parse(raw);
-        const requirements = parsed.requirements;
-        const allowedApprovalPolicies = dedupeStrings((requirements?.allowedApprovalPolicies ?? []).filter(isNonEmptyString));
-        const allowedSandboxModes = dedupeStrings((requirements?.allowedSandboxModes ?? []).filter((mode) => mode === 'read-only' || mode === 'workspace-write' || mode === 'danger-full-access'));
-        const hasExplicitApprovalPolicies = Array.isArray(requirements?.allowedApprovalPolicies);
-        const hasExplicitSandboxModes = Array.isArray(requirements?.allowedSandboxModes);
-        return {
-            allowedApprovalPolicies: allowedApprovalPolicies.length > 0
-                ? allowedApprovalPolicies
-                : hasExplicitApprovalPolicies
-                    ? []
-                    : DEFAULT_APPROVAL_POLICIES,
-            allowedSandboxModes: allowedSandboxModes.length > 0
-                ? allowedSandboxModes
-                : hasExplicitSandboxModes
-                    ? []
-                    : DEFAULT_SANDBOX_MODES,
-        };
-    }
-    async loadCollaborationModes() {
-        const entries = [];
-        let cursor = null;
-        for (;;) {
-            const response = await this.requestCollaborationModeListWithRetry(cursor);
-            entries.push(...response.data.flatMap((entry) => isNonEmptyString(entry.mode)
-                ? [
-                    {
-                        mode: entry.mode,
-                        name: entry.name,
-                        model: entry.model ?? null,
-                        reasoningEffort: entry.reasoning_effort ?? null,
-                        developerInstructions: entry.developer_instructions ?? null,
-                    },
-                ]
-                : []));
-            cursor = response.nextCursor ?? null;
-            if (!cursor) {
-                break;
-            }
-        }
-        if (entries.length === 0) {
-            throw new Error('Codex collaborationMode/list returned no modes');
-        }
-        return entries;
-    }
-    async requestCollaborationModeListWithRetry(cursor, maxAttempts = 3) {
-        let attempt = 0;
-        let lastError;
-        while (attempt < maxAttempts) {
-            attempt += 1;
-            try {
-                const raw = await this.codex.request('collaborationMode/list', cursor ? { cursor } : {});
-                return collaborationModeListResponseSchema.parse(raw);
-            }
-            catch (error) {
-                lastError = error;
-                if (!(error instanceof CodexRequestError) ||
-                    error.code !== -32_001 ||
-                    attempt >= maxAttempts) {
-                    throw error;
-                }
-                const delayMs = Math.round(2 ** attempt * 100 + Math.random() * 120);
-                await new Promise((resolve) => setTimeout(resolve, delayMs));
-            }
-        }
-        throw lastError;
-    }
-    async loadModelCatalog() {
-        const models = [];
-        let cursor = null;
-        for (;;) {
-            const response = await this.requestModelListWithRetry(cursor);
-            models.push(...response.data.map((model) => ({
-                id: model.id,
-                displayName: model.displayName,
-                description: model.description,
-                defaultReasoningEffort: model.defaultReasoningEffort,
-                supportedReasoningEfforts: (model.supportedReasoningEfforts ?? [])
-                    .filter((entry) => isNonEmptyString(entry.reasoningEffort))
-                    .map((entry) => ({
-                    reasoningEffort: entry.reasoningEffort,
-                    description: entry.description,
-                })),
-                inputModalities: model.inputModalities ?? [],
-                isDefault: model.isDefault ?? false,
-            })));
-            cursor = response.nextCursor ?? null;
-            if (!cursor) {
-                return models;
-            }
-        }
-    }
-    async requestModelListWithRetry(cursor, maxAttempts = 3) {
-        let attempt = 0;
-        let lastError;
-        while (attempt < maxAttempts) {
-            attempt += 1;
-            try {
-                const raw = await this.codex.request('model/list', cursor ? { cursor } : {});
-                return modelListResponseSchema.parse(raw);
-            }
-            catch (error) {
-                lastError = error;
-                if (!(error instanceof CodexRequestError) ||
-                    error.code !== -32_001 ||
-                    attempt >= maxAttempts) {
-                    throw error;
-                }
-                const delayMs = Math.round(2 ** attempt * 100 + Math.random() * 120);
-                await new Promise((resolve) => setTimeout(resolve, delayMs));
-            }
-        }
-        throw lastError;
-    }
     async replayThreadHistory(sessionId, threadId) {
-        const session = this.requireSession(sessionId);
-        const threadReadRaw = await this.codex.request('thread/read', {
-            threadId,
-            includeTurns: true,
-        });
-        const threadRead = threadReadResponseSchema.parse(threadReadRaw);
-        for (const turn of threadRead.thread.turns) {
-            for (const item of turn.items) {
-                await this.replayThreadHistoryItem(session, sessionId, turn.id, item);
-            }
-        }
-    }
-    async replayThreadHistoryItem(session, sessionId, turnId, item) {
-        if (item.type === 'userMessage') {
-            await this.replayUserMessageHistoryItem(sessionId, item);
-            return;
-        }
-        if (item.type === 'agentMessage') {
-            await this.replayAgentMessageHistoryItem(sessionId, item);
-            return;
-        }
-        await this.replayToolLikeHistoryItem(session, sessionId, turnId, item);
-    }
-    async replayUserMessageHistoryItem(sessionId, item) {
-        const contentBlocks = Array.isArray(item.content) ? item.content : [];
-        for (const content of contentBlocks) {
-            if (!isRecord(content) || content.type !== 'text' || typeof content.text !== 'string') {
-                continue;
-            }
-            await this.emitSessionUpdate(sessionId, {
-                sessionUpdate: 'user_message_chunk',
-                content: { type: 'text', text: content.text },
-            });
-        }
-    }
-    async replayAgentMessageHistoryItem(sessionId, item) {
-        const text = asString(item.text);
-        if (!text) {
-            return;
-        }
-        await this.emitSessionUpdate(sessionId, {
-            sessionUpdate: 'agent_message_chunk',
-            content: { type: 'text', text },
-        });
-    }
-    async replayToolLikeHistoryItem(session, sessionId, turnId, item) {
-        if (item.type === 'reasoning') {
-            await this.emitSessionUpdate(sessionId, {
-                sessionUpdate: 'tool_call',
-                toolCallId: resolveToolCallId({ itemId: item.id, source: item }),
-                title: 'reasoning',
-                kind: 'think',
-                status: 'completed',
-                rawInput: item,
-                rawOutput: item,
-            });
-            await this.emitReasoningThoughtChunkFromItem(sessionId, item);
-            session.replayedTurnItemKeys.add(toTurnItemKey(turnId, item.id));
-            return;
-        }
-        const toolInfo = this.buildToolCallState(session, item, turnId);
-        if (!toolInfo) {
-            this.reportShapeDrift('unhandled_replay_item', {
-                turnId,
-                itemType: item.type,
-                itemId: item.id,
-            });
-            return;
-        }
-        await this.emitSessionUpdate(sessionId, {
-            sessionUpdate: 'tool_call',
-            toolCallId: toolInfo.toolCallId,
-            title: toolInfo.title,
-            kind: toolInfo.kind,
-            status: 'completed',
-            rawInput: item,
-            rawOutput: item,
-        });
-        session.replayedTurnItemKeys.add(toTurnItemKey(turnId, item.id));
+        await this.streamEventHandler.replayThreadHistory(sessionId, threadId);
     }
     async handleCodexNotification(method, params) {
-        const parsed = knownCodexNotificationSchema.safeParse({ method, params });
-        if (!parsed.success) {
-            this.reportShapeDrift('malformed_notification', {
-                method,
-                issues: parsed.error.issues.slice(0, 3).map((issue) => issue.message),
-            });
-            return;
-        }
-        const notification = parsed.data;
-        if (notification.method === 'error' || notification.method === 'turn/started') {
-            return;
-        }
-        const sessionId = this.sessionIdByThreadId.get(notification.params.threadId);
-        if (!sessionId) {
-            return;
-        }
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            return;
-        }
-        if (notification.method === 'item/agentMessage/delta') {
-            await this.emitSessionUpdate(sessionId, {
-                sessionUpdate: 'agent_message_chunk',
-                content: {
-                    type: 'text',
-                    text: notification.params.delta,
-                },
-            });
-            return;
-        }
-        if (notification.method === 'item/plan/delta') {
-            await this.handlePlanDelta(sessionId, session, notification.params.itemId, notification.params.delta);
-            return;
-        }
-        if (notification.method === 'item/reasoning/summaryTextDelta') {
-            await this.emitReasoningThoughtDelta(sessionId, session, notification.params.turnId, notification.params.itemId, notification.params.delta);
-            return;
-        }
-        if (notification.method === 'item/commandExecution/outputDelta') {
-            await this.emitToolCallProgress(sessionId, session, notification.params.turnId, notification.params.itemId, notification.params.delta, 'commandExecution');
-            return;
-        }
-        if (notification.method === 'item/fileChange/outputDelta') {
-            await this.emitToolCallProgress(sessionId, session, notification.params.turnId, notification.params.itemId, notification.params.delta, 'fileChange');
-            return;
-        }
-        if (notification.method === 'item/mcpToolCall/progress') {
-            await this.emitToolCallProgress(sessionId, session, notification.params.turnId, notification.params.itemId, notification.params.message, 'mcpToolCall');
-            return;
-        }
-        if (notification.method === 'item/started') {
-            await this.handleItemStarted(session, notification.params.item, notification.params.turnId);
-            return;
-        }
-        if (notification.method === 'item/completed') {
-            await this.handleItemCompleted(session, notification.params.item, notification.params.turnId);
-            return;
-        }
-        if (notification.method === 'turn/completed') {
-            await this.handleTurnCompletedNotification(session, notification.params.turn.id, notification.params.turn.status, notification.params.turn.error?.message);
-        }
-    }
-    async handlePlanDelta(sessionId, session, itemId, delta) {
-        const previous = session.planTextByItemId.get(itemId) ?? '';
-        const next = `${previous}${delta}`;
-        session.planTextByItemId.set(itemId, next);
-        await this.emitSessionUpdate(sessionId, {
-            sessionUpdate: 'plan',
-            entries: [
-                {
-                    content: next,
-                    priority: 'medium',
-                    status: 'in_progress',
-                },
-            ],
-        });
+        await this.streamEventHandler.handleCodexNotification({ method, params });
     }
     async emitReasoningThoughtChunkFromItem(sessionId, item) {
         const text = extractReasoningTextLocal(item);
@@ -1707,262 +667,11 @@ export class CodexAppServerAcpAdapter {
             content: { type: 'text', text },
         });
     }
-    isReplayedTurnItem(session, turnId, itemId) {
-        return session.replayedTurnItemKeys.has(toTurnItemKey(turnId, itemId));
-    }
-    async emitReasoningThoughtDelta(sessionId, session, turnId, itemId, delta) {
-        if (this.isReplayedTurnItem(session, turnId, itemId)) {
-            return;
-        }
-        if (delta.length === 0) {
-            return;
-        }
-        const existing = session.toolCallsByItemId.get(itemId);
-        if (!existing) {
-            const toolCallId = resolveToolCallId({
-                itemId,
-            });
-            session.toolCallsByItemId.set(itemId, {
-                toolCallId,
-                title: 'reasoning',
-                kind: 'think',
-                locations: [],
-            });
-            await this.emitSessionUpdate(sessionId, {
-                sessionUpdate: 'tool_call',
-                toolCallId,
-                title: 'reasoning',
-                kind: 'think',
-                status: 'pending',
-                rawInput: {
-                    type: 'reasoning',
-                    id: itemId,
-                },
-            });
-            await this.emitSessionUpdate(sessionId, {
-                sessionUpdate: 'tool_call_update',
-                toolCallId,
-                title: 'reasoning',
-                kind: 'think',
-                status: 'in_progress',
-            });
-        }
-        session.reasoningDeltaItemIds.add(itemId);
-        await this.emitSessionUpdate(sessionId, {
-            sessionUpdate: 'agent_thought_chunk',
-            content: { type: 'text', text: delta },
-        });
-    }
-    async emitToolCallProgress(sessionId, session, turnId, itemId, output, source) {
-        if (this.isReplayedTurnItem(session, turnId, itemId)) {
-            return;
-        }
-        const toolCall = session.toolCallsByItemId.get(itemId);
-        if (!toolCall) {
-            this.reportShapeDrift('tool_progress_without_tool_call', { turnId, itemId });
-            return;
-        }
-        if (session.syntheticallyCompletedToolItemIds.has(itemId)) {
-            return;
-        }
-        if (source === 'commandExecution' && isCommandExecutionSessionHandoffOutput(output)) {
-            session.syntheticallyCompletedToolItemIds.add(itemId);
-            await this.emitSessionUpdate(sessionId, {
-                sessionUpdate: 'tool_call_update',
-                toolCallId: toolCall.toolCallId,
-                status: 'completed',
-                kind: toolCall.kind,
-                title: toolCall.title,
-                ...(toolCall.locations.length > 0 ? { locations: toolCall.locations } : {}),
-                rawOutput: output,
-            });
-            return;
-        }
-        await this.emitSessionUpdate(sessionId, {
-            sessionUpdate: 'tool_call_update',
-            toolCallId: toolCall.toolCallId,
-            status: 'in_progress',
-            ...(toolCall.locations.length > 0 ? { locations: toolCall.locations } : {}),
-            rawOutput: output,
-        });
-    }
-    async handleTurnCompletedNotification(session, turnId, status, errorMessage) {
-        if (status === 'inProgress') {
-            return;
-        }
-        const completionStatus = status;
-        if (this.shouldDeferTurnCompletion(session, turnId, completionStatus)) {
-            session.pendingTurnCompletionsByTurnId.set(turnId, this.buildPendingTurnCompletion(completionStatus, errorMessage));
-            return;
-        }
-        await this.finalizeTurnCompletion(session, completionStatus, errorMessage);
-    }
-    shouldDeferTurnCompletion(session, turnId, status) {
-        if (!session.activeTurn || session.activeTurn.turnId !== turnId) {
-            return true;
-        }
-        return status !== 'interrupted' && this.hasPendingPlanApprovals(session, turnId);
-    }
-    buildPendingTurnCompletion(status, errorMessage) {
-        const stopReason = status === 'interrupted' ? 'cancelled' : 'end_turn';
-        if (status === 'failed' && errorMessage) {
-            return { stopReason, errorMessage };
-        }
-        return { stopReason };
-    }
-    async finalizeTurnCompletion(session, status, errorMessage) {
-        if (status === 'interrupted') {
-            this.settleTurn(session, 'cancelled');
-            return;
-        }
-        if (status === 'failed' && errorMessage) {
-            await this.emitTurnFailureMessage(session.sessionId, errorMessage);
-        }
-        if (status === 'failed') {
-            this.settleTurn(session, 'end_turn');
-            return;
-        }
-        this.settleTurn(session, session.activeTurn?.cancelRequested ? 'cancelled' : 'end_turn');
-    }
-    async handleItemStarted(session, item, turnId) {
-        if (this.isReplayedTurnItem(session, turnId, item.id)) {
-            return;
-        }
-        if (item.type === 'reasoning') {
-            const existing = session.toolCallsByItemId.get(item.id);
-            const toolInfo = existing ??
-                {
-                    toolCallId: resolveToolCallId({
-                        itemId: item.id,
-                        source: item,
-                    }),
-                    title: 'reasoning',
-                    kind: 'think',
-                    locations: [],
-                };
-            if (!existing) {
-                session.syntheticallyCompletedToolItemIds.delete(item.id);
-                session.toolCallsByItemId.set(item.id, toolInfo);
-                await this.emitSessionUpdate(session.sessionId, {
-                    sessionUpdate: 'tool_call',
-                    toolCallId: toolInfo.toolCallId,
-                    title: toolInfo.title,
-                    kind: toolInfo.kind,
-                    status: 'pending',
-                    rawInput: item,
-                });
-            }
-            await this.emitSessionUpdate(session.sessionId, {
-                sessionUpdate: 'tool_call_update',
-                toolCallId: toolInfo.toolCallId,
-                title: toolInfo.title,
-                kind: toolInfo.kind,
-                status: 'in_progress',
-            });
-            return;
-        }
-        const toolInfo = this.buildToolCallState(session, item, turnId);
-        if (!toolInfo) {
-            this.reportShapeDrift('unhandled_item_started_type', {
-                turnId,
-                itemType: item.type,
-                itemId: item.id,
-            });
-            return;
-        }
-        session.syntheticallyCompletedToolItemIds.delete(item.id);
-        session.toolCallsByItemId.set(item.id, toolInfo);
-        await this.emitSessionUpdate(session.sessionId, {
-            sessionUpdate: 'tool_call',
-            toolCallId: toolInfo.toolCallId,
-            title: toolInfo.title,
-            kind: toolInfo.kind,
-            status: 'pending',
-            ...(toolInfo.locations.length > 0 ? { locations: toolInfo.locations } : {}),
-            rawInput: item,
-        });
-        const itemStatus = toToolStatus(item.status);
-        if (itemStatus === 'in_progress') {
-            await this.emitSessionUpdate(session.sessionId, {
-                sessionUpdate: 'tool_call_update',
-                toolCallId: toolInfo.toolCallId,
-                status: 'in_progress',
-            });
-        }
-    }
-    async handleItemCompleted(session, item, turnId) {
-        if (this.isReplayedTurnItem(session, turnId, item.id)) {
-            return;
-        }
-        if (item.type === 'reasoning') {
-            const existing = session.toolCallsByItemId.get(item.id);
-            const reasoningToolCallId = existing?.toolCallId ??
-                resolveToolCallId({
-                    itemId: item.id,
-                    source: item,
-                });
-            if (existing) {
-                await this.emitSessionUpdate(session.sessionId, {
-                    sessionUpdate: 'tool_call_update',
-                    toolCallId: reasoningToolCallId,
-                    title: existing.title,
-                    kind: existing.kind,
-                    status: toToolStatus(item.status) ?? 'completed',
-                    rawOutput: item,
-                });
-            }
-            else {
-                await this.emitSessionUpdate(session.sessionId, {
-                    sessionUpdate: 'tool_call',
-                    toolCallId: reasoningToolCallId,
-                    title: 'reasoning',
-                    kind: 'think',
-                    status: toToolStatus(item.status) ?? 'completed',
-                    rawInput: item,
-                    rawOutput: item,
-                });
-            }
-            session.toolCallsByItemId.delete(item.id);
-            session.syntheticallyCompletedToolItemIds.delete(item.id);
-            const sawDelta = session.reasoningDeltaItemIds.has(item.id);
-            session.reasoningDeltaItemIds.delete(item.id);
-            if (!sawDelta) {
-                await this.emitReasoningThoughtChunkFromItem(session.sessionId, item);
-            }
-            return;
-        }
-        const existing = session.toolCallsByItemId.get(item.id);
-        if (!existing) {
-            this.reportShapeDrift('item_completed_without_started_state', {
-                turnId,
-                itemType: item.type,
-                itemId: item.id,
-            });
-            return;
-        }
-        const shouldHoldTurnForPlanApproval = item.type === 'plan' &&
+    shouldHoldTurnForPlanApproval(session, item, turnId) {
+        return (item.type === 'plan' &&
             isPlanLikeMode(session.defaults.collaborationMode) &&
             !session.planApprovalRequestedByTurnId.has(turnId) &&
-            this.extractPlanApprovalText(session, item) !== null;
-        if (shouldHoldTurnForPlanApproval) {
-            this.holdTurnUntilPlanApprovalResolves(session, turnId);
-        }
-        const statusFromItem = toToolStatus(item.status);
-        const status = statusFromItem ?? 'completed';
-        const completionLocations = this.extractLocations(item);
-        const locations = dedupeLocations([...existing.locations, ...completionLocations]);
-        await this.emitSessionUpdate(session.sessionId, {
-            sessionUpdate: 'tool_call_update',
-            toolCallId: existing.toolCallId,
-            status,
-            kind: existing.kind,
-            title: existing.title,
-            ...(locations.length > 0 ? { locations } : {}),
-            rawOutput: item,
-        });
-        session.toolCallsByItemId.delete(item.id);
-        session.syntheticallyCompletedToolItemIds.delete(item.id);
-        await this.maybeRequestPlanApproval(session, item, turnId, existing);
+            this.extractPlanApprovalText(session, item) !== null);
     }
     buildPlanApprovalInput(planText, sourceItemId) {
         return {
@@ -2001,11 +710,7 @@ export class CodexAppServerAcpAdapter {
         return left.localeCompare(right);
     }
     resolveCollaborationModeLabel(modeId) {
-        const entry = this.collaborationModes.find((candidate) => candidate.mode === modeId);
-        if (entry?.name) {
-            return entry.name;
-        }
-        return sanitizeModeName(modeId);
+        return resolveCollaborationModeLabel(this.collaborationModes, modeId);
     }
     buildPlanApprovalOptions(session) {
         const currentMode = session.defaults.collaborationMode;
@@ -2145,27 +850,6 @@ export class CodexAppServerAcpAdapter {
             await this.releaseTurnHoldForPlanApproval(session, turnId);
         }
     }
-    extractLocations(item) {
-        if (!isRecord(item) || item.type !== 'fileChange') {
-            return [];
-        }
-        const changes = item.changes;
-        if (!Array.isArray(changes)) {
-            return [];
-        }
-        const locations = [];
-        for (const change of changes) {
-            if (!isRecord(change)) {
-                continue;
-            }
-            const path = asString(change.path);
-            if (!path) {
-                continue;
-            }
-            locations.push({ path });
-        }
-        return locations;
-    }
     buildToolCallState(session, item, _turnId) {
         const kindByType = {
             commandExecution: 'execute',
@@ -2191,7 +875,7 @@ export class CodexAppServerAcpAdapter {
         }
         else if (item.type === 'fileChange') {
             title = 'fileChange';
-            locations = this.extractLocations(item);
+            locations = extractLocations(item);
         }
         else if (item.type === 'mcpToolCall') {
             const server = asString(item.server) ?? 'mcp';
@@ -2212,280 +896,15 @@ export class CodexAppServerAcpAdapter {
             locations,
         };
     }
-    buildPermissionOptions(params) {
-        if (params.method === 'item/tool/requestUserInput') {
-            return buildToolUserInputPermissionOptions(params.questions);
-        }
-        if (params.method === 'item/commandExecution/requestApproval') {
-            return [
-                {
-                    optionId: 'allow_always',
-                    name: 'Allow for session',
-                    kind: 'allow_always',
-                },
-                {
-                    optionId: 'allow_once',
-                    name: 'Allow once',
-                    kind: 'allow_once',
-                },
-                {
-                    optionId: 'reject_once',
-                    name: 'Reject',
-                    kind: 'reject_once',
-                },
-            ];
-        }
-        return [
-            {
-                optionId: 'allow_once',
-                name: 'Allow once',
-                kind: 'allow_once',
-            },
-            {
-                optionId: 'reject_once',
-                name: 'Reject',
-                kind: 'reject_once',
-            },
-        ];
-    }
-    async maybeAutoApproveCommandRequest(params) {
-        if (params.request.method !== 'item/commandExecution/requestApproval') {
-            return false;
-        }
-        const scopeKey = buildCommandApprovalScopeKey({
-            command: asString(params.request.params.command),
-            cwd: asString(params.request.params.cwd) ?? params.session.cwd,
-        });
-        if (!(scopeKey && params.session.commandApprovalScopes.has(scopeKey))) {
-            return false;
-        }
-        await this.respondToCodexPermissionRequest({
-            request: params.request,
-            permission: {
-                outcome: { outcome: 'selected', optionId: 'allow_always' },
-            },
-            session: params.session,
-            toolCallId: params.toolCallId,
-            questions: [],
-        });
-        return true;
-    }
     async handleCodexServerRequest(request) {
-        try {
-            const parsed = knownCodexServerRequestSchema.safeParse(request);
-            if (!parsed.success) {
-                this.reportShapeDrift('malformed_server_request', {
-                    method: request.method,
-                    issues: parsed.error.issues.slice(0, 3).map((issue) => issue.message),
-                });
-                this.codex.respondError(request.id, {
-                    code: -32_602,
-                    message: 'Unsupported codex server request payload',
-                });
-                return;
-            }
-            const typed = parsed.data;
-            const sessionId = this.sessionIdByThreadId.get(typed.params.threadId);
-            if (!sessionId) {
-                this.reportShapeDrift('request_for_unknown_thread', {
-                    method: typed.method,
-                    threadId: typed.params.threadId,
-                    itemId: typed.params.itemId,
-                });
-                this.codex.respondError(typed.id, {
-                    code: -32_603,
-                    message: 'No ACP session mapped for this thread',
-                });
-                return;
-            }
-            const session = this.sessions.get(sessionId);
-            if (!session) {
-                this.reportShapeDrift('request_for_missing_session', {
-                    method: typed.method,
-                    sessionId,
-                    itemId: typed.params.itemId,
-                });
-                this.codex.respondError(typed.id, {
-                    code: -32_603,
-                    message: 'No ACP session mapped for this thread',
-                });
-                return;
-            }
-            const existingTool = session.toolCallsByItemId.get(typed.params.itemId);
-            const toolCall = existingTool ??
-                this.buildApprovalToolCallState(session, typed.method, typed.params.itemId, typed.params.turnId, typed.params);
-            session.toolCallsByItemId.set(typed.params.itemId, toolCall);
-            if (!existingTool) {
-                await this.emitSessionUpdate(sessionId, {
-                    sessionUpdate: 'tool_call',
-                    toolCallId: toolCall.toolCallId,
-                    title: toolCall.title,
-                    kind: toolCall.kind,
-                    status: 'pending',
-                    ...(toolCall.locations.length > 0 ? { locations: toolCall.locations } : {}),
-                    rawInput: typed.params,
-                });
-            }
-            if (await this.maybeAutoApproveCommandRequest({
-                request: typed,
-                session,
-                toolCallId: toolCall.toolCallId,
-            })) {
-                return;
-            }
-            const questions = typed.method === 'item/tool/requestUserInput' ? typed.params.questions : [];
-            const permissionOptions = this.buildPermissionOptions({
-                method: typed.method,
-                questions,
-            });
-            await this.emitSessionUpdate(sessionId, {
-                sessionUpdate: 'tool_call_update',
-                toolCallId: toolCall.toolCallId,
-                title: toolCall.title,
-                kind: toolCall.kind,
-                status: 'pending',
-                ...(toolCall.locations.length > 0 ? { locations: toolCall.locations } : {}),
-            });
-            const permissionResult = await this.connection.requestPermission({
-                sessionId,
-                toolCall: {
-                    toolCallId: toolCall.toolCallId,
-                    title: toolCall.title,
-                    kind: toolCall.kind,
-                    status: 'pending',
-                    rawInput: typed.params,
-                },
-                options: permissionOptions,
-            });
-            await this.respondToCodexPermissionRequest({
-                request: typed,
-                permission: permissionResult,
-                session,
-                toolCallId: toolCall.toolCallId,
-                questions,
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            this.codex.respondError(request.id, {
-                code: -32_600,
-                message: 'Failed to process codex approval request',
-                data: { error: message },
-            });
-        }
-    }
-    buildApprovalToolCallState(session, method, itemId, _turnId, params) {
-        if (method === 'item/commandExecution/requestApproval') {
-            const command = asString(params.command);
-            const cwd = asString(params.cwd) ?? session.cwd;
-            const parsed = resolveCommandDisplay({ command, cwd });
-            return {
-                toolCallId: resolveToolCallId({
-                    itemId,
-                    source: params,
-                }),
-                title: parsed.title,
-                kind: parsed.kind,
-                locations: parsed.locations,
-            };
-        }
-        if (method === 'item/fileChange/requestApproval') {
-            const grantRoot = asString(params.grantRoot);
-            return {
-                toolCallId: resolveToolCallId({
-                    itemId,
-                    source: params,
-                }),
-                title: 'fileChange',
-                kind: 'edit',
-                locations: grantRoot ? [{ path: grantRoot }] : [],
-            };
-        }
-        return {
-            toolCallId: resolveToolCallId({
-                itemId,
-                source: params,
-            }),
-            title: 'item/tool/requestUserInput',
-            kind: 'other',
-            locations: [],
-        };
-    }
-    isAllowedPermissionSelection(selectedOptionId) {
-        return selectedOptionId === 'allow_once' || selectedOptionId === 'allow_always';
-    }
-    async handleToolUserInputPermissionResponse(params) {
-        if (params.request.method !== 'item/tool/requestUserInput') {
-            return false;
-        }
-        const rejected = params.selectedOptionId === null || params.selectedOptionId === 'reject_once';
-        let answers;
-        try {
-            answers = buildToolUserInputAnswers({
-                questions: params.questions,
-                permission: params.permission,
-                selectedOptionId: params.selectedOptionId,
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            this.codex.respondError(params.request.id, {
-                code: -32_602,
-                message: 'Failed to map requestUserInput answers',
-                data: { error: message },
-            });
-            await this.emitSessionUpdate(params.session.sessionId, {
-                sessionUpdate: 'tool_call_update',
-                toolCallId: params.toolCallId,
-                status: 'failed',
-                rawOutput: { error: message },
-            });
-            return true;
-        }
-        this.codex.respondSuccess(params.request.id, {
-            answers,
-        });
-        await this.emitSessionUpdate(params.session.sessionId, {
-            sessionUpdate: 'tool_call_update',
-            toolCallId: params.toolCallId,
-            status: rejected ? 'failed' : 'completed',
-            rawOutput: rejected ? { outcome: 'rejected' } : { answers },
-        });
-        return true;
-    }
-    async respondToCodexPermissionRequest(params) {
-        const selected = params.permission.outcome.outcome === 'selected' ? params.permission.outcome.optionId : null;
-        if (await this.handleToolUserInputPermissionResponse({
-            ...params,
-            selectedOptionId: selected,
-        })) {
-            return;
-        }
-        if (params.request.method === 'item/commandExecution/requestApproval' &&
-            selected === 'allow_always') {
-            const scopeKey = buildCommandApprovalScopeKey({
-                command: asString(params.request.params.command),
-                cwd: asString(params.request.params.cwd) ?? params.session.cwd,
-            });
-            if (scopeKey) {
-                params.session.commandApprovalScopes.add(scopeKey);
-            }
-            else {
-                this.reportShapeDrift('allow_always_without_scope_key', {
-                    itemId: params.request.params.itemId,
-                    command: params.request.params.command,
-                });
-            }
-        }
-        const allow = this.isAllowedPermissionSelection(selected);
-        this.codex.respondSuccess(params.request.id, {
-            decision: allow ? 'accept' : 'decline',
-        });
-        await this.emitSessionUpdate(params.session.sessionId, {
-            sessionUpdate: 'tool_call_update',
-            toolCallId: params.toolCallId,
-            status: allow ? 'in_progress' : 'failed',
-            rawOutput: { decision: allow ? 'accept' : 'decline' },
+        await handleCodexServerPermissionRequest({
+            request,
+            sessionIdByThreadId: this.sessionIdByThreadId,
+            sessions: this.sessions,
+            connection: this.connection,
+            codex: this.codex,
+            emitSessionUpdate: (sessionId, update) => this.emitSessionUpdate(sessionId, update),
+            reportShapeDrift: (event, details) => this.reportShapeDrift(event, details),
         });
     }
     settleTurn(session, stopReason) {
@@ -2504,11 +923,7 @@ export class CodexAppServerAcpAdapter {
         session.pendingTurnCompletionsByTurnId.clear();
     }
     reportShapeDrift(event, details) {
-        const count = (this.shapeDriftCounts.get(event) ?? 0) + 1;
-        this.shapeDriftCounts.set(event, count);
-        const includeDetails = details !== undefined && (count <= 5 || count % 50 === 0);
-        const detailsSuffix = includeDetails ? ` details=${toShapeDriftDetails(details)}` : '';
-        process.stderr.write(`[codex-app-server-acp] shape-drift event=${event} count=${count}${detailsSuffix}\n`);
+        this.shapeDriftReporter.report(event, details);
     }
     async emitSessionUpdate(sessionId, update) {
         try {
@@ -2518,10 +933,10 @@ export class CodexAppServerAcpAdapter {
         }
     }
 }
-export function runCodexAppServerAcpAdapter() {
+export function runCodexAppServerAcpAdapter(options) {
     const output = Writable.toWeb(process.stdout);
     const input = Readable.toWeb(process.stdin);
     const stream = ndJsonStream(output, input);
-    new AgentSideConnection((connection) => new CodexAppServerAcpAdapter(connection), stream);
+    new AgentSideConnection((connection) => new CodexAppServerAcpAdapter(connection, undefined, options), stream);
 }
 //# sourceMappingURL=codex-app-server-acp-adapter.js.map