ycodium-acp-executor 0.2.3080 → 0.2.3088

package/dist/executor.js

@@ -2,25 +2,24 @@
 // @effect-diagnostics globalDate:off
 // @effect-diagnostics globalTimers:off
 import * as NodeCrypto from "node:crypto";
-import { CLIENT_METHODS, RequestError, createAcpConnection, } from "./protocol.js";
-import { acpApprovalOptions, acpPromptSettlementBelongsToContext, isAcpRequestPermissionParams, selectAcpPermissionOptionId, selectAutoApprovedAcpPermissionOption, } from "./adapter-support.js";
-import { approvalOutcomeForDecision, createApprovalGate, } from "./approvals.js";
-import { makeArtifactEmitter, resourceLinkArtifacts } from "./artifacts.js";
+import { createApprovalGate } from "./approvals.js";
+import { AcpExecutorError } from "./errors.js";
 import { UnboundedEventStream } from "./event-stream.js";
-import { AcpExecutorCancelTimeoutError, AcpExecutorDisposedError, AcpExecutorError, AcpExecutorNotStartedError, AcpExecutorRequestError, withStartupStderr, } from "./errors.js";
-import { fileChangesFromAcpPermission, makeAcpAssistantItemEvent, makeAcpContentDeltaEvent, makeAcpPlanUpdatedEvent, makeAcpRequestOpenedEvent, makeAcpRequestResolvedEvent, makeAcpToolCallEvent, retainToolCallUpdate, } from "./events.js";
-import { readOpenToolCalls } from "./openCommands.js";
-import { applyRequestedEffort } from "./apply-effort.js";
-import { acpPromptFailureCategory, acpTransportIfEstablished, failureCategoryField, withFailureCategory, } from "./failureCategory.js";
-import { acpModeConfigId } from "./runtime-mode.js";
-import { acpInitializePayload } from "./handshake.js";
-import { unhandledConfigCategories } from "./config-option-wiring.js";
+import {} from "./events.js";
+import { createExecutorLifecycle } from "./executor/lifecycle.js";
+import { createExecutorPrompt } from "./executor/prompt.js";
+import { createExecutorRequests } from "./executor/requests.js";
+import { createExecutorRuntime } from "./executor/runtime.js";
+import { createExecutorSession } from "./executor/session.js";
+import { createExecutorSettlement } from "./executor/settlement.js";
+import { createExecutorUpdates } from "./executor/updates.js";
+import { acpTransportIfEstablished } from "./failureCategory.js";
 import { Mutex } from "./mutex.js";
-import { modelSelectionStateFromSetup, normalizeModelId, } from "./model-selection.js";
-import { extractModelConfigId, filterMcpServersByAgentCapabilities, matchAdvertisedModelValue, parseAvailableCommandsUpdate, parsePermissionRequest, parseSessionModeState, parseSessionUpdateEvent, } from "./runtime-model.js";
-import { isRecord, selectPromptTurnId } from "./util.js";
-import { userInputAnswerOptionId } from "./user-input-pending.js";
-import { defaultVendorHooks, } from "./vendor-hooks.js";
+import { readOpenToolCalls } from "./openCommands.js";
+import { CLIENT_METHODS, RequestError, createAcpConnection, } from "./protocol.js";
+import {} from "./runtime-model.js";
+import {} from "./user-input-pending.js";
+import { defaultVendorHooks } from "./vendor-hooks.js";
 const DEFAULT_CANCEL_GRACE_MS = 5_000;
 function defaultNowIso() {
     return new Date().toISOString();
@@ -36,561 +35,81 @@ export function createAcpExecutor(options) {
     const eventStream = new UnboundedEventStream();
     const threadMutex = new Mutex();
     const promptMutex = new Mutex();
-    let generation = 0;
-    let disposed = false;
-    let status = "idle";
-    let sessionId;
-    let modelSelectionState = {
-        strategy: "session/set_model",
-        sessionModelsAdvertised: false,
-        modelConfigId: undefined,
-        currentModelId: undefined,
-        advertisedModelValues: [],
+    const shared = {
+        generation: 0,
+        disposed: false,
+        status: "idle",
+        sessionId: undefined,
+        modelSelectionState: {
+            strategy: "session/set_model",
+            sessionModelsAdvertised: false,
+            modelConfigId: undefined,
+            currentModelId: undefined,
+            advertisedModelValues: [],
+        },
+        lastUnmatchedModelId: undefined,
+        initializeResult: undefined,
+        startResult: undefined,
+        startInFlight: undefined,
+        activeTurnId: undefined,
+        promptsInFlight: 0,
+        pendingSettlement: undefined,
+        manualCompaction: undefined,
+        assistantSegment: { nextSegmentIndex: 0 },
+        modeState: undefined,
+        availableCommands: [],
+        promptWaiters: [],
+        abortLocalPrompt: undefined,
+        connectionClosed: false,
+        sessionLoadInFlight: false,
+        droppedReplayUpdates: 0,
     };
-    /** 上一个对不上目录的请求型号：同一个 id 每轮都来，日志只记一次。 */
-    let lastUnmatchedModelId;
-    let initializeResult;
-    let startResult;
-    let startInFlight;
-    let activeTurnId;
-    let promptsInFlight = 0;
     const interruptedTurnIds = new Set();
     const approvals = createApprovalGate({
         singleResolver: false,
     });
     // 结构化用户输入（厂商钩子把 permission 认成提问/计划时）的挂起表，与 approvals 同理：答复 / 取消 / 断连三者竞争只完成一次。
     const pendingUserInputs = new Map();
-    /** 这一轮挂着的「提前收口」等待。同一时刻至多一条：prompt 之间有 promptMutex。 */
-    let pendingSettlement;
-    /**
-     * 已经结算过的 promptKey。通知与 RPC 应答都可能带同一个 key 再来一次，
-     * 不记住就会把下一轮的等待错误地收掉。有界：只留最近这些。
-     */
-    const settledPromptKeys = [];
-    const SETTLED_PROMPT_KEY_LIMIT = 32;
-    const rememberSettledPromptKey = (key) => {
-        if (settledPromptKeys.includes(key))
-            return;
-        settledPromptKeys.push(key);
-        if (settledPromptKeys.length > SETTLED_PROMPT_KEY_LIMIT)
-            settledPromptKeys.shift();
-    };
     const toolCalls = new Map();
     /** agent 自己的 compactionId → 累积状态。有界：一次会话压缩不了几回，结束的随手清掉。 */
     const compactions = new Map();
-    /** 我们自己发命令触发的那一次；期间 agent 自报的第一条压缩并进它。 */
-    let manualCompaction;
-    const COMPACTION_SUMMARY_MAX_CHARS = 8_000;
     const nowMs = () => options.nowMs?.() ?? Date.now();
-    const emitCompactionState = (record, state) => {
-        const summary = record.summary?.trim() ?? "";
-        const truncated = summary.length > COMPACTION_SUMMARY_MAX_CHARS;
-        emit({
-            type: "thread.state.changed",
-            ...stamp(),
-            provider: options.provider,
-            threadId: options.threadId,
-            ...(activeTurnId !== undefined ? { turnId: activeTurnId } : {}),
-            payload: {
-                state,
-                compaction: {
-                    compactionId: record.snapshotId,
-                    trigger: record.trigger,
-                    ...(state === "compacted"
-                        ? { durationMs: Math.max(0, nowMs() - record.startedAtMs) }
-                        : {}),
-                    ...(summary.length > 0
-                        ? {
-                            summary: truncated ? summary.slice(0, COMPACTION_SUMMARY_MAX_CHARS) : summary,
-                            ...(truncated ? { summaryTruncated: true } : {}),
-                        }
-                        : {}),
-                },
-            },
-        });
-    };
-    const applyCompactionUpdate = (event) => {
-        let record = compactions.get(event.compactionId);
-        if (record === undefined) {
-            // 手动压缩进行中：agent 自报的第一条就是它，沿用我们的 id，投影才折成同一行。
-            if (manualCompaction !== undefined && !manualCompaction.adopted) {
-                manualCompaction.adopted = true;
-                record = manualCompaction;
-            }
-            else {
-                record = {
-                    snapshotId: randomId(),
-                    trigger: "automatic",
-                    startedAtMs: nowMs(),
-                    summary: undefined,
-                    announced: false,
-                    finished: false,
-                    adopted: false,
-                };
-            }
-            compactions.set(event.compactionId, record);
-        }
-        if (event.summary !== undefined)
-            record.summary = event.summary ?? undefined;
-        switch (event.status) {
-            case "in_progress":
-                if (!record.announced) {
-                    record.announced = true;
-                    emitCompactionState(record, "compacting");
-                }
-                return;
-            case "completed":
-                record.announced = true;
-                record.finished = true;
-                compactions.delete(event.compactionId);
-                emitCompactionState(record, "compacted");
-                return;
-            case "failed":
-            case "cancelled":
-                record.finished = true;
-                compactions.delete(event.compactionId);
-                emit({
-                    type: "runtime.warning",
-                    ...stamp(),
-                    provider: options.provider,
-                    threadId: options.threadId,
-                    ...(activeTurnId !== undefined ? { turnId: activeTurnId } : {}),
-                    payload: {
-                        message: event.error ?? `Context compaction ${event.status}`,
-                        detail: { code: `context-compaction-${event.status}` },
-                    },
-                });
-                return;
-            default:
-                return;
-        }
-    };
-    /** 已经发过工具事件的调用 id，有界。晚到的更新靠它认出「不是新调用」。 */
-    const shownToolCallIds = new Set();
-    const SHOWN_TOOL_CALL_LIMIT = 256;
-    const rememberShownToolCall = (toolCallId) => {
-        shownToolCallIds.add(toolCallId);
-        if (shownToolCallIds.size <= SHOWN_TOOL_CALL_LIMIT)
-            return;
-        // 先淘汰最老的、已经收尾的；还在跑的调用（长命的后台命令）留着，否则它下一次更新会被当成新调用，把当时正在写的回答劈开。
-        for (const id of shownToolCallIds) {
-            if (toolCalls.has(id))
-                continue;
-            shownToolCallIds.delete(id);
-            return;
-        }
-    };
-    let assistantSegment = { nextSegmentIndex: 0 };
-    let modeState;
-    let availableCommands = [];
     const assistantItemRuntimeId = randomId();
-    let promptWaiters = [];
-    let abortLocalPrompt;
-    let connectionClosed = false;
-    /**
-     * `session/load` 发出到应答到达之间为真。ACP 规定 agent 在应答之前把整段历史按
-     * `session/update` 重放一遍（用户消息、回复、思考、工具调用、计划）；这些是已经发生过的
-     * 旧内容，当成本轮输出投影出去，每续一次会话就把之前的回复在新一轮开头再吐一遍。
-     * 只丢内容类更新，命令清单、模式这类状态照常处理。
-     */
-    let sessionLoadInFlight = false;
-    let droppedReplayUpdates = 0;
-    const stamp = () => ({
-        eventId: randomId(),
-        createdAt: nowIso(),
+    const { stamp, isLive, emit, emitArtifacts, failIfDisposed, closeActiveAssistantSegment, ensureActiveAssistantSegment, notifyPromptSettled, waitForPromptIdle, } = createExecutorRuntime({
+        randomId,
+        nowIso,
+        eventStream,
+        options,
+        assistantItemRuntimeId,
+        promptMutex,
+        shared,
     });
-    // 迟到的结果先验身份：dispose 之后、或已经换代的那次 start/prompt 完成时，
-    // 不许回写状态。`Promise.race` 输掉的那一方还在跑，这是唯一的拦截点。
-    const isLive = (expectedGeneration) => !disposed && generation === expectedGeneration;
-    const publish = (event) => {
-        if (disposed) {
-            return;
-        }
-        eventStream.publish(options.originBindingGeneration === undefined
-            ? event
-            : { ...event, originBindingGeneration: options.originBindingGeneration });
-    };
-    const emit = publish;
-    const emitArtifacts = makeArtifactEmitter({ emit, stamp, options, turnId: () => activeTurnId });
-    const failIfDisposed = () => {
-        if (disposed) {
-            throw new AcpExecutorDisposedError();
-        }
-    };
-    const closeActiveAssistantSegment = (turnId) => {
-        if (!assistantSegment.activeItemId) {
-            return;
-        }
-        const itemId = assistantSegment.activeItemId;
-        assistantSegment = { nextSegmentIndex: assistantSegment.nextSegmentIndex };
-        emit(makeAcpAssistantItemEvent({
-            stamp: stamp(),
-            provider: options.provider,
-            threadId: options.threadId,
-            turnId,
-            itemId,
-            lifecycle: "item.completed",
-        }));
-    };
-    const ensureActiveAssistantSegment = (acpSessionId, turnId) => {
-        if (assistantSegment.activeItemId) {
-            return assistantSegment.activeItemId;
-        }
-        const itemId = `assistant:${acpSessionId}:runtime:${assistantItemRuntimeId}:segment:${assistantSegment.nextSegmentIndex}`;
-        assistantSegment = {
-            nextSegmentIndex: assistantSegment.nextSegmentIndex + 1,
-            activeItemId: itemId,
-        };
-        emit(makeAcpAssistantItemEvent({
-            stamp: stamp(),
-            provider: options.provider,
-            threadId: options.threadId,
-            turnId,
-            itemId,
-            lifecycle: "item.started",
-        }));
-        return itemId;
-    };
-    const handleSessionUpdate = (params) => {
-        const parsed = parseSessionUpdateEvent(params);
-        if (parsed.modeId && modeState) {
-            modeState = {
-                ...modeState,
-                currentModeId: parsed.modeId,
-            };
-        }
-        const commands = parseAvailableCommandsUpdate(params);
-        if (commands !== undefined) {
-            availableCommands = commands;
-            options.onAvailableCommands?.(commands);
-        }
-        if (sessionLoadInFlight) {
-            droppedReplayUpdates += parsed.events.filter((event) => event._tag !== "ModeChanged").length;
-            return;
-        }
-        for (const event of parsed.events) {
-            if (event._tag === "ToolCallUpdated") {
-                const { nextToolCall, decision } = retainToolCallUpdate(toolCalls, event.toolCall, {
-                    turnId: activeTurnId,
-                    rawTitle: params.update.title,
-                    nowMs,
-                });
-                // 后台任务（监视器、后台 shell）的生命周期只在工具结果里：不论这次更新发不发工具事件，都要过一遍，轮询通知常常只带 rawOutput。
-                const hookResult = hooks.onToolCallUpdated?.({
-                    toolCallId: nextToolCall.toolCallId,
-                    status: nextToolCall.status,
-                    title: nextToolCall.title,
-                    kind: nextToolCall.kind,
-                    rawInput: nextToolCall.data["rawInput"],
-                    rawOutput: nextToolCall.data["rawOutput"],
-                    meta: params.update._meta,
-                    turnId: activeTurnId,
-                });
-                const taskEvents = hookResult === undefined ? [] : "events" in hookResult ? hookResult.events : hookResult;
-                const handledByHook = hookResult !== undefined && "events" in hookResult && hookResult.handled === true;
-                for (const taskEvent of taskEvents) {
-                    emit({
-                        type: taskEvent.type,
-                        ...stamp(),
-                        provider: options.provider,
-                        threadId: options.threadId,
-                        ...(taskEvent.turnId !== undefined ? { turnId: taskEvent.turnId } : {}),
-                        payload: taskEvent.payload,
-                    });
-                }
-                if (nextToolCall.status === "completed" && hookResult && "artifacts" in hookResult)
-                    emitArtifacts(hookResult.artifacts ?? [], nextToolCall.toolCallId);
-                if (handledByHook || !decision.emit) {
-                    continue;
-                }
-                // 新工具调用是回答里的分界；已经露过面的调用再报进度（比如后台命令跑完）不是，不能把一段回答从中间劈开。
-                if (!shownToolCallIds.has(nextToolCall.toolCallId)) {
-                    rememberShownToolCall(nextToolCall.toolCallId);
-                    closeActiveAssistantSegment(activeTurnId);
-                }
-                emit(makeAcpToolCallEvent({
-                    stamp: stamp(),
-                    provider: options.provider,
-                    threadId: options.threadId,
-                    turnId: activeTurnId,
-                    toolCall: nextToolCall,
-                    rawPayload: event.rawPayload,
-                }));
-                continue;
-            }
-            if (event._tag === "AssistantContentBlock") {
-                emitArtifacts(resourceLinkArtifacts(event.content));
-                continue;
-            }
-            if (event._tag === "CompactionUpdated") {
-                applyCompactionUpdate(event);
-                continue;
-            }
-            if (event._tag === "CompactionSummaryChunk") {
-                const record = compactions.get(event.compactionId);
-                if (record !== undefined && !record.finished) {
-                    record.summary = (record.summary ?? "") + event.text;
-                }
-                continue;
-            }
-            if (event._tag === "ContentDelta") {
-                // 手动压缩那条命令吐的文本不是回答，不进时间线（压缩结果走生命周期事件）。
-                if (manualCompaction !== undefined) {
-                    continue;
-                }
-                if (event.streamKind === "reasoning_text") {
-                    // 思考不得开 assistant 段：item.started 会把思考段收口，字会进正式回答。
-                    if (event.text.trim().length === 0) {
-                        continue;
-                    }
-                    emit(makeAcpContentDeltaEvent({
-                        stamp: stamp(),
-                        provider: options.provider,
-                        threadId: options.threadId,
-                        turnId: activeTurnId,
-                        text: event.text,
-                        streamKind: "reasoning_text",
-                        rawPayload: event.rawPayload,
-                    }));
-                    continue;
-                }
-                if (event.text.trim().length === 0 && !assistantSegment.activeItemId) {
-                    continue;
-                }
-                const itemId = sessionId
-                    ? ensureActiveAssistantSegment(sessionId, activeTurnId)
-                    : undefined;
-                emit(makeAcpContentDeltaEvent({
-                    stamp: stamp(),
-                    provider: options.provider,
-                    threadId: options.threadId,
-                    turnId: activeTurnId,
-                    ...(itemId ? { itemId } : {}),
-                    text: event.text,
-                    streamKind: "assistant_text",
-                    rawPayload: event.rawPayload,
-                }));
-                continue;
-            }
-            if (event._tag === "PlanUpdated") {
-                emit(makeAcpPlanUpdatedEvent({
-                    stamp: stamp(),
-                    provider: options.provider,
-                    threadId: options.threadId,
-                    turnId: activeTurnId,
-                    payload: event.payload,
-                    source: "acp.jsonrpc",
-                    method: "session/update",
-                    rawPayload: event.rawPayload,
-                }));
-            }
-        }
-    };
-    const emitResolved = (pending, decision, reason) => {
-        emit(makeAcpRequestResolvedEvent({
-            stamp: stamp(),
-            provider: options.provider,
-            threadId: options.threadId,
-            turnId: pending.turnId,
-            requestId: pending.requestId,
-            permissionRequest: pending.permissionRequest,
-            decision,
-            ...(reason !== undefined ? { reason } : {}),
-        }));
-    };
-    const settleApproval = (pending, outcome, decision, reason) => {
-        if (!approvals.settle(pending, outcome)) {
-            return false;
-        }
-        emitResolved(pending, decision, reason);
-        return true;
-    };
-    const settleAllApprovals = (decision) => {
-        for (const entry of approvals.settleAll({ outcome: "cancelled" })) {
-            emitResolved(entry, decision);
-        }
-    };
-    const emitUserInputResolved = (pending, answers) => {
-        emit({
-            type: "user-input.resolved",
-            ...stamp(),
-            provider: options.provider,
-            threadId: options.threadId,
-            ...(pending.turnId !== undefined ? { turnId: pending.turnId } : {}),
-            requestId: pending.requestId,
-            payload: { answers },
-        });
-    };
-    /** 挂着的提前收口等待。四个清理点（流断 / 连接关 / 取消 / dispose）都要过它。 */
-    const abortPendingSettlement = (reason, failureCategory) => {
-        const waiting = pendingSettlement;
-        if (waiting === undefined)
-            return;
-        pendingSettlement = undefined;
-        waiting.settle({
-            error: withFailureCategory(new AcpExecutorRequestError("session/prompt", reason), failureCategory),
-        });
-    };
-    const settleAllUserInputs = () => {
-        for (const pending of pendingUserInputs.values()) {
-            if (pending.settled)
-                continue;
-            pending.settled = true;
-            pending.resolve({ kind: "cancelled" });
-        }
-        pendingUserInputs.clear();
-    };
-    /**
-     * 一条通知能不能收掉这一轮。返回 true 表示它是收口信号，已消费。
-     *
-     * 四条语义都在这里，不外放给钩子——外放的话每家会各写一遍，而其中第三条有事故记录：
-     * 1. 带 key 按 key 配，不带 key 按 sessionId 配当前这一轮（Grok 的 promptId 是可选的）
-     * 2. 已结算过的 key 丢弃，防迟到的重复通知收掉下一轮
-     * 3. `error` 走失败通道，**绝不能归成正常结束**——Grok 额度耗尽正是发它，
-     *    归成成功的话用户看到一条空白回复（`cba38ce0d`）
-     * 4. 赢了之后输掉的那条 RPC 不会有人再等，交给 dispose/close 时的 rejectPending 收
-     */
-    const settleFromNotification = (method, params) => {
-        const hook = hooks.promptSettlement;
-        if (hook === undefined || pendingSettlement === undefined)
-            return false;
-        const signal = hook.fromNotification(method, params);
-        if (signal === undefined)
-            return false;
-        const waiting = pendingSettlement;
-        if (signal.sessionId !== waiting.sessionId)
-            return false;
-        if (signal.promptKey !== undefined && signal.promptKey !== waiting.promptKey) {
-            // 不是这一轮的：可能是上一轮迟到的重复通知，消费掉但不结算。
-            return settledPromptKeys.includes(signal.promptKey);
-        }
-        pendingSettlement = undefined;
-        rememberSettledPromptKey(waiting.promptKey);
-        if (signal.outcome === "error") {
-            waiting.settle({
-                error: withFailureCategory(new AcpExecutorRequestError("session/prompt", signal.detail ?? "prompt failed without an error detail"), signal.failureCategory),
-            });
-        }
-        else {
-            waiting.settle({
-                response: { stopReason: signal.stopReason ?? "end_turn" },
-            });
-        }
-        return true;
-    };
-    /**
-     * 把一组问题交给用户，等回答。权限那条（Kimi 借 permission 传提问）与厂商扩展那条
-     * （Grok 的 `_x.ai/ask_user_question`）共用这一份等待表——两边各自登记会让
-     * `settleAllUserInputs` 漏掉一半，CLI 崩溃时那一半永远不 settle。
-     */
-    const askUserInput = async (input) => {
-        // dispose 之后迟到的请求不得再登记：清理已经跑完，塞进去就再也 settle 不了。
-        failIfDisposed();
-        const requestId = randomId();
-        const { promise: settlement, resolve: settle } = Promise.withResolvers();
-        const pending = {
-            requestId,
-            questions: input.questions,
-            turnId: activeTurnId,
-            settled: false,
-            resolve: settle,
-        };
-        pendingUserInputs.set(requestId, pending);
-        emit({
-            type: "user-input.requested",
-            ...stamp(),
-            provider: options.provider,
-            threadId: options.threadId,
-            ...(activeTurnId !== undefined ? { turnId: activeTurnId } : {}),
-            requestId,
-            payload: { questions: input.questions },
-            raw: {
-                source: "acp.jsonrpc",
-                method: input.method,
-                payload: input.payload,
-            },
-        });
-        const resolution = await settlement;
-        pendingUserInputs.delete(requestId);
-        emitUserInputResolved(pending, resolution.kind === "answered" ? resolution.answers : {});
-        return resolution;
-    };
-    /** 每次扩展请求现造一份，把真实方法名与原始载荷带进 `raw`，排障时看得出是谁问的。 */
-    const makeExtensionContext = (method, params) => ({
-        askUserInput: (questions) => askUserInput({ questions, method, payload: params }),
+    const { emitCompactionState, handleSessionUpdate } = createExecutorUpdates({
+        emit,
+        stamp,
+        options,
+        nowMs,
+        compactions,
+        randomId,
+        toolCalls,
+        hooks,
+        emitArtifacts,
+        closeActiveAssistantSegment,
+        ensureActiveAssistantSegment,
+        shared,
     });
-    /** 厂商钩子认出的提问/计划走 `user-input.*`，返回 undefined 表示没接管。 */
-    const handlePermissionAsUserInput = async (params) => {
-        if (hooks.permissionUserInput === undefined)
-            return undefined;
-        let question;
-        try {
-            question = hooks.permissionUserInput(params);
-        }
-        catch (error) {
-            // 认出来却形状不全的交互绝不能降格成批准/拒绝两档——回协议错误。
-            throw RequestError.invalidParams({
-                detail: error instanceof Error ? error.message : String(error),
-            });
-        }
-        if (question === undefined)
-            return undefined;
-        const resolution = await askUserInput({
-            questions: [question],
-            method: CLIENT_METHODS.session_request_permission,
-            payload: params,
-        });
-        const optionId = resolution.kind === "answered"
-            ? userInputAnswerOptionId(question, resolution.answers)
-            : undefined;
-        return {
-            outcome: optionId !== undefined ? { outcome: "selected", optionId } : { outcome: "cancelled" },
-        };
-    };
-    const handlePermissionRequest = async (params) => {
-        if (!isAcpRequestPermissionParams(params)) {
-            throw RequestError.invalidParams({ detail: "Malformed session/request_permission" });
-        }
-        const userInputOutcome = await handlePermissionAsUserInput(params);
-        if (userInputOutcome !== undefined)
-            return userInputOutcome;
-        const permissionRequest = parsePermissionRequest(params);
-        if (options.autoApprove?.(permissionRequest) === true) {
-            // 选项表认不出唯一的「允许」项就照常弹给用户，不替它猜。
-            const optionId = selectAutoApprovedAcpPermissionOption(params);
-            if (optionId !== undefined) {
-                return { outcome: { outcome: "selected", optionId } };
-            }
-        }
-        const requestId = randomId();
-        const outcome = await new Promise((resolve) => {
-            const pending = {
-                requestId,
-                request: params,
-                permissionRequest,
-                turnId: activeTurnId,
-                settled: false,
-                resolve,
-            };
-            approvals.add(pending);
-            emit(makeAcpRequestOpenedEvent({
-                stamp: stamp(),
-                provider: options.provider,
-                threadId: options.threadId,
-                turnId: activeTurnId,
-                requestId,
-                permissionRequest,
-                detail: permissionRequest.detail ?? "Approve this tool call?",
-                args: permissionRequest.toolCall?.data["rawInput"] ?? params.toolCall.rawInput,
-                options: acpApprovalOptions(params),
-                fileChanges: fileChangesFromAcpPermission(permissionRequest),
-                source: "acp.jsonrpc",
-                method: "session/request_permission",
-                rawPayload: params,
-            }));
-        });
-        return { outcome };
-    };
+    const { settleAllApprovals, settleAllUserInputs, makeExtensionContext, handlePermissionRequest, respondToRequest, respondToUserInput, } = createExecutorRequests({
+        emit,
+        stamp,
+        options,
+        approvals,
+        pendingUserInputs,
+        failIfDisposed,
+        randomId,
+        hooks,
+        shared,
+    });
+    const { rememberSettledPromptKey, abortPendingSettlement, settleFromNotification } = createExecutorSettlement({ hooks, shared });
     const connection = createAcpConnection({
         readable: options.readable,
         writable: options.writable,
@@ -603,7 +122,7 @@ export function createAcpExecutor(options) {
         // 窗口在应答帧到达的那一刻同步收掉：应答之后的通知是真输出，不能再丢。
         onResponse: (method) => {
             if (method === "session/load")
-                sessionLoadInFlight = false;
+                shared.sessionLoadInFlight = false;
         },
         onNotification: (notification) => {
             if (notification.method === "session/update") {
@@ -634,22 +153,22 @@ export function createAcpExecutor(options) {
         },
     });
     void connection.closed.then(() => {
-        connectionClosed = true;
-        if (disposed) {
+        shared.connectionClosed = true;
+        if (shared.disposed) {
             return;
         }
         settleAllApprovals("cancel");
         settleAllUserInputs();
-        abortPendingSettlement("connection closed", acpTransportIfEstablished(startResult !== undefined, disposed));
-        promptWaiters.splice(0).forEach((wake) => wake());
+        abortPendingSettlement("connection closed", acpTransportIfEstablished(shared.startResult !== undefined, shared.disposed));
+        shared.promptWaiters.splice(0).forEach((wake) => wake());
     }, () => {
-        connectionClosed = true;
+        shared.connectionClosed = true;
     });
     // 入流一死就当场结算挂着的审批/用户输入/轮次等待，不能等 connection.closed：
     // 协议的 shutdown 排在入站队列后面，而队列正卡在等这些 handler settle——
     // 等 closed 才动手就是死锁。这里先结算，队列疏通后剩余缓冲帧照常投递。
     const onInputDead = () => {
-        if (disposed) {
+        if (shared.disposed) {
             return;
         }
         settleAllApprovals("cancel");
@@ -657,698 +176,76 @@ export function createAcpExecutor(options) {
         // 提前收口的等待不在这里中止：清掉审批 / 用户输入之后入站队列就通了，协议层的
         // shutdown 随即 reject 那条 prompt RPC，竞速的另一边自己会赢（实测两版都 reject，
         // 只是理由从 "input stream ended" 变成流上的那个 error）。
-        promptWaiters.splice(0).forEach((wake) => wake());
+        shared.promptWaiters.splice(0).forEach((wake) => wake());
     };
     options.readable.once("end", onInputDead);
     options.readable.once("error", onInputDead);
-    const applyRequestedModel = async (input) => {
-        const requestedModelId = normalizeModelId(input.requestedModelId);
-        if (requestedModelId === undefined ||
-            requestedModelId === input.state.currentModelId ||
-            (input.state.strategy === "session/set_model" && !input.state.sessionModelsAdvertised) ||
-            (input.state.strategy === "config-option" && input.state.modelConfigId === undefined)) {
-            return input.state;
-        }
-        const value = matchAdvertisedModelValue(requestedModelId, input.state.advertisedModelValues);
-        if (value === undefined) {
-            // 对不上就保留手自己的型号，只记一次日志（带上手的目录）；没有别处替它改写上游请求。
-            if (requestedModelId !== lastUnmatchedModelId) {
-                lastUnmatchedModelId = requestedModelId;
-                options.log?.info("requested model is not in the agent catalog; keeping its own model", {
-                    requestedModelId,
-                    currentModelId: input.state.currentModelId,
-                    advertisedModelValues: input.state.advertisedModelValues,
-                });
-            }
-            return input.state;
-        }
-        if (value === input.state.currentModelId) {
-            return input.state;
-        }
-        let configOptions = input.state.configOptions;
-        if (input.state.strategy === "config-option") {
-            const switched = await connection.request("session/set_config_option", { sessionId: input.acpSessionId, configId: input.state.modelConfigId, value });
-            configOptions = switched?.configOptions ?? configOptions;
-        }
-        else {
-            await connection.request("session/set_model", {
-                sessionId: input.acpSessionId,
-                modelId: value,
-            });
-        }
-        if (!isLive(input.expectedGeneration)) {
-            throw new AcpExecutorDisposedError();
-        }
-        return { ...input.state, currentModelId: value, configOptions };
-    };
-    const startOnce = async (expectedGeneration) => {
-        // 载荷与探测路径共用一份（`handshake.ts`）：agent 按客户端能力决定播报什么，两边各写一份就会问出两个不同的问题。
-        const initializePayload = acpInitializePayload(options.clientInfo, options.clientCapabilities);
-        const initialized = await connection.request("initialize", initializePayload);
-        if (!isLive(expectedGeneration)) {
-            throw new AcpExecutorDisposedError();
-        }
-        initializeResult = initialized;
-        const authMethodId = typeof options.authMethodId === "function"
-            ? options.authMethodId(initialized)
-            : options.authMethodId;
-        if (authMethodId !== undefined) {
-            await connection.request("authenticate", { methodId: authMethodId });
-            if (!isLive(expectedGeneration)) {
-                throw new AcpExecutorDisposedError();
-            }
-        }
-        const mcpServers = filterMcpServersByAgentCapabilities(options.mcpServers ?? [], initialized.agentCapabilities);
-        const additionalDirectories = options.additionalDirectories !== undefined && options.additionalDirectories.length > 0
-            ? { additionalDirectories: options.additionalDirectories }
-            : {};
-        let setup;
-        let nextSessionId;
-        if (options.resumeSessionId && options.resumeMethod === "session/resume") {
-            setup = await connection.request("session/resume", {
-                sessionId: options.resumeSessionId,
-                cwd: options.cwd,
-                mcpServers,
-                ...additionalDirectories,
-            });
-            nextSessionId = options.resumeSessionId;
-        }
-        else if (options.resumeSessionId) {
-            sessionLoadInFlight = true;
-            try {
-                setup = await connection.request("session/load", {
-                    sessionId: options.resumeSessionId,
-                    cwd: options.cwd,
-                    mcpServers,
-                    ...additionalDirectories,
-                });
-            }
-            finally {
-                sessionLoadInFlight = false;
-            }
-            options.log?.info("acp session loaded; replayed history was not projected", {
-                sessionId: options.resumeSessionId,
-                droppedReplayUpdates,
-            });
-            nextSessionId = options.resumeSessionId;
-        }
-        else {
-            const created = await connection.request("session/new", {
-                cwd: options.cwd,
-                mcpServers,
-                ...additionalDirectories,
-            });
-            nextSessionId = created.sessionId;
-            setup = created;
-        }
-        // 报了一类从没登记过的选项，说一声。在此之前只挑 `model` 与力度档，其余整个丢掉、
-        // 零痕迹——界面上少一格，日志里一个字都没有（2026-09-19 力度档就是这么漏的）。
-        const unhandledCategories = unhandledConfigCategories(setup.configOptions);
-        if (unhandledCategories.length > 0) {
-            options.log?.info("acp session reported config option categories we do not handle", {
-                sessionId: nextSessionId,
-                categories: unhandledCategories,
-            });
-        }
-        const nextModelSelectionState = await applyRequestedModel({
-            state: modelSelectionStateFromSetup(setup),
-            acpSessionId: nextSessionId,
-            requestedModelId: options.requestedModelId,
-            expectedGeneration,
-        });
-        // 切过型号就按切型号回包里的那份认档（见 `AcpModelSelectionState.configOptions`）。
-        await applyRequestedEffort({
-            connection,
-            log: options.log,
-            isLive,
-            configOptions: nextModelSelectionState.configOptions,
-            acpSessionId: nextSessionId,
-            requestedEffort: options.requestedEffort,
-            expectedGeneration,
-        });
-        if (options.beforeApplyResult) {
-            await options.beforeApplyResult();
-        }
-        if (!isLive(expectedGeneration)) {
-            throw new AcpExecutorDisposedError();
-        }
-        sessionId = nextSessionId;
-        modelSelectionState = nextModelSelectionState;
-        modeState = parseSessionModeState(setup);
-        const result = {
-            sessionId: nextSessionId,
-            generation: expectedGeneration,
-            initializeResult: initialized,
-            sessionSetupResult: setup,
-            modelConfigId: extractModelConfigId(setup),
-            modelId: nextModelSelectionState.currentModelId,
-        };
-        startResult = result;
-        status = "ready";
-        emit({
-            type: "session.started",
-            ...stamp(),
-            provider: options.provider,
-            ...(options.providerInstanceId ? { providerInstanceId: options.providerInstanceId } : {}),
-            threadId: options.threadId,
-            payload: {
-                sessionId: nextSessionId,
-                cwd: options.cwd,
-            },
-        });
-        return result;
-    };
-    const start = async () => {
-        failIfDisposed();
-        if (startResult) {
-            return startResult;
-        }
-        if (startInFlight) {
-            return startInFlight;
-        }
-        generation += 1;
-        const expectedGeneration = generation;
-        status = "starting";
-        startInFlight = startOnce(expectedGeneration).then((result) => {
-            startInFlight = undefined;
-            return result;
-        }, async (error) => {
-            startInFlight = undefined;
-            if (isLive(expectedGeneration) && !startResult) {
-                status = "idle";
-                generation = expectedGeneration;
-            }
-            throw await withStartupStderr(error, options.stderrTail);
-        });
-        return startInFlight;
-    };
-    const requireStarted = () => {
-        failIfDisposed();
-        if (!sessionId || !startResult) {
-            throw new AcpExecutorNotStartedError();
-        }
-        return { sessionId, generation: startResult.generation };
-    };
-    const notifyPromptSettled = () => {
-        const waiters = promptWaiters.splice(0);
-        for (const waiter of waiters) {
-            waiter();
-        }
-    };
-    const waitForPromptIdle = async (timeoutMs) => {
-        if (!promptMutex.isLocked) {
-            return true;
-        }
-        return await new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                promptWaiters = promptWaiters.filter((waiter) => waiter !== onSettle);
-                resolve(false);
-            }, timeoutMs);
-            const onSettle = () => {
-                clearTimeout(timer);
-                resolve(true);
-            };
-            promptWaiters.push(onSettle);
-        });
-    };
-    /** 这一条 prompt 落定；返回整轮是否就此收口（发了 `turn.completed`）。 */
-    const settleTurn = (input) => {
-        if (!isLive(input.expectedGeneration)) {
-            return false;
-        }
-        if (!acpPromptSettlementBelongsToContext({
-            liveAcpSessionId: sessionId ?? "",
-            expectedAcpSessionId: input.expectedSessionId,
-            liveActiveTurnId: activeTurnId,
-            liveSessionActiveTurnId: activeTurnId,
-            turnId: input.turnId,
-        })) {
-            return false;
-        }
-        closeActiveAssistantSegment(input.turnId);
-        promptsInFlight = Math.max(0, promptsInFlight - 1);
-        if (promptsInFlight !== 0 || activeTurnId !== input.turnId)
-            return false;
-        activeTurnId = undefined;
-        if (status !== "disposed") {
-            status = "ready";
-        }
-        emit({
-            type: "turn.completed",
-            ...stamp(),
-            provider: options.provider,
-            threadId: options.threadId,
-            turnId: input.turnId,
-            payload: {
-                state: input.state,
-                stopReason: input.stopReason,
-                ...(input.errorMessage === undefined ? {} : { errorMessage: input.errorMessage }),
-                ...(input.state === "failed" ? failureCategoryField(input.failureCategory) : {}),
-            },
-        });
-        interruptedTurnIds.delete(input.turnId);
-        return true;
-    };
-    /**
-     * 发一条 `session/prompt` 并等它收口：RPC 应答，或提前收口钩子认出的通知，谁先到算谁。
-     * 调用方持有 `promptMutex`；轮次的开合与事件由调用方管。`onWritten` 在请求写进对端
-     * stdin 之后调用（规则 13 的传输完成点）；写失败就不调。
-     */
-    const sendPromptRpc = async (sessionId, promptParts, onWritten) => {
-        const settlementHooks = hooks.promptSettlement;
-        // 有提前收口钩子时给这一轮一个关联 id，通知才认得回来。
-        const promptKey = settlementHooks === undefined ? undefined : randomId();
-        const pending = connection.begin("session/prompt", {
-            sessionId,
-            prompt: promptParts,
-            ...(settlementHooks !== undefined && promptKey !== undefined
-                ? settlementHooks.requestFields(promptKey)
-                : {}),
-        });
-        // 不 await 写入：提前收口的等待要在下面同步登记好，对端回得再快也认得回来。
-        void pending.written.then(onWritten, () => undefined);
-        const promptRpc = pending.response;
-        // 老实等对端应答。取消走 `session/cancel` 通知让 agent 自己收尾，不在本地
-        // 假装 resolve —— 那会让「调用方不再等」被误当成「远端已经停了」。
-        //
-        // 唯一的例外是提前收口钩子：Grok 1.0.24 起发完 `prompt_complete` 就不再回这条
-        // 应答，只等它这一轮永远收不了口。那不是本地假装 resolve——收口信号是对端发的。
-        if (settlementHooks === undefined || promptKey === undefined) {
-            return await promptRpc;
-        }
-        else {
-            const { promise: early, resolve: settleEarly } = Promise.withResolvers();
-            pendingSettlement = { promptKey, sessionId, settle: settleEarly };
-            try {
-                const outcome = await Promise.race([
-                    promptRpc.then((value) => {
-                        const key = settlementHooks.responseKey?.(value);
-                        if (key !== undefined)
-                            rememberSettledPromptKey(key);
-                        return { response: value };
-                    }),
-                    early,
-                ]);
-                if (outcome.error !== undefined)
-                    throw outcome.error;
-                return outcome.response;
-            }
-            finally {
-                pendingSettlement = undefined;
-                // 输掉的那条 RPC 没人再等。协议层没有单请求取消，它挂在 pending 表里
-                // 直到连接关闭——一轮一条，所以这里吞掉它的 rejection，不留未处理拒绝。
-                void promptRpc.catch(() => undefined);
-            }
-        }
-    };
-    const prompt = async (input) => {
-        failIfDisposed();
-        const started = requireStarted();
-        const settle = (rest) => settleTurn({
-            expectedGeneration: started.generation,
-            expectedSessionId: started.sessionId,
-            ...rest,
-        });
-        let turnId;
-        // thread 锁只罩短临界区（开轮、结算），不罩整个 prompt RPC。把整轮锁进去的话，
-        // 取消与审批答复会排在这把锁后面——「停止」和「允许」就永远到不了。
-        await threadMutex.acquire();
-        try {
-            failIfDisposed();
-            turnId = selectPromptTurnId(input, promptsInFlight > 0 ? activeTurnId : undefined, randomId);
-            promptsInFlight += 1;
-            activeTurnId = turnId;
-            status = "running";
-            if (promptsInFlight === 1) {
-                emit({
-                    type: "turn.started",
-                    ...stamp(),
-                    provider: options.provider,
-                    threadId: options.threadId,
-                    turnId,
-                    payload: {},
-                });
-            }
-        }
-        finally {
-            threadMutex.release();
-        }
-        const promptParts = input.prompt ??
-            (input.text !== undefined
-                ? [{ type: "text", text: input.text }]
-                : [{ type: "text", text: "" }]);
-        await promptMutex.acquire();
-        let response;
-        try {
-            failIfDisposed();
-            // 这一轮被打断、或插话的目标轮已不是活动轮：不写出去，换模型等完应答再核一次。普通 prompt 不看活动轮。
-            const queuedTurnId = turnId;
-            const isStale = () => interruptedTurnIds.has(queuedTurnId) ||
-                (input.expectedActiveTurnId !== undefined && activeTurnId !== queuedTurnId);
-            if (!isStale()) {
-                modelSelectionState = await applyRequestedModel({
-                    state: modelSelectionState,
-                    acpSessionId: started.sessionId,
-                    requestedModelId: input.requestedModelId,
-                    expectedGeneration: started.generation,
-                });
-            }
-            if (isStale()) {
-                settle({ turnId, stopReason: "cancelled", state: "cancelled" });
-                return { threadId: options.threadId, turnId, stopReason: "cancelled" };
-            }
-            closeActiveAssistantSegment(turnId);
-            let written = false;
-            try {
-                response = await sendPromptRpc(started.sessionId, promptParts, () => {
-                    written = true;
-                    input.onDispatched?.(turnId);
-                });
-            }
-            catch (error) {
-                if (disposed) {
-                    throw new AcpExecutorDisposedError();
-                }
-                // 调用方已经拿「写入落定」返回了，没人再接这次抛错：这一轮要靠事件以 failed 收尾。
-                // 打断引起的拒绝由 cancel 收成 cancelled；同一轮还有别的 prompt 在跑时没收口，不报失败。
-                const failureCategory = acpPromptFailureCategory(error, {
-                    sessionEstablished: startResult !== undefined,
-                    disposed,
-                });
-                if (written && input.onDispatched !== undefined && !interruptedTurnIds.has(turnId)) {
-                    const errorMessage = (error instanceof Error && error.message.trim()) || "ACP prompt failed";
-                    if (settle({
-                        turnId,
-                        stopReason: "error",
-                        state: "failed",
-                        errorMessage,
-                        ...(failureCategory === undefined ? {} : { failureCategory }),
-                    }))
-                        options.log?.warn?.("turn failed after dispatch", {
-                            threadId: options.threadId,
-                            failure: errorMessage,
-                        });
-                }
-                // 失败事件与抛给调用方的错误带同一个类别。
-                throw error instanceof Error ? withFailureCategory(error, failureCategory) : error;
-            }
-            // 应答唤醒调用方不代表同批通知已经派发：一次 stdio read 可能同时带回应答与
-            // 排在它后面的 `session/update`。不等排空就结算会漏事件。
-            await connection.awaitInboundIdle();
-            if (options.beforeApplyResult) {
-                await options.beforeApplyResult();
-            }
-        }
-        finally {
-            promptMutex.release();
-            notifyPromptSettled();
-        }
-        if (!isLive(started.generation)) {
-            throw new AcpExecutorDisposedError();
-        }
-        if (turnId === undefined) {
-            throw new AcpExecutorError("internal", "ACP prompt settled without a turn id");
-        }
-        const settledTurnId = turnId;
-        // 上下文占用在这家 CLI 自己写的记录里（厂商钩子）；读不到、读坏都不挡轮次收尾——少一条事件，界面不画圈，而不是画一个编出来的数。
-        let contextWindow;
-        if (hooks.readContextWindow !== undefined) {
-            try {
-                contextWindow =
-                    (await hooks.readContextWindow({
-                        sessionId: started.sessionId,
-                        promptResponse: response,
-                    })) ?? undefined;
-            }
-            catch {
-                contextWindow = undefined;
-            }
-        }
-        const finishPrompt = () => {
-            if (interruptedTurnIds.has(settledTurnId)) {
-                settle({ turnId: settledTurnId, stopReason: "cancelled", state: "cancelled" });
-                return {
-                    threadId: options.threadId,
-                    turnId: settledTurnId,
-                    stopReason: "cancelled",
-                };
-            }
-            const stopReason = hooks.completedStopReason?.(response) ?? response.stopReason;
-            if (contextWindow !== undefined) {
-                emit({
-                    type: "thread.token-usage.updated",
-                    ...stamp(),
-                    provider: options.provider,
-                    threadId: options.threadId,
-                    turnId: settledTurnId,
-                    payload: {
-                        usage: {
-                            usedTokens: contextWindow.usedTokens,
-                            ...(contextWindow.maxTokens === undefined
-                                ? {}
-                                : { maxTokens: contextWindow.maxTokens }),
-                        },
-                    },
-                });
-            }
-            settle({
-                turnId: settledTurnId,
-                stopReason,
-                state: response.stopReason === "cancelled" ? "cancelled" : "completed",
-            });
-            return {
-                threadId: options.threadId,
-                turnId: settledTurnId,
-                stopReason,
-                ...(response.usage !== undefined && response.usage !== null
-                    ? { usage: response.usage }
-                    : {}),
-            };
-        };
-        if (threadMutex.tryAcquire()) {
-            try {
-                return finishPrompt();
-            }
-            finally {
-                threadMutex.release();
-            }
-        }
-        await threadMutex.acquire();
-        try {
-            return finishPrompt();
-        }
-        finally {
-            threadMutex.release();
-        }
-    };
-    const cancel = async (turnId) => {
-        failIfDisposed();
-        const started = requireStarted();
-        const targetTurnId = turnId ?? activeTurnId;
-        if (targetTurnId !== undefined) {
-            interruptedTurnIds.add(targetTurnId);
-        }
-        settleAllApprovals("cancel");
-        settleAllUserInputs();
-        abortPendingSettlement("turn cancelled");
-        const runCancel = async () => {
-            if (sessionId) {
-                await connection.notify("session/cancel", { sessionId });
-            }
-            const settled = await waitForPromptIdle(cancelGraceMs);
-            if (!settled) {
-                throw new AcpExecutorCancelTimeoutError();
-            }
-            if (targetTurnId !== undefined && isLive(started.generation)) {
-                if (activeTurnId === targetTurnId || interruptedTurnIds.has(targetTurnId)) {
-                    if (status === "running") {
-                        closeActiveAssistantSegment(targetTurnId);
-                        promptsInFlight = 0;
-                        activeTurnId = undefined;
-                        status = "ready";
-                        emit({
-                            type: "turn.completed",
-                            ...stamp(),
-                            provider: options.provider,
-                            threadId: options.threadId,
-                            turnId: targetTurnId,
-                            payload: { state: "cancelled", stopReason: "cancelled" },
-                        });
-                        interruptedTurnIds.delete(targetTurnId);
-                    }
-                }
-            }
-        };
-        // 取消不走 thread 锁。今天 thread 锁只罩开轮与结算两段短临界区，prompt RPC 在锁外，
-        // 所以排进去也不会被 RPC 堵住——但那是「锁范围恰好正确」带来的，不是设计保证。
-        // 让取消独立于这把锁，是为了以后有人加长临界区时，Stop 仍然到得了。
-        await runCancel();
-    };
-    const respondToRequest = async (requestId, decision, reason) => {
-        failIfDisposed();
-        const apply = () => {
-            const pending = approvals.get(requestId);
-            if (!pending || pending.requestId !== requestId) {
-                throw new AcpExecutorRequestError("session/request_permission", `Unknown pending approval request: ${requestId}`);
-            }
-            if (pending.settled) {
-                return;
-            }
-            const selectedOptionId = decision === "cancel" ? undefined : selectAcpPermissionOptionId(pending.request, decision);
-            if (decision !== "cancel" && selectedOptionId === undefined) {
-                throw new AcpExecutorRequestError("session/request_permission", `Unsupported approval decision for this request: ${decision}`);
-            }
-            settleApproval(pending, approvalOutcomeForDecision(decision, selectedOptionId), decision, reason);
-        };
-        // 审批答复同样不走 thread 锁，理由同 `cancel`。
-        apply();
-    };
-    const compact = async (input) => {
-        failIfDisposed();
-        const started = requireStarted();
-        const trimmedName = input.commandName.trim();
-        const commandName = trimmedName.startsWith("/") ? trimmedName.slice(1) : trimmedName;
-        if (!availableCommands.some((command) => command.name === commandName)) {
-            throw new AcpExecutorError("command-unavailable", `The agent has not advertised the /${commandName} command`);
-        }
-        if (promptsInFlight > 0 || promptMutex.isLocked || manualCompaction !== undefined) {
-            throw new AcpExecutorError("busy", "Cannot compact while a turn or another compaction is running");
-        }
-        const record = {
-            snapshotId: randomId(),
-            trigger: "manual",
-            startedAtMs: nowMs(),
-            summary: undefined,
-            announced: true,
-            finished: false,
-            adopted: false,
-        };
-        // 先占住 promptMutex 再宣布开始：并发的 prompt 排在压缩后面，不会插进命令中间。
-        await promptMutex.acquire();
-        manualCompaction = record;
-        const emitSessionState = (state) => {
-            emit({
-                type: "session.state.changed",
-                ...stamp(),
-                provider: options.provider,
-                threadId: options.threadId,
-                payload: { state, reason: "compaction" },
-            });
-        };
-        try {
-            failIfDisposed();
-            emitSessionState("compacting");
-            emitCompactionState(record, "compacting");
-            let response;
-            try {
-                response = await sendPromptRpc(started.sessionId, [
-                    { type: "text", text: `/${commandName}` },
-                ]);
-            }
-            catch (error) {
-                if (disposed)
-                    throw new AcpExecutorDisposedError();
-                throw error;
-            }
-            await connection.awaitInboundIdle();
-            if (response.stopReason === "cancelled") {
-                return;
-            }
-            if (!record.finished) {
-                record.finished = true;
-                emitCompactionState(record, "compacted");
-            }
-        }
-        finally {
-            for (const [agentId, tracked] of compactions) {
-                if (tracked === record)
-                    compactions.delete(agentId);
-            }
-            manualCompaction = undefined;
-            promptMutex.release();
-            notifyPromptSettled();
-            if (!disposed)
-                emitSessionState("ready");
-        }
-    };
-    const setNativeMode = async (modeId) => {
-        failIfDisposed();
-        const started = startResult;
-        if (started === undefined) {
-            throw new AcpExecutorRequestError("session/set_mode", "session has not started yet");
-        }
-        // 报了 configOptions 那一项就走它，否则走 session/set_mode——两种报法各家挑一种，
-        // 发错通道会被回 `-32601 Method not found`（dsh 实测）。
-        const configId = acpModeConfigId(started.sessionSetupResult);
-        if (configId !== undefined) {
-            await connection.request("session/set_config_option", {
-                sessionId: started.sessionId,
-                configId,
-                value: modeId,
-            });
-            return;
-        }
-        await connection.request("session/set_mode", {
-            sessionId: started.sessionId,
-            modeId,
-        });
-    };
-    const respondToUserInput = async (requestId, answers) => {
-        failIfDisposed();
-        const pending = pendingUserInputs.get(requestId);
-        if (pending === undefined) {
-            throw new AcpExecutorRequestError("session/request_permission", `Unknown pending user-input request: ${requestId}`);
-        }
-        if (pending.settled) {
-            return;
-        }
-        pending.settled = true;
-        pendingUserInputs.delete(requestId);
-        pending.resolve({
-            kind: "answered",
-            answers: isRecord(answers) ? answers : {},
-        });
-    };
-    const dispose = async () => {
-        if (disposed) {
-            return;
-        }
-        settleAllApprovals("cancel");
-        settleAllUserInputs();
-        abortPendingSettlement("executor disposed");
-        notifyPromptSettled();
-        abortLocalPrompt?.();
-        emit({
-            type: "session.exited",
-            ...stamp(),
-            provider: options.provider,
-            threadId: options.threadId,
-            payload: { reason: "disposed" },
-        });
-        disposed = true;
-        generation += 1;
-        status = "disposed";
-        eventStream.close();
-        options.readable.off("end", onInputDead);
-        options.readable.off("error", onInputDead);
-        options.readable.pause();
-        if (!connectionClosed) {
-            await connection.awaitInboundIdle().catch(() => undefined);
-            await connection.close().catch(() => undefined);
-        }
-    };
+    const { applyRequestedModel, start, requireStarted, setNativeMode } = createExecutorSession({
+        options,
+        connection,
+        isLive,
+        emit,
+        stamp,
+        failIfDisposed,
+        shared,
+    });
+    const { sendPromptRpc, prompt } = createExecutorPrompt({
+        isLive,
+        closeActiveAssistantSegment,
+        emit,
+        stamp,
+        options,
+        interruptedTurnIds,
+        hooks,
+        randomId,
+        connection,
+        rememberSettledPromptKey,
+        failIfDisposed,
+        requireStarted,
+        threadMutex,
+        promptMutex,
+        applyRequestedModel,
+        notifyPromptSettled,
+        shared,
+    });
+    const { cancel, compact, dispose } = createExecutorLifecycle({
+        failIfDisposed,
+        requireStarted,
+        interruptedTurnIds,
+        settleAllApprovals,
+        settleAllUserInputs,
+        abortPendingSettlement,
+        connection,
+        waitForPromptIdle,
+        cancelGraceMs,
+        isLive,
+        closeActiveAssistantSegment,
+        emit,
+        stamp,
+        options,
+        promptMutex,
+        randomId,
+        nowMs,
+        emitCompactionState,
+        sendPromptRpc,
+        compactions,
+        notifyPromptSettled,
+        eventStream,
+        onInputDead,
+        shared,
+    });
     return {
         get generation() {
-            return generation;
+            return shared.generation;
         },
         get sessionId() {
-            return sessionId;
+            return shared.sessionId;
         },
         get modelId() {
-            return modelSelectionState.currentModelId;
+            return shared.modelSelectionState.currentModelId;
         },
         get status() {
-            return status;
+            return shared.status;
         },
         events: eventStream.subscribe(),
         start,
@@ -1358,7 +255,7 @@ export function createAcpExecutor(options) {
         respondToUserInput,
         setNativeMode,
         compact,
-        openToolCalls: () => readOpenToolCalls(toolCalls, activeTurnId),
+        openToolCalls: () => readOpenToolCalls(toolCalls, shared.activeTurnId),
         dispose,
     };
 }