@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/providers/acp-agent.js

@@ -0,0 +1,3412 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { Readable, Writable } from "node:stream";
+import { terminateWithTreeKill } from "../../../utils/tree-kill.js";
+import { ClientSideConnection, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
+import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
+import { raceProviderRefreshAbort, runProviderRefreshActivity, } from "../provider-refresh-deadline.js";
+import { isDefaultAgentCreateConfigUnattended, resolveDefaultAgentCreateConfig, } from "../create-agent-mode.js";
+import { importSessionFromPersistence } from "../provider-session-import.js";
+import { checkProviderLaunchAvailable, createProviderEnvSpec, resolveProviderLaunch, } from "../provider-launch-config.js";
+import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
+import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "./provider-runner.js";
+import { buildStringCommandShellInvocation, createStringCommandShellEnvOverlay, } from "../../../utils/string-command-shell.js";
+import { spawnProcess } from "../../../utils/spawn.js";
+import { toDiagnosticErrorMessage, truncateForDiagnostic, } from "./diagnostic-utils.js";
+import { withTimeout } from "../../../utils/promise-timeout.js";
+const ACP_AUTO_ACCEPT_FEATURE_ID = "auto_accept";
+function assertChildWithPipes(child) {
+    if (!child.stdin || !child.stdout || !child.stderr) {
+        throw new Error("Child process did not expose stdio pipes");
+    }
+}
+function isRecord(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function isACPError(value) {
+    return isRecord(value) && typeof value.message === "string" && typeof value.code === "number";
+}
+function extractACPErrorDataMessage(data) {
+    if (!isRecord(data)) {
+        return null;
+    }
+    for (const key of ["details", "errorMessage", "message", "detail", "title"]) {
+        const value = data[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return extractACPErrorDataMessage(data.error);
+}
+export function summarizeACPRequestError(error) {
+    // Promise rejections are untyped, but the ACP SDK rejects JSON-RPC failures as response.error.
+    if (isACPError(error)) {
+        const code = String(error.code);
+        const detail = extractACPErrorDataMessage(error.data);
+        const message = detail && detail !== error.message ? `${error.message}: ${detail}` : error.message;
+        const data = error.data === undefined ? "" : ` | data=${JSON.stringify(error.data)}`;
+        return {
+            message,
+            code,
+            diagnostic: `${message} | code=${code}${data}`,
+        };
+    }
+    if (error instanceof Error) {
+        return { message: error.message };
+    }
+    return { message: String(error) };
+}
+function toACPRequestError(error) {
+    if (!isACPError(error)) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    const summary = summarizeACPRequestError(error);
+    const next = new Error(summary.message);
+    next.name = "ACPRequestError";
+    return next;
+}
+function resolveTerminalCommand(command, args) {
+    if (args && args.length > 0) {
+        return { command, args };
+    }
+    if (!/\s/.test(command.trim())) {
+        return { command, args: [] };
+    }
+    const shell = buildStringCommandShellInvocation({ command, windowsShell: "cmd" });
+    return { command: shell.shell, args: shell.args, shell: false };
+}
+function formatDurationMs(startedAt) {
+    return `${Math.max(0, Date.now() - startedAt)}ms`;
+}
+function pushACPStderrRow(rows, stderrChunks) {
+    const stderr = stderrChunks.join("").trim();
+    if (!stderr) {
+        return;
+    }
+    rows.push({
+        label: "ACP stderr",
+        value: truncateForDiagnostic(stderr),
+    });
+}
+export const DEFAULT_ACP_CAPABILITIES = {
+    supportsStreaming: true,
+    supportsSessionPersistence: true,
+    supportsSessionListing: true,
+    supportsDynamicModes: true,
+    supportsMcpServers: true,
+    supportsReasoningStream: true,
+    supportsToolInvocations: true,
+    supportsRewindConversation: false,
+    supportsRewindFiles: false,
+    supportsRewindBoth: false,
+};
+function acpSessionListRequest(cursor, cwd) {
+    return {
+        ...(cursor ? { cursor } : {}),
+        ...(cwd ? { cwd } : {}),
+    };
+}
+const BASE_ACP_CLIENT_CAPABILITIES = {
+    fs: {
+        readTextFile: false,
+        writeTextFile: false,
+    },
+    terminal: true,
+};
+export function buildACPClientCapabilities(meta, override) {
+    const capabilities = {
+        ...BASE_ACP_CLIENT_CAPABILITIES,
+        ...override,
+        fs: {
+            ...BASE_ACP_CLIENT_CAPABILITIES.fs,
+            ...override?.fs,
+        },
+    };
+    return meta && Object.keys(meta).length > 0 ? { ...capabilities, _meta: meta } : capabilities;
+}
+// Suppress interactive auth side-effects (e.g. Gemini CLI opening a Google
+// sign-in URL in the browser) when probing an ACP agent for models/modes.
+// NO_BROWSER is honored by Gemini CLI; other ACP agents ignore it.
+const PROBE_ENV = { NO_BROWSER: "true" };
+const ACP_DIAGNOSTIC_PHASE_TIMEOUT_MS = 20000;
+const ACP_PROBE_CLOSE_TIMEOUT_MS = 2000;
+const ACP_IMPORT_HISTORY_LOAD_TIMEOUT_MS = 30000;
+const ACP_IMPORT_HISTORY_BUDGET_MS = 60000;
+function summarizeMalformedACPStdoutError(error) {
+    return {
+        type: error instanceof Error ? error.name : typeof error,
+        message: "ACP stdout line was not valid JSON",
+    };
+}
+function normalizeACPIncomingMessage(message) {
+    if ("id" in message &&
+        !("method" in message) &&
+        typeof message.id === "string" &&
+        /^\d+$/.test(message.id)) {
+        const numericId = Number(message.id);
+        if (Number.isSafeInteger(numericId)) {
+            return {
+                ...message,
+                // COMPAT(deepseek-tui-acp-id): added v0.1.78, remove after 2026-11-19
+                // once the ACP SDK accepts stringified numeric response IDs.
+                id: numericId,
+            };
+        }
+    }
+    return message;
+}
+export function createLoggedNdJsonStream(output, input, options) {
+    const textEncoder = new TextEncoder();
+    const textDecoder = new TextDecoder();
+    const readable = new ReadableStream({
+        async start(controller) {
+            let content = "";
+            const reader = input.getReader();
+            try {
+                while (true) {
+                    const { value, done } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    if (!value) {
+                        continue;
+                    }
+                    content += textDecoder.decode(value, { stream: true });
+                    const lines = content.split("\n");
+                    content = lines.pop() || "";
+                    for (const line of lines) {
+                        const trimmedLine = line.trim();
+                        if (!trimmedLine) {
+                            continue;
+                        }
+                        try {
+                            const message = JSON.parse(trimmedLine);
+                            controller.enqueue(normalizeACPIncomingMessage(message));
+                        }
+                        catch (error) {
+                            options.logger.warn({
+                                err: summarizeMalformedACPStdoutError(error),
+                                provider: options.provider,
+                            }, "ACP agent emitted non-JSON stdout; ignoring line");
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+                controller.close();
+            }
+        },
+    });
+    const writable = new WritableStream({
+        async write(message) {
+            const writer = output.getWriter();
+            try {
+                await writer.write(textEncoder.encode(`${JSON.stringify(message)}\n`));
+            }
+            finally {
+                writer.releaseLock();
+            }
+        },
+    });
+    return { readable, writable };
+}
+class ACPImportHistoryCollector {
+    constructor() {
+        this.prompts = new Map();
+    }
+    begin(sessionId) {
+        this.prompts.set(sessionId, { completed: [], current: null, hasConversation: false });
+    }
+    accept(params) {
+        const state = this.prompts.get(params.sessionId);
+        if (!state)
+            return;
+        const update = params.update;
+        if (isACPConversationUpdate(update))
+            state.hasConversation = true;
+        if (update.sessionUpdate !== "user_message_chunk") {
+            this.flushCurrent(state);
+            return;
+        }
+        const text = contentBlockToText(update.content);
+        if (!text)
+            return;
+        const messageId = update.messageId ?? null;
+        if (state.current?.messageId && messageId !== state.current.messageId) {
+            this.flushCurrent(state);
+        }
+        state.current ?? (state.current = { messageId, text: "" });
+        state.current.text += text;
+    }
+    finish(sessionId) {
+        const state = this.prompts.get(sessionId);
+        if (!state) {
+            return { firstPromptPreview: null, lastPromptPreview: null, hasConversation: false };
+        }
+        this.flushCurrent(state);
+        this.prompts.delete(sessionId);
+        return {
+            firstPromptPreview: normalizeACPImportPromptPreview(state.completed[0] ?? null),
+            lastPromptPreview: normalizeACPImportPromptPreview(state.completed.at(-1) ?? null),
+            hasConversation: state.hasConversation,
+        };
+    }
+    discard(sessionId) {
+        this.prompts.delete(sessionId);
+    }
+    flushCurrent(state) {
+        if (state.current?.text.trim())
+            state.completed.push(state.current.text);
+        state.current = null;
+    }
+}
+export function mapACPUsage(usage) {
+    if (!usage) {
+        return undefined;
+    }
+    return {
+        inputTokens: usage.inputTokens ?? undefined,
+        outputTokens: usage.outputTokens ?? undefined,
+        cachedInputTokens: usage.cachedReadTokens ?? undefined,
+    };
+}
+export function resolveACPModeSelection({ modeId, availableModes, configOptions, }) {
+    const configOption = findSelectConfigOption({ configOptions, category: "mode" });
+    return {
+        availableMode: availableModes.find((mode) => mode.id === modeId) ?? null,
+        configOption,
+        configChoice: findSelectConfigChoice({ option: configOption, value: modeId }),
+        hasAvailableModes: availableModes.length > 0,
+    };
+}
+export function resolveACPModelSelection({ modelId, availableModels, configOptions, }) {
+    const configOption = findSelectConfigOption({ configOptions, category: "model" });
+    return {
+        availableModel: availableModels?.find((model) => model.modelId === modelId) ?? null,
+        configOption,
+        configChoice: findSelectConfigChoice({ option: configOption, value: modelId }),
+        hasAvailableModels: Boolean(availableModels?.length),
+    };
+}
+export function deriveModesFromACP(fallbackModes, modeState, configOptions) {
+    if (modeState?.availableModes?.length) {
+        return {
+            modes: modeState.availableModes.map((mode) => ({
+                id: mode.id,
+                label: mode.name,
+                description: mode.description ?? undefined,
+            })),
+            currentModeId: modeState.currentModeId ?? null,
+        };
+    }
+    const modeOption = findSelectConfigOption({ configOptions, category: "mode" });
+    if (modeOption) {
+        const flatOptions = flattenSelectOptions(modeOption.options);
+        return {
+            modes: flatOptions.map((option) => ({
+                id: option.value,
+                label: option.name,
+                description: option.description ?? undefined,
+            })),
+            currentModeId: modeOption.currentValue,
+        };
+    }
+    return {
+        modes: fallbackModes,
+        currentModeId: null,
+    };
+}
+export function deriveModelDefinitionsFromACP(provider, models, configOptions) {
+    const thinkingOptions = deriveSelectorOptions(configOptions, "thought_level");
+    const defaultThinkingOptionId = thinkingOptions.find((option) => option.isDefault)?.id ?? null;
+    if (models?.availableModels?.length) {
+        return models.availableModels.map((model) => ({
+            provider,
+            id: model.modelId,
+            label: model.name,
+            description: model.description ?? undefined,
+            isDefault: model.modelId === models.currentModelId,
+            thinkingOptions: thinkingOptions.length > 0 ? thinkingOptions : undefined,
+            defaultThinkingOptionId: defaultThinkingOptionId ?? undefined,
+        }));
+    }
+    const modelOptions = deriveSelectorOptions(configOptions, "model");
+    return modelOptions.map((option) => ({
+        provider,
+        id: option.id,
+        label: option.label,
+        description: option.description,
+        isDefault: option.isDefault,
+        thinkingOptions: thinkingOptions.length > 0 ? thinkingOptions : undefined,
+        defaultThinkingOptionId: defaultThinkingOptionId ?? undefined,
+        metadata: option.metadata,
+    }));
+}
+export function deriveFeaturesFromACP(configOptions, featureOptions) {
+    return featureOptions.flatMap((featureOption) => {
+        const option = findSelectConfigFeatureOption(configOptions, featureOption);
+        if (!option) {
+            return [];
+        }
+        return [
+            {
+                type: "select",
+                id: featureOption.id,
+                label: featureOption.label,
+                description: featureOption.description,
+                tooltip: featureOption.tooltip,
+                icon: featureOption.icon,
+                value: option.currentValue ?? null,
+                options: deriveConfigFeatureSelectOptions(option, featureOption),
+            },
+        ];
+    });
+}
+function isACPAutoAcceptEnabled(config) {
+    return config.featureValues?.[ACP_AUTO_ACCEPT_FEATURE_ID] === true;
+}
+function buildACPAutoAcceptFeature(config) {
+    return {
+        type: "toggle",
+        id: ACP_AUTO_ACCEPT_FEATURE_ID,
+        label: "Auto Accept",
+        description: "Automatically approves ACP permission prompts.",
+        tooltip: "Auto accept permission prompts",
+        icon: "shield-check",
+        value: isACPAutoAcceptEnabled(config),
+    };
+}
+function resolveACPCreateConfig(input) {
+    const isUnattendedCreate = input.unattended || input.parent?.isUnattended === true;
+    const featureValues = isUnattendedCreate && input.featureValues?.[ACP_AUTO_ACCEPT_FEATURE_ID] === undefined
+        ? { ...input.featureValues, [ACP_AUTO_ACCEPT_FEATURE_ID]: true }
+        : input.featureValues;
+    if (input.requestedMode === undefined &&
+        isUnattendedCreate &&
+        input.parent !== null &&
+        input.parent.provider !== input.provider) {
+        return { modeId: undefined, featureValues };
+    }
+    return resolveDefaultAgentCreateConfig({ ...input, featureValues });
+}
+function isACPCreateConfigUnattended(input) {
+    return (isDefaultAgentCreateConfigUnattended(input) ||
+        input.config.featureValues?.[ACP_AUTO_ACCEPT_FEATURE_ID] === true ||
+        input.features?.some((feature) => feature.id === ACP_AUTO_ACCEPT_FEATURE_ID &&
+            feature.type === "toggle" &&
+            feature.value === true) === true);
+}
+export class ACPAgentClient {
+    constructor(options) {
+        this.resolveCreateConfig = resolveACPCreateConfig;
+        this.isCreateConfigUnattended = isACPCreateConfigUnattended;
+        this.importPromptCache = new Map();
+        this.provider = options.provider;
+        this.terminateProcess = options.terminateProcess ?? terminateWithTreeKill;
+        this.capabilities = options.capabilities ?? DEFAULT_ACP_CAPABILITIES;
+        this.logger = options.logger.child({
+            module: "agent",
+            provider: options.provider,
+        });
+        this.runtimeSettings = options.runtimeSettings;
+        this.defaultCommand = options.defaultCommand;
+        this.defaultModes = options.defaultModes ?? [];
+        this.catalogModelResolver = options.catalogModelResolver;
+        this.modelTransformer = options.modelTransformer;
+        this.sessionResponseTransformer = options.sessionResponseTransformer;
+        this.configOptionsTransformer = options.configOptionsTransformer;
+        this.configFeatureOptions = options.configFeatureOptions ?? [];
+        this.clientCapabilities = options.clientCapabilities;
+        this.clientCapabilityMeta = options.clientCapabilityMeta;
+        this.modeIdTransformer = options.modeIdTransformer;
+        this.toolSnapshotTransformer = options.toolSnapshotTransformer;
+        this.providerModeWriter = options.providerModeWriter;
+        this.beforeModeWriter = options.beforeModeWriter;
+        this.thinkingOptionWriter = options.thinkingOptionWriter;
+        this.waitForInitialCommands = options.waitForInitialCommands ?? false;
+        this.initialCommandsWaitTimeoutMs = options.initialCommandsWaitTimeoutMs ?? 1500;
+        this.extensionCommandsParser = options.extensionCommandsParser;
+        this.now = options.now ?? Date.now;
+    }
+    async createSession(config, launchContext) {
+        this.assertProvider(config);
+        const session = this.createAgentSession({ ...config, provider: this.provider }, {
+            provider: this.provider,
+            logger: this.logger,
+            runtimeSettings: this.runtimeSettings,
+            defaultCommand: this.defaultCommand,
+            defaultModes: this.defaultModes,
+            modelTransformer: this.modelTransformer,
+            sessionResponseTransformer: this.sessionResponseTransformer,
+            configOptionsTransformer: this.configOptionsTransformer,
+            configFeatureOptions: this.configFeatureOptions,
+            clientCapabilities: this.clientCapabilities,
+            clientCapabilityMeta: this.clientCapabilityMeta,
+            modeIdTransformer: this.modeIdTransformer,
+            toolSnapshotTransformer: this.toolSnapshotTransformer,
+            providerModeWriter: this.providerModeWriter,
+            beforeModeWriter: this.beforeModeWriter,
+            thinkingOptionWriter: this.thinkingOptionWriter,
+            capabilities: this.capabilities,
+            agentId: launchContext?.agentId,
+            launchEnv: launchContext?.env,
+            extensionCommandsParser: this.extensionCommandsParser,
+            waitForInitialCommands: this.waitForInitialCommands,
+            initialCommandsWaitTimeoutMs: this.initialCommandsWaitTimeoutMs,
+        });
+        await session.initializeNewSession();
+        return session;
+    }
+    /**
+     * Builds the session instance behind `createSession`/`resumeSession`. A fork
+     * provider overrides this to substitute its own session subclass while
+     * keeping the shared launch, transform, and capability plumbing.
+     */
+    createAgentSession(config, options) {
+        return new ACPAgentSession(config, options);
+    }
+    async resumeSession(handle, overrides, launchContext) {
+        if (handle.provider !== this.provider) {
+            throw new Error(`Cannot resume ${handle.provider} handle with ${this.provider} provider`);
+        }
+        const storedConfig = coerceSessionConfigMetadata(handle.metadata);
+        const cwd = overrides?.cwd ?? storedConfig.cwd;
+        if (!cwd) {
+            throw new Error(`${this.provider} resume requires the original working directory`);
+        }
+        const mergedConfig = {
+            ...storedConfig,
+            ...overrides,
+            provider: this.provider,
+            cwd,
+        };
+        const session = this.createAgentSession(mergedConfig, {
+            provider: this.provider,
+            logger: this.logger,
+            runtimeSettings: this.runtimeSettings,
+            defaultCommand: this.defaultCommand,
+            defaultModes: this.defaultModes,
+            modelTransformer: this.modelTransformer,
+            sessionResponseTransformer: this.sessionResponseTransformer,
+            configOptionsTransformer: this.configOptionsTransformer,
+            configFeatureOptions: this.configFeatureOptions,
+            clientCapabilities: this.clientCapabilities,
+            clientCapabilityMeta: this.clientCapabilityMeta,
+            modeIdTransformer: this.modeIdTransformer,
+            toolSnapshotTransformer: this.toolSnapshotTransformer,
+            providerModeWriter: this.providerModeWriter,
+            beforeModeWriter: this.beforeModeWriter,
+            thinkingOptionWriter: this.thinkingOptionWriter,
+            capabilities: this.capabilities,
+            handle,
+            agentId: launchContext?.agentId,
+            launchEnv: launchContext?.env,
+            extensionCommandsParser: this.extensionCommandsParser,
+            waitForInitialCommands: this.waitForInitialCommands,
+            initialCommandsWaitTimeoutMs: this.initialCommandsWaitTimeoutMs,
+        });
+        await session.initializeResumedSession();
+        return session;
+    }
+    async fetchCatalog(options, context) {
+        const cwd = options.scope === "global" ? homedir() : options.cwd;
+        let probe = null;
+        let probeSessionId = null;
+        let probeSessionPromise = null;
+        let closePromise = null;
+        const closeProbe = () => {
+            if (!probe)
+                return Promise.resolve();
+            closePromise ?? (closePromise = (async () => {
+                if (!probeSessionId && probeSessionPromise) {
+                    try {
+                        probeSessionId = (await withTimeout(probeSessionPromise, ACP_PROBE_CLOSE_TIMEOUT_MS, `ACP probe session/new cleanup timed out after ${ACP_PROBE_CLOSE_TIMEOUT_MS}ms`)).sessionId;
+                    }
+                    catch (error) {
+                        this.logger.debug({ err: error }, "ACP probe session/new did not finish during cleanup");
+                    }
+                }
+                await this.closeProbe(probe, probeSessionId);
+            })());
+            return closePromise;
+        };
+        const handleAbort = () => void closeProbe().catch(() => undefined);
+        context?.signal.addEventListener("abort", handleAbort, { once: true });
+        try {
+            const initializedProbe = await runProviderRefreshActivity(context, "initialize", () => raceProviderRefreshAbort(context?.signal, this.spawnProcess(PROBE_ENV, {
+                onSpawned: (spawned) => {
+                    probe = spawned;
+                    if (context?.signal.aborted)
+                        void closeProbe().catch(() => undefined);
+                },
+            })));
+            probe = initializedProbe;
+            probeSessionPromise = this.runACPRequest(() => initializedProbe.connection.newSession({
+                cwd,
+                mcpServers: [],
+            }));
+            const response = await runProviderRefreshActivity(context, "session/new", () => raceProviderRefreshAbort(context?.signal, probeSessionPromise));
+            probeSessionId = response.sessionId;
+            const transformed = this.transformSessionResponse(response);
+            const derivedModels = deriveModelDefinitionsFromACP(this.provider, transformed.models, transformed.configOptions);
+            const models = this.catalogModelResolver
+                ? await runProviderRefreshActivity(context, "catalog.resolve", () => raceProviderRefreshAbort(context?.signal, this.catalogModelResolver?.({
+                    connection: initializedProbe.connection,
+                    sessionId: response.sessionId,
+                    models: derivedModels,
+                    configOptions: transformed.configOptions,
+                    runRequest: (request) => this.runACPRequest(request),
+                    transformConfigOptions: (configOptions) => this.configOptionsTransformer
+                        ? this.configOptionsTransformer(configOptions)
+                        : configOptions,
+                    logger: this.logger,
+                    provider: this.provider,
+                }) ?? Promise.resolve(derivedModels)))
+                : derivedModels;
+            const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, transformed.configOptions);
+            return {
+                models: this.modelTransformer ? this.modelTransformer(models) : models,
+                modes: modeInfo.modes,
+            };
+        }
+        finally {
+            context?.signal.removeEventListener("abort", handleAbort);
+            await closeProbe();
+        }
+    }
+    async listFeatures(config) {
+        const autoAcceptFeature = buildACPAutoAcceptFeature(config);
+        if (this.configFeatureOptions.length === 0) {
+            return [autoAcceptFeature];
+        }
+        this.assertProvider(config);
+        const probe = await this.spawnProcess(PROBE_ENV);
+        let probeSessionId = null;
+        try {
+            const response = await this.runACPRequest(() => probe.connection.newSession({
+                cwd: config.cwd,
+                mcpServers: [],
+            }));
+            probeSessionId = response.sessionId;
+            const transformed = this.transformSessionResponse(response);
+            return [
+                autoAcceptFeature,
+                ...deriveFeaturesFromACP(transformed.configOptions, this.configFeatureOptions),
+            ];
+        }
+        finally {
+            await this.closeProbe(probe, probeSessionId);
+        }
+    }
+    async listImportableSessions(options) {
+        const history = new ACPImportHistoryCollector();
+        const probe = await this.spawnProcess(PROBE_ENV, {
+            client: this.buildProbeClient((params) => history.accept(params)),
+        });
+        try {
+            if (!probe.initialize.agentCapabilities?.sessionCapabilities?.list) {
+                return [];
+            }
+            const sessions = [];
+            const resultLimit = options?.limit ?? Number.POSITIVE_INFINITY;
+            const scanLimit = Math.min(options?.scanLimit ?? 500, 500);
+            const canLoadHistory = probe.initialize.agentCapabilities.loadSession === true;
+            const historyDeadline = this.now() + ACP_IMPORT_HISTORY_BUDGET_MS;
+            let scanned = 0;
+            let cursor;
+            for (;;) {
+                const page = await this.runACPRequest(() => probe.connection.listSessions(acpSessionListRequest(cursor, options?.cwd)));
+                for (const session of page.sessions) {
+                    if (scanned >= scanLimit || sessions.length >= resultLimit)
+                        break;
+                    scanned += 1;
+                    const descriptor = await this.describeImportableSession(probe, history, session, canLoadHistory, historyDeadline);
+                    if (descriptor)
+                        sessions.push(descriptor);
+                }
+                cursor = page.nextCursor ?? null;
+                if (!cursor)
+                    break;
+                if (scanned >= scanLimit || sessions.length >= resultLimit)
+                    break;
+            }
+            return sessions;
+        }
+        finally {
+            await this.closeProbe(probe);
+        }
+    }
+    async describeImportableSession(probe, history, session, canLoadHistory, historyDeadline) {
+        const loadedPreviews = canLoadHistory
+            ? await this.loadImportPromptPreviews(probe, history, session, historyDeadline)
+            : null;
+        if (loadedPreviews?.hasConversation === false)
+            return null;
+        return {
+            providerHandleId: session.sessionId,
+            cwd: session.cwd,
+            title: session.title ?? null,
+            firstPromptPreview: loadedPreviews?.firstPromptPreview ?? null,
+            lastPromptPreview: loadedPreviews?.lastPromptPreview ?? null,
+            lastActivityAt: session.updatedAt ? new Date(session.updatedAt) : new Date(0),
+        };
+    }
+    async loadImportPromptPreviews(probe, history, session, historyDeadline) {
+        const updatedAt = session.updatedAt ?? null;
+        const cached = this.importPromptCache.get(session.sessionId);
+        if (updatedAt !== null && cached?.updatedAt === updatedAt) {
+            return {
+                firstPromptPreview: cached.firstPromptPreview,
+                lastPromptPreview: cached.lastPromptPreview,
+                hasConversation: cached.hasConversation,
+            };
+        }
+        const remainingMs = historyDeadline - this.now();
+        if (remainingMs <= 0)
+            return null;
+        const loadTimeoutMs = Math.min(ACP_IMPORT_HISTORY_LOAD_TIMEOUT_MS, remainingMs);
+        history.begin(session.sessionId);
+        try {
+            await withTimeout(this.runACPRequest(() => probe.connection.loadSession({
+                sessionId: session.sessionId,
+                cwd: session.cwd,
+                mcpServers: [],
+            })), loadTimeoutMs, `ACP import history load timed out after ${loadTimeoutMs}ms`);
+            const previews = history.finish(session.sessionId);
+            if (updatedAt !== null) {
+                this.importPromptCache.set(session.sessionId, { updatedAt, ...previews });
+            }
+            return previews;
+        }
+        catch (error) {
+            history.discard(session.sessionId);
+            this.logger.debug({ err: error, sessionId: session.sessionId }, "ACP import history load failed; keeping the session visible");
+            return null;
+        }
+        finally {
+            await this.closeLoadedSession(probe, session.sessionId, historyDeadline);
+        }
+    }
+    async closeLoadedSession(probe, sessionId, historyDeadline) {
+        if (!probe.initialize.agentCapabilities?.sessionCapabilities?.close)
+            return;
+        const remainingMs = historyDeadline - this.now();
+        if (remainingMs <= 0)
+            return;
+        const closeTimeoutMs = Math.min(ACP_PROBE_CLOSE_TIMEOUT_MS, remainingMs);
+        try {
+            await withTimeout(probe.connection.unstable_closeSession({ sessionId }), closeTimeoutMs, `ACP loaded session/close timed out after ${closeTimeoutMs}ms`);
+        }
+        catch (error) {
+            this.logger.debug({ err: error, sessionId }, "ACP loaded session close failed");
+        }
+    }
+    async importSession(input, context) {
+        return importSessionFromPersistence({
+            provider: this.provider,
+            request: input,
+            context,
+            resumeSession: this.resumeSession.bind(this),
+        });
+    }
+    async isAvailable() {
+        try {
+            await this.resolveLaunchCommand();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async spawnProcess(launchEnv, options) {
+        const transport = await this.spawnTransport(launchEnv, options?.client);
+        const probe = {
+            child: transport.child,
+            connection: transport.connection,
+            stderrChunks: transport.stderrChunks,
+        };
+        options?.onSpawned?.(probe);
+        try {
+            const initialize = await this.initializeTransport(transport, options?.initializeTimeoutMs);
+            const initializedProbe = {
+                ...probe,
+                initialize,
+            };
+            probe.initialize = initialize;
+            return initializedProbe;
+        }
+        catch (error) {
+            await terminateChildProcess(transport.child, 2000, this.terminateProcess);
+            throw error;
+        }
+    }
+    async spawnTransport(launchEnv, client = this.buildProbeClient()) {
+        const { command, args } = await this.resolveLaunchCommand();
+        const child = spawnProcess(command, args, {
+            cwd: process.cwd(),
+            ...createProviderEnvSpec({
+                runtimeSettings: this.runtimeSettings,
+                overlays: [launchEnv],
+            }),
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        assertChildWithPipes(child);
+        const stderrChunks = [];
+        child.stderr.on("data", (chunk) => {
+            stderrChunks.push(chunk.toString());
+        });
+        const spawnErrorPromise = new Promise((_, reject) => {
+            child.once("error", (error) => {
+                const stderr = stderrChunks.join("").trim();
+                reject(new Error(stderr ? `${String(error)}\n${stderr}` : String(error)));
+            });
+        });
+        const spawnReadyPromise = new Promise((resolve) => {
+            child.once("spawn", () => {
+                resolve();
+            });
+        });
+        const stream = createLoggedNdJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout), { logger: this.logger, provider: this.provider });
+        const connection = new ClientSideConnection(() => client, stream);
+        return {
+            child,
+            connection,
+            stderrChunks,
+            spawnReady: spawnReadyPromise,
+            spawnError: spawnErrorPromise,
+        };
+    }
+    async initializeTransport(transport, initializeTimeoutMs) {
+        let timeout = null;
+        const initializeTimeoutPromise = initializeTimeoutMs
+            ? new Promise((_, reject) => {
+                timeout = setTimeout(() => {
+                    reject(new Error(`ACP initialize timed out after ${initializeTimeoutMs}ms`));
+                }, initializeTimeoutMs);
+            })
+            : null;
+        try {
+            return await this.runACPRequest(() => Promise.race([
+                transport.connection.initialize({
+                    protocolVersion: PROTOCOL_VERSION,
+                    clientCapabilities: buildACPClientCapabilities(this.clientCapabilityMeta, this.clientCapabilities),
+                    clientInfo: { name: "Paseo", version: "dev" },
+                }),
+                transport.spawnError,
+                ...(initializeTimeoutPromise ? [initializeTimeoutPromise] : []),
+            ]));
+        }
+        finally {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+        }
+    }
+    buildProbeClient(onSessionUpdate) {
+        return {
+            async requestPermission() {
+                return { outcome: { outcome: "cancelled" } };
+            },
+            async sessionUpdate(params) {
+                await onSessionUpdate?.(params);
+            },
+            async readTextFile(params) {
+                const content = await fs.readFile(params.path, "utf8");
+                return { content };
+            },
+            async writeTextFile(params) {
+                await fs.mkdir(path.dirname(params.path), { recursive: true });
+                await fs.writeFile(params.path, params.content, "utf8");
+                return {};
+            },
+            async createTerminal() {
+                throw new Error("ACP model probe does not support terminal execution");
+            },
+        };
+    }
+    async closeProbe(probe, sessionId = null) {
+        try {
+            if (sessionId && probe.initialize?.agentCapabilities?.sessionCapabilities?.close) {
+                await withTimeout(probe.connection.unstable_closeSession({ sessionId }), ACP_PROBE_CLOSE_TIMEOUT_MS, `ACP probe session/close timed out after ${ACP_PROBE_CLOSE_TIMEOUT_MS}ms`);
+            }
+        }
+        catch (error) {
+            this.logger.debug({ err: error, sessionId }, "ACP probe closeSession failed during cleanup");
+        }
+        finally {
+            await terminateChildProcess(probe.child, 2000, this.terminateProcess);
+        }
+    }
+    async runACPRequest(request) {
+        try {
+            return await request();
+        }
+        catch (error) {
+            throw toACPRequestError(error);
+        }
+    }
+    async buildACPProbeDiagnosticRows(options = {}) {
+        const rows = [];
+        const phaseTimeoutMs = options.phaseTimeoutMs ?? ACP_DIAGNOSTIC_PHASE_TIMEOUT_MS;
+        const cwd = options.cwd ?? homedir();
+        let transport = null;
+        let initialize = null;
+        let probeSessionId = null;
+        try {
+            const spawnStartedAt = Date.now();
+            try {
+                transport = await this.spawnTransport(PROBE_ENV);
+                await withTimeout(Promise.race([transport.spawnReady, transport.spawnError]), phaseTimeoutMs, `ACP spawn timed out after ${phaseTimeoutMs}ms`);
+                rows.push({
+                    label: "ACP spawn",
+                    value: `ok (${formatDurationMs(spawnStartedAt)})`,
+                });
+            }
+            catch (error) {
+                rows.push({
+                    label: "ACP spawn",
+                    value: `error: ${toDiagnosticErrorMessage(error)}`,
+                });
+                return rows;
+            }
+            const activeTransport = transport;
+            const initializeStartedAt = Date.now();
+            try {
+                initialize = await this.initializeTransport(activeTransport, phaseTimeoutMs);
+                rows.push({
+                    label: "ACP initialize",
+                    value: `ok (${formatDurationMs(initializeStartedAt)})`,
+                });
+            }
+            catch (error) {
+                rows.push({
+                    label: "ACP initialize",
+                    value: `error: ${toDiagnosticErrorMessage(error)}`,
+                });
+                pushACPStderrRow(rows, activeTransport.stderrChunks);
+                return rows;
+            }
+            const sessionStartedAt = Date.now();
+            try {
+                const response = await withTimeout(this.runACPRequest(() => activeTransport.connection.newSession({
+                    cwd,
+                    mcpServers: [],
+                })), phaseTimeoutMs, `ACP session/new timed out after ${phaseTimeoutMs}ms`);
+                probeSessionId = response.sessionId;
+                const transformed = this.transformSessionResponse(response);
+                const models = deriveModelDefinitionsFromACP(this.provider, transformed.models, transformed.configOptions);
+                const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, transformed.configOptions);
+                rows.push({
+                    label: "ACP session/new",
+                    value: `ok (${formatDurationMs(sessionStartedAt)}; models=${models.length}; modes=${modeInfo.modes.length})`,
+                });
+            }
+            catch (error) {
+                rows.push({
+                    label: "ACP session/new",
+                    value: `error: ${toDiagnosticErrorMessage(error)}`,
+                });
+                pushACPStderrRow(rows, activeTransport.stderrChunks);
+                return rows;
+            }
+            pushACPStderrRow(rows, activeTransport.stderrChunks);
+            return rows;
+        }
+        finally {
+            if (transport) {
+                const cleanupStartedAt = Date.now();
+                try {
+                    await this.closeProbe({
+                        child: transport.child,
+                        connection: transport.connection,
+                        stderrChunks: transport.stderrChunks,
+                        ...(initialize ? { initialize } : {}),
+                    }, probeSessionId);
+                    rows.push({
+                        label: "ACP cleanup",
+                        value: `ok (${formatDurationMs(cleanupStartedAt)})`,
+                    });
+                }
+                catch (error) {
+                    rows.push({
+                        label: "ACP cleanup",
+                        value: `error: ${toDiagnosticErrorMessage(error)}`,
+                    });
+                }
+            }
+        }
+    }
+    async resolveLaunchCommand() {
+        const prefix = await resolveProviderLaunch({
+            commandConfig: this.runtimeSettings?.command,
+            defaultBinary: this.defaultCommand[0],
+        });
+        const availability = await checkProviderLaunchAvailable(prefix);
+        if (!availability.available) {
+            throw new Error(`${this.provider} command '${this.defaultCommand[0]}' not found`);
+        }
+        return {
+            command: prefix.command,
+            args: [...prefix.args, ...this.defaultCommand.slice(1)],
+        };
+    }
+    assertProvider(config) {
+        if (config.provider !== this.provider) {
+            throw new Error(`Expected ${this.provider} config, received ${config.provider}`);
+        }
+    }
+    transformSessionResponse(response) {
+        const transformed = this.sessionResponseTransformer
+            ? this.sessionResponseTransformer(response)
+            : response;
+        if (!this.configOptionsTransformer || !transformed.configOptions) {
+            return transformed;
+        }
+        return {
+            ...transformed,
+            configOptions: this.configOptionsTransformer(transformed.configOptions),
+        };
+    }
+}
+/**
+ * Fail-closed ceiling on how long a staged replacement may wait for the stop
+ * boundary in front of it. Follows the OpenCode pending-abort deadline: it
+ * bounds the caller's wait, it never manufactures provider readiness. Expiry
+ * rejects only the queued replacement and leaves the session stopping.
+ */
+export const ACP_STOPPED_TURN_ADMISSION_TIMEOUT_MS = 10000;
+const ACP_FOREGROUND_ACTIVE_ERROR = "A foreground turn is already active";
+function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+export class ACPAgentSession {
+    constructor(config, options) {
+        this.subscribers = new Set();
+        this.pendingPermissions = new Map();
+        this.pendingUserMessage = null;
+        this.submittedUserMessageTurnId = null;
+        this.toolCalls = new Map();
+        this.terminalEntries = new Map();
+        this.persistedHistory = [];
+        this.child = null;
+        this.connection = null;
+        this.agentCapabilities = null;
+        this.sessionId = null;
+        this.currentMode = null;
+        this.currentModel = null;
+        this.availableModels = null;
+        this.thinkingOptionId = null;
+        this.currentTitle = null;
+        this.lastActivityAt = null;
+        this.configOptions = [];
+        this.cachedCommands = [];
+        this.commandsReadyDeferred = null;
+        this.commandsReadySettled = false;
+        this.activeForegroundTurnId = null;
+        /**
+         * Foreground admission state and the stop boundary in front of it. See
+         * {@link ACPAdmissionState} for the phases and their transitions. Both move
+         * only inside synchronous sections: a reservation is never split across an
+         * `await`, so no event, echo, turn id, or prompt can escape before ownership
+         * is taken.
+         */
+        this.admissionState = "idle";
+        this.stop = null;
+        this.connectionRevision = 0;
+        this.connectionDeathSignal = null;
+        this.fallbackAssistantMessageId = null;
+        this.closed = false;
+        this.historyPending = false;
+        this.replayingHistory = false;
+        this.bootstrapThreadEventPending = false;
+        this.provider = options.provider;
+        this.terminateProcess = options.terminateProcess ?? terminateWithTreeKill;
+        this.capabilities = options.capabilities;
+        this.logger = options.logger.child({ module: "agent", provider: options.provider });
+        this.runtimeSettings = options.runtimeSettings;
+        this.defaultCommand = options.defaultCommand;
+        this.defaultModes = options.defaultModes;
+        this.modelTransformer = options.modelTransformer;
+        this.sessionResponseTransformer = options.sessionResponseTransformer;
+        this.configOptionsTransformer = options.configOptionsTransformer;
+        this.configFeatureOptions = options.configFeatureOptions ?? [];
+        this.clientCapabilities = options.clientCapabilities;
+        this.clientCapabilityMeta = options.clientCapabilityMeta;
+        this.modeIdTransformer = options.modeIdTransformer;
+        this.toolSnapshotTransformer = options.toolSnapshotTransformer;
+        this.providerModeWriter = options.providerModeWriter;
+        this.beforeModeWriter = options.beforeModeWriter;
+        this.thinkingOptionWriter = options.thinkingOptionWriter;
+        this.availableModes = options.defaultModes;
+        this.agentId = options.agentId;
+        this.launchEnv = options.launchEnv;
+        this.initialHandle = options.handle;
+        this.config = { ...config, provider: options.provider };
+        this.currentMode = config.modeId ?? null;
+        this.currentModel = config.model ?? null;
+        this.thinkingOptionId = config.thinkingOptionId ?? null;
+        this.currentTitle = config.title ?? null;
+        this.waitForInitialCommands = options.waitForInitialCommands ?? false;
+        this.initialCommandsWaitTimeoutMs = options.initialCommandsWaitTimeoutMs ?? 1500;
+        this.extensionCommandsParser = options.extensionCommandsParser;
+    }
+    // ── Provider-neutral extension seams ────────────────────────────────────
+    // A provider subclass builds on this session without reaching into private
+    // state. Everything below is read-only unless named explicitly; none of it
+    // hands out the mutable connection, environment, or stop internals in a way
+    // that would let a subclass bypass the admission boundary.
+    getAcpSessionId() {
+        return this.sessionId;
+    }
+    getAcpConnection() {
+        return this.connection;
+    }
+    getForegroundTurnId() {
+        return this.activeForegroundTurnId;
+    }
+    getAdmissionState() {
+        return this.admissionState;
+    }
+    getCurrentStop() {
+        return this.stop;
+    }
+    /** One-key read-only view of the launch environment. Never exposes the object. */
+    getLaunchEnv(name) {
+        return this.launchEnv?.[name];
+    }
+    get id() {
+        return this.sessionId;
+    }
+    async initializeNewSession() {
+        try {
+            const spawned = await this.spawnProcess();
+            this.child = spawned.child;
+            this.connection = spawned.connection;
+            this.agentCapabilities = spawned.initialize.agentCapabilities ?? null;
+            const response = await this.runACPRequest(() => this.connection.newSession({
+                cwd: this.config.cwd,
+                mcpServers: this.acpMcpServers(),
+            }));
+            this.sessionId = response.sessionId;
+            this.bootstrapThreadEventPending = true;
+            this.applySessionState(response);
+            await this.applyConfiguredOverrides();
+        }
+        catch (error) {
+            await this.closeAfterInitializationFailure(error);
+        }
+    }
+    /**
+     * IMPORTANT: Some ACP providers (e.g., Devin CLI) require all three params
+     * (sessionId, cwd, mcpServers) to be present in session/load or
+     * unstable_resumeSession — even when mcpServers is an empty array — and
+     * return "Invalid params" if any are omitted. Never drop cwd or mcpServers
+     * from these calls regardless of capabilities.
+     */
+    async initializeResumedSession() {
+        try {
+            const handle = this.initialHandle;
+            if (!handle) {
+                throw new Error("Resume requested without persistence handle");
+            }
+            const spawned = await this.spawnProcess();
+            this.child = spawned.child;
+            this.connection = spawned.connection;
+            this.agentCapabilities = spawned.initialize.agentCapabilities ?? null;
+            this.sessionId = handle.sessionId;
+            this.bootstrapThreadEventPending = true;
+            const sessionCapabilities = this.agentCapabilities?.sessionCapabilities;
+            if (this.agentCapabilities?.loadSession) {
+                this.replayingHistory = true;
+                const response = await this.runACPRequest(() => this.connection.loadSession({
+                    sessionId: handle.sessionId,
+                    cwd: this.config.cwd,
+                    mcpServers: this.acpMcpServers(),
+                }));
+                this.deliverTranslatedEvents(this.flushPendingUserMessage());
+                this.replayingHistory = false;
+                this.historyPending = this.persistedHistory.length > 0;
+                this.applySessionState(response);
+            }
+            else if (sessionCapabilities?.resume) {
+                const response = await this.runACPRequest(() => this.connection.unstable_resumeSession({
+                    sessionId: handle.sessionId,
+                    cwd: this.config.cwd,
+                    mcpServers: this.acpMcpServers(),
+                }));
+                this.applySessionState(response);
+            }
+            else {
+                throw new Error(`${this.provider} does not support ACP session resume`);
+            }
+            await this.applyConfiguredOverrides();
+        }
+        catch (error) {
+            await this.closeAfterInitializationFailure(error);
+        }
+    }
+    async closeAfterInitializationFailure(error) {
+        try {
+            await this.close();
+        }
+        catch (closeError) {
+            this.logger.warn({ err: closeError, initializationError: error }, "Failed to close ACP process after session initialization failure");
+        }
+        throw error;
+    }
+    async run(prompt, options) {
+        const result = await runProviderTurn({
+            prompt,
+            runOptions: options,
+            startTurn: (p, o) => this.startTurn(p, o),
+            subscribe: (callback) => this.subscribe(callback),
+            getSessionId: () => this.sessionId ?? "",
+            reduceFinalText: appendOrReplaceGrowingAssistantMessage,
+        });
+        if (!this.sessionId) {
+            throw new Error("ACP session did not expose a session id");
+        }
+        return result;
+    }
+    async startTurn(prompt, options) {
+        return this.startTurnWithAdmission(prompt, options);
+    }
+    /**
+     * The single admission path for every foreground prompt, ordinary or staged
+     * behind a stop.
+     *
+     * 1. A call that arrives while a stop is installed becomes that stop's staged
+     *    successor — at most one per stop; a second concurrent call throws the
+     *    foreground-active error instead of displacing the first.
+     * 2. It then waits for the stop's gates (authoritative terminal, settled and
+     *    successful cancellation writes, provider proof) inside
+     *    {@link ACP_STOPPED_TURN_ADMISSION_TIMEOUT_MS}. The deadline rejects only
+     *    this waiter; it never sends a prompt and never opens readiness.
+     * 3. {@link reserveForegroundSlot} rechecks every fact and reserves the
+     *    foreground slot with no `await` in between.
+     * 4. Only after the reservation are the turn id and the start-side effects
+     *    produced, in the order ACP always used them.
+     */
+    async startTurnWithAdmission(prompt, options) {
+        if (this.closed) {
+            throw new Error(`${this.provider} session is closed`);
+        }
+        if (!this.connection || !this.sessionId) {
+            throw new Error(`${this.provider} session is not initialized`);
+        }
+        const staging = this.stageAdmission();
+        if (staging.kind === "queued") {
+            // Rejects on invalidation, deadline expiry, or close; resolves only when
+            // the stop's gates are satisfied. The reservation rechecks everything.
+            await staging.release.promise;
+        }
+        // ── Synchronous commit section ────────────────────────────────────────
+        // No `await` may appear between the checks in reserveForegroundSlot and the
+        // reservation it performs, and no successor side effect may run before it.
+        const detachedStop = this.reserveForegroundSlot(staging);
+        let turnId = null;
+        try {
+            this.deliverTranslatedEvents(this.flushPendingUserMessage());
+            turnId = randomUUID();
+            const foregroundTurnId = turnId;
+            const messageId = options?.clientMessageId ?? randomUUID();
+            this.activeForegroundTurnId = foregroundTurnId;
+            this.fallbackAssistantMessageId = null;
+            this.submittedUserMessageTurnId = null;
+            this.emitBootstrapThreadEvent();
+            this.pushEvent({ type: "turn_started", provider: this.provider, turnId: foregroundTurnId });
+            this.emitSubmittedUserMessage(prompt, messageId, foregroundTurnId, options?.clientMessageId);
+            // reserved → running happens before the prompt write: from this line the
+            // foreground slot belongs to `foregroundTurnId` for admission purposes.
+            this.admissionState = "running";
+            const connection = this.connection;
+            const sessionId = this.sessionId;
+            void connection
+                .prompt({
+                sessionId,
+                messageId,
+                prompt: toACPContentBlocks(prompt),
+            })
+                .then((response) => {
+                this.handlePromptResponse(response, foregroundTurnId);
+                return;
+            })
+                .catch((error) => {
+                const summary = summarizeACPRequestError(error);
+                this.finishTurn(foregroundTurnId, {
+                    type: "turn_failed",
+                    provider: this.provider,
+                    error: summary.message,
+                    code: summary.code,
+                    diagnostic: this.collectDiagnostic(summary.diagnostic ?? summary.message),
+                    turnId: foregroundTurnId,
+                });
+            });
+        }
+        catch (error) {
+            // Roll back only this reservation. A stop that was in front of it keeps
+            // every fact it earned; it is never reopened by a failed send.
+            this.rollbackReservation(detachedStop, turnId);
+            throw error;
+        }
+        return { turnId };
+    }
+    /**
+     * Registers the caller as a stop's sole staged successor. A call with no stop
+     * in front of it commits immediately; a call while the foreground slot is held
+     * throws, exactly as it always has.
+     */
+    stageAdmission() {
+        const stop = this.stop;
+        if (!stop) {
+            if (this.admissionState !== "idle") {
+                throw new Error(ACP_FOREGROUND_ACTIVE_ERROR);
+            }
+            return { kind: "immediate" };
+        }
+        if (stop.stagedSuccessor) {
+            throw new Error(ACP_FOREGROUND_ACTIVE_ERROR);
+        }
+        const token = randomUUID();
+        const release = createDeferred();
+        const staged = {
+            token,
+            release,
+            deadline: setTimeout(() => this.expireStagedSuccessor(stop, token), ACP_STOPPED_TURN_ADMISSION_TIMEOUT_MS),
+        };
+        stop.stagedSuccessor = staged;
+        // Newest-wins across the one-microtask window between gate release and
+        // reserveForegroundSlot: staging a new successor clears the released token,
+        // so a released-but-uncommitted caller loses the slot and throws the
+        // foreground-active error. Exactly one caller ever commits.
+        stop.releasedSuccessorToken = null;
+        this.logger.info({
+            stopId: stop.stopId,
+            stoppedTurnId: stop.stoppedTurnId,
+            token,
+            kind: stop.kind,
+            sessionId: stop.sessionId,
+            timeoutMs: ACP_STOPPED_TURN_ADMISSION_TIMEOUT_MS,
+        }, "provider.acp.successor_staged");
+        // The stop's facts may already be complete, in which case the waiter is
+        // released before the first await and the commit recheck decides.
+        this.evaluateStopGate(stop);
+        return { kind: "queued", stop, token, release };
+    }
+    /**
+     * Deadline expiry rejects the queued replacement and nothing else: no prompt,
+     * no turn event, no user echo, no turn id. The stop stays installed, so a
+     * later request can still be evaluated on its own facts.
+     */
+    expireStagedSuccessor(stop, token) {
+        if (this.stop !== stop) {
+            return;
+        }
+        const staged = stop.stagedSuccessor;
+        if (!staged || staged.token !== token) {
+            return;
+        }
+        const unresolved = {
+            terminal: !stop.terminalObserved,
+            cancelWrites: !this.isCancelLedgerSatisfied(stop),
+            providerGate: !this.isProviderStopGateSatisfied(stop),
+            providerGateFacts: this.describeProviderStopGate(stop),
+        };
+        this.takeStagedSuccessor(stop);
+        this.logger.info({
+            stopId: stop.stopId,
+            token,
+            stoppedTurnId: stop.stoppedTurnId,
+            timeoutMs: ACP_STOPPED_TURN_ADMISSION_TIMEOUT_MS,
+            unresolved,
+        }, "provider.acp.admission_deadline");
+        staged.release.reject(new Error(`${this.provider} replacement turn was not admitted within ${ACP_STOPPED_TURN_ADMISSION_TIMEOUT_MS}ms; the previous turn is still being stopped`));
+    }
+    /**
+     * Detaches and disarms the stop's staged successor, clearing the deadline and
+     * the token slot together. This is the whole of successor cleanup, so close and
+     * supersession can call it without touching stop state.
+     */
+    takeStagedSuccessor(stop) {
+        const staged = stop.stagedSuccessor;
+        if (!staged) {
+            return null;
+        }
+        stop.stagedSuccessor = null;
+        stop.releasedSuccessorToken = null;
+        clearTimeout(staged.deadline);
+        return staged;
+    }
+    /** Invalidates the queued replacement without touching the stop identity. */
+    invalidateStagedSuccessor(stop, reason) {
+        const staged = this.takeStagedSuccessor(stop);
+        if (!staged) {
+            return;
+        }
+        this.logger.info({ stopId: stop.stopId, token: staged.token, reason, stoppedTurnId: stop.stoppedTurnId }, "provider.acp.successor_invalidated");
+        staged.release.reject(new Error(`${this.provider} staged replacement was invalidated (${reason})`));
+    }
+    /**
+     * The one death path for the stop boundary, invoked by every way the session
+     * observes its process or transport died: the child exit handler, the
+     * connection close signal, and close. The SDK delivers `cancel()` as a
+     * notification whose write errors are swallowed, so on a dead pipe an
+     * undelivered cancel resolves as a settled success — death therefore settles
+     * EVERY attempt, including recorded successes, as rejected, records provider
+     * death proof, and rejects the staged successor immediately instead of
+     * leaving it to the admission deadline. Idempotent: the first observation
+     * wins and later ones (a signal abort after the exit handler, or close) are
+     * no-ops. Gated on the stop's captured identity, so a stop captured on an
+     * older connection stays untouched.
+     */
+    settleStopOnObservedDeath(reason) {
+        const stop = this.stop;
+        if (!stop || stop.deathSettled || !this.stopIdentityMatches(stop)) {
+            return;
+        }
+        stop.deathSettled = true;
+        for (const attempt of stop.cancelAttempts) {
+            attempt.settled = true;
+            attempt.outcome = "rejected";
+        }
+        stop.cancelSettledRevision = Math.max(stop.cancelSettledRevision, stop.cancelIssuedRevision);
+        stop.newestCancelSucceeded = false;
+        this.logger.info({
+            stopId: stop.stopId,
+            stoppedTurnId: stop.stoppedTurnId,
+            attempts: stop.cancelAttempts.length,
+            reason,
+        }, "provider.acp.stop_death_settled");
+        this.recordProviderStopDeath(stop, reason);
+        this.invalidateStagedSuccessor(stop, reason);
+    }
+    /**
+     * Opens the staged successor only when every fact the stop owes is present:
+     * the session identity it captured, terminal proof for the turn it stopped, a
+     * fully settled and successful cancellation ledger, and provider proof. Any
+     * gap keeps the session stopping — nothing infers readiness here.
+     */
+    evaluateStopGate(stop) {
+        if (this.closed || this.stop !== stop || !this.stopIdentityMatches(stop)) {
+            return;
+        }
+        if (!stop.terminalObserved || !this.isCancelLedgerSatisfied(stop)) {
+            return;
+        }
+        if (!this.isProviderStopGateSatisfied(stop)) {
+            return;
+        }
+        const staged = this.takeStagedSuccessor(stop);
+        if (!staged) {
+            return;
+        }
+        stop.releasedSuccessorToken = staged.token;
+        this.logger.info({
+            stopId: stop.stopId,
+            token: staged.token,
+            stoppedTurnId: stop.stoppedTurnId,
+            satisfiedGates: ["terminal", "cancelWrites", "providerGate"],
+        }, "provider.acp.admission_released");
+        staged.release.resolve();
+    }
+    /**
+     * The cancellation ledger: every cancellation write issued for the stop must
+     * have settled, and the newest must have succeeded. An older rejected write is
+     * recovered only by a newer successful one after everything has settled, so no
+     * unresolved write can trail behind a committed successor. A stop that never
+     * issued a write owes the ledger nothing — foreground stops always issue their
+     * first write synchronously after install, and a write that throws before it is
+     * sent is recorded as rejected.
+     */
+    isCancelLedgerSatisfied(stop) {
+        if (stop.cancelAttempts.length === 0) {
+            return true;
+        }
+        const newest = stop.cancelAttempts[stop.cancelAttempts.length - 1];
+        return (newest.revision === stop.cancelIssuedRevision &&
+            stop.cancelAttempts.every((attempt) => attempt.settled) &&
+            newest.outcome === "success");
+    }
+    /** The stop's captured identity must still be the live one. */
+    stopIdentityMatches(stop) {
+        return (this.connection === stop.connection &&
+            this.connectionRevision === stop.connectionRevision &&
+            this.sessionId === stop.sessionId);
+    }
+    /**
+     * Reserves the foreground slot. Every check re-verifies a fact the release
+     * already proved; any mismatch fails closed and leaves the stop installed.
+     */
+    reserveForegroundSlot(staging) {
+        if (this.closed) {
+            throw new Error(`${this.provider} session is closed`);
+        }
+        if (!this.connection || !this.sessionId) {
+            throw new Error(`${this.provider} session is not initialized`);
+        }
+        const stop = this.stop;
+        if (stop) {
+            if (staging.kind !== "queued" || stop.releasedSuccessorToken !== staging.token) {
+                throw new Error(ACP_FOREGROUND_ACTIVE_ERROR);
+            }
+            if (stop.stagedSuccessor) {
+                throw new Error(ACP_FOREGROUND_ACTIVE_ERROR);
+            }
+            if (!this.stopIdentityMatches(stop)) {
+                throw new Error(`${this.provider} session identity changed while a stop boundary was installed`);
+            }
+            if (!stop.terminalObserved) {
+                throw new Error(`${this.provider} stop boundary is missing terminal proof`);
+            }
+            if (!this.isCancelLedgerSatisfied(stop)) {
+                throw new Error(`${this.provider} stop boundary still has unresolved cancellation writes`);
+            }
+            if (!this.isProviderStopGateSatisfied(stop)) {
+                throw new Error(`${this.provider} stop boundary is missing provider stop proof`);
+            }
+            this.stop = null;
+            this.admissionState = "reserved";
+            return stop;
+        }
+        if (this.admissionState !== "idle") {
+            throw new Error(ACP_FOREGROUND_ACTIVE_ERROR);
+        }
+        this.admissionState = "reserved";
+        return null;
+    }
+    rollbackReservation(stop, turnId) {
+        if (this.activeForegroundTurnId && this.activeForegroundTurnId === turnId) {
+            this.activeForegroundTurnId = null;
+        }
+        if (stop) {
+            this.stop = stop;
+            this.admissionState = "stopping";
+            return;
+        }
+        this.admissionState = "idle";
+    }
+    /**
+     * Installs a stop boundary. Must run synchronously before the first
+     * cancellation write it is followed by, so admission closes before any
+     * asynchronous cancellation work begins.
+     */
+    installStop(input) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error(`${this.provider} session is not initialized`);
+        }
+        const stop = {
+            stopId: randomUUID(),
+            stoppedTurnId: input.stoppedTurnId,
+            sessionId: this.sessionId,
+            connection: this.connection,
+            connectionRevision: this.connectionRevision,
+            kind: input.kind,
+            terminalObserved: false,
+            terminalDelivered: false,
+            cancelAttempts: [],
+            cancelIssuedRevision: 0,
+            cancelSettledRevision: 0,
+            newestCancelSucceeded: false,
+            deathSettled: false,
+            stagedSuccessor: null,
+            releasedSuccessorToken: null,
+            providerGateSatisfied: true,
+        };
+        this.stop = stop;
+        this.admissionState = "stopping";
+        this.logger.info({
+            stopId: stop.stopId,
+            stoppedTurnId: stop.stoppedTurnId,
+            kind: stop.kind,
+            reason: input.reason,
+            sessionId: stop.sessionId,
+            connectionRevision: stop.connectionRevision,
+        }, "provider.acp.stop_installed");
+        return stop;
+    }
+    /**
+     * The one foreground stop operation. Interrupt, permission denial, and a
+     * repeated Stop all land here: it installs the boundary, or reuses the one
+     * installed, and returns when the cancellation write it issued settles.
+     * Settling a write proves transport completion only — the stop stays installed
+     * until terminal proof and a fully settled ledger arrive.
+     *
+     * With no stop-able turn the cancellation write is suppressed entirely (AC13):
+     * no stop is installed and admission state is untouched. A denial caller
+     * passes `correlation`, and the suppression logs
+     * `provider.acp.deny_cancel_suppressed` with a `reason` that separates the
+     * not-initialized session from the no-active-turn case — review finding 3.
+     */
+    async stopForegroundTurn(input) {
+        if (this.closed) {
+            return;
+        }
+        const existing = this.stop;
+        if (existing) {
+            // Repeated Stop keeps stop identity and retries the same stop: the queued
+            // successor is invalidated and a fresh attempt revision is issued.
+            this.invalidateStagedSuccessor(existing, input.reason);
+            await this.issueCancelWrite(existing);
+            return;
+        }
+        const turnId = this.activeForegroundTurnId;
+        if (!turnId || !this.connection || !this.sessionId) {
+            // Deliberate delta from pre-stop-boundary behavior (AC13): a permission
+            // denial arriving with no foreground turn and no installed stop sends no
+            // cancellation. An untracked session-scoped cancel write is exactly what
+            // the ledger exists to prevent. The suppressed write is still a fact
+            // worth seeing: one event, with the deny correlation and a reason that
+            // distinguishes an uninitialized session from a session with no
+            // stop-able turn.
+            if (input.correlation) {
+                this.logger.info({
+                    permissionRequestId: input.correlation.permissionRequestId,
+                    ...(input.correlation.turnId ? { turnId: input.correlation.turnId } : {}),
+                    ...(this.sessionId ? { sessionId: this.sessionId } : {}),
+                    reason: this.connection && this.sessionId ? "no_active_turn" : "session_not_initialized",
+                }, "provider.acp.deny_cancel_suppressed");
+            }
+            return;
+        }
+        const stop = this.installStop({
+            kind: "foreground",
+            stoppedTurnId: turnId,
+            reason: input.reason,
+        });
+        await this.issueCancelWrite(stop);
+    }
+    /**
+     * Issues one cancellation write on the connection the stop captured and tracks
+     * its promise in that stop's ledger. A write that rejects — or throws before it
+     * is sent — is recorded as rejected, which keeps the boundary closed.
+     */
+    issueCancelWrite(stop) {
+        if (!this.stopIdentityMatches(stop)) {
+            return Promise.reject(new Error(`${this.provider} cannot cancel a stopped turn on a replaced session or connection`));
+        }
+        const revision = stop.cancelIssuedRevision + 1;
+        stop.cancelIssuedRevision = revision;
+        const attempt = { revision, settled: false, outcome: "pending" };
+        stop.cancelAttempts.push(attempt);
+        this.logger.info({ stopId: stop.stopId, revision, sessionId: stop.sessionId }, "provider.acp.cancel_attempt_started");
+        let write;
+        try {
+            write = stop.connection.cancel({ sessionId: stop.sessionId }).then(() => {
+                this.settleCancelAttempt(stop, attempt, "success");
+                return undefined;
+            }, (error) => {
+                this.settleCancelAttempt(stop, attempt, "rejected");
+                throw error;
+            });
+        }
+        catch (error) {
+            this.settleCancelAttempt(stop, attempt, "rejected");
+            throw error;
+        }
+        return write;
+    }
+    settleCancelAttempt(stop, attempt, outcome) {
+        if (stop.deathSettled) {
+            // Death closed this ledger; a resolution that lands after the transport
+            // died is not delivery proof and cannot reopen the boundary.
+            return;
+        }
+        attempt.settled = true;
+        attempt.outcome = outcome;
+        stop.cancelSettledRevision = Math.max(stop.cancelSettledRevision, attempt.revision);
+        const newest = stop.cancelAttempts[stop.cancelAttempts.length - 1];
+        stop.newestCancelSucceeded = newest.settled && newest.outcome === "success";
+        this.logger.info({ stopId: stop.stopId, revision: attempt.revision, outcome }, "provider.acp.cancel_attempt_settled");
+        // A rejected newest write keeps the session stopping; only a newer
+        // successful retry on the same connection can recover it.
+        this.evaluateStopGate(stop);
+    }
+    /** Provider-specific stop proof. The generic boundary needs none of it. */
+    isProviderStopGateSatisfied(stop) {
+        return stop.providerGateSatisfied;
+    }
+    /** Records provider stop proof and re-evaluates admission. */
+    markProviderStopGateSatisfied(stop) {
+        stop.providerGateSatisfied = true;
+        this.evaluateStopGate(stop);
+    }
+    /**
+     * Names the provider facts a stop is still waiting on, empty once the gate is
+     * satisfied. The generic boundary has one opaque gate; a provider subclass
+     * overrides this so an admission deadline names what it is missing instead of
+     * only reporting a boolean.
+     */
+    describeProviderStopGate(stop) {
+        return this.isProviderStopGateSatisfied(stop) ? [] : ["provider_gate"];
+    }
+    /**
+     * Provider-specific proof for a stop settled by the death path, recorded
+     * after the ledger is closed and before the staged successor is rejected.
+     * The generic boundary records none; a subclass records what its own stop
+     * gate still owes (a GJC ownerless abort settles its pending attempt as a
+     * reject so the gate names the real reason).
+     */
+    recordProviderStopDeath(stop, reason) {
+        void stop;
+        void reason;
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        if (this.sessionId) {
+            callback({
+                type: "thread_started",
+                provider: this.provider,
+                sessionId: this.sessionId,
+            });
+        }
+        return () => {
+            this.subscribers.delete(callback);
+        };
+    }
+    async *streamHistory() {
+        if (!this.historyPending || this.persistedHistory.length === 0) {
+            return;
+        }
+        const history = [...this.persistedHistory];
+        this.persistedHistory.length = 0;
+        this.historyPending = false;
+        for (const item of history) {
+            yield { type: "timeline", provider: this.provider, item };
+        }
+    }
+    async getRuntimeInfo() {
+        return this.runtimeInfo();
+    }
+    async getAvailableModes() {
+        return [...this.availableModes];
+    }
+    async getCurrentMode() {
+        return this.currentMode;
+    }
+    get features() {
+        return [
+            buildACPAutoAcceptFeature(this.config),
+            ...deriveFeaturesFromACP(this.configOptions, this.configFeatureOptions),
+        ];
+    }
+    ensureCommandsReadyDeferred() {
+        if (this.commandsReadyDeferred || this.commandsReadySettled || this.cachedCommands.length > 0) {
+            return;
+        }
+        let resolve;
+        const promise = new Promise((r) => {
+            resolve = r;
+        });
+        this.commandsReadyDeferred = { promise, resolve };
+    }
+    settleCommandsReady() {
+        if (this.commandsReadySettled) {
+            return;
+        }
+        this.commandsReadySettled = true;
+        this.commandsReadyDeferred?.resolve();
+        this.commandsReadyDeferred = null;
+    }
+    async waitForCommandsReady() {
+        const deferred = this.commandsReadyDeferred;
+        if (!deferred) {
+            return;
+        }
+        let timer = null;
+        try {
+            await Promise.race([
+                deferred.promise,
+                new Promise((resolve) => {
+                    timer = setTimeout(resolve, this.initialCommandsWaitTimeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timer) {
+                clearTimeout(timer);
+            }
+        }
+    }
+    async listCommands() {
+        if (this.cachedCommands.length > 0) {
+            return this.cachedCommands;
+        }
+        if (!this.waitForInitialCommands || this.closed) {
+            return this.cachedCommands;
+        }
+        this.ensureCommandsReadyDeferred();
+        await this.waitForCommandsReady();
+        this.settleCommandsReady();
+        return this.cachedCommands;
+    }
+    async setMode(modeId) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
+        }
+        const selection = resolveACPModeSelection({
+            modeId,
+            availableModes: this.availableModes,
+            configOptions: this.configOptions,
+        });
+        await this.setModeWithSelection({ modeId, selection });
+    }
+    // Mode/model selection updates stay after ACP RPC success; this intentionally diverges from Zed's optimistic rollback path (acp.rs:3080-3104).
+    async setModeWithSelection({ modeId, selection, }) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
+        }
+        const context = this.createProviderModeWriterContext(modeId, selection);
+        const providerResult = this.providerModeWriter
+            ? await this.providerModeWriter(context)
+            : { handled: false };
+        if (providerResult.handled) {
+            this.currentMode = providerResult.currentModeId ?? modeId;
+            if (providerResult.configOptions) {
+                this.configOptions = this.transformConfigOptions(providerResult.configOptions);
+            }
+            this.availableModes = deriveModesFromACP(this.defaultModes, null, this.configOptions).modes;
+            this.pushEvent({
+                type: "mode_changed",
+                provider: this.provider,
+                currentModeId: this.currentMode,
+                availableModes: [...this.availableModes],
+            });
+            return;
+        }
+        if (selection.hasAvailableModes) {
+            if (!selection.availableMode) {
+                this.warnInvalidSelection(modeId, `is not valid ${this.provider} mode. Available options: ${this.availableModes
+                    .map((mode) => mode.id)
+                    .join(", ")}`);
+                return;
+            }
+        }
+        else {
+            const modeOption = selection.configOption;
+            if (!modeOption) {
+                throw new Error(`${this.provider} does not expose ACP mode switching`);
+            }
+            if (!selection.configChoice) {
+                this.warnInvalidSelection(modeId, `is not valid ${this.provider} mode config option. Available options: ${flattenSelectOptions(modeOption.options)
+                    .map((option) => option.value)
+                    .join(", ")}`);
+                return;
+            }
+        }
+        if (this.beforeModeWriter) {
+            const beforeResult = await this.beforeModeWriter(context);
+            if (beforeResult?.configOptions) {
+                this.configOptions = this.transformConfigOptions(beforeResult.configOptions);
+            }
+        }
+        if (selection.hasAvailableModes) {
+            await this.connection.setSessionMode({ sessionId: this.sessionId, modeId });
+            this.currentMode = modeId;
+            this.pushEvent({
+                type: "mode_changed",
+                provider: this.provider,
+                currentModeId: this.currentMode,
+                availableModes: [...this.availableModes],
+            });
+            return;
+        }
+        const modeOption = selection.configOption;
+        if (!modeOption) {
+            throw new Error(`${this.provider} does not expose ACP mode switching`);
+        }
+        const response = await this.connection.setSessionConfigOption({
+            sessionId: this.sessionId,
+            configId: modeOption.id,
+            value: modeId,
+        });
+        this.currentMode = this.applyConfigOptionResponse({
+            response,
+            configId: modeOption.id,
+            category: "mode",
+            requestedValue: modeId,
+            label: "mode",
+        });
+        this.availableModes = deriveModesFromACP(this.defaultModes, null, this.configOptions).modes;
+        this.pushEvent({
+            type: "mode_changed",
+            provider: this.provider,
+            currentModeId: this.currentMode,
+            availableModes: [...this.availableModes],
+        });
+    }
+    createProviderModeWriterContext(requestedModeId, selection) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
+        }
+        return {
+            connection: this.connection,
+            sessionId: this.sessionId,
+            requestedModeId,
+            currentModeId: this.currentMode,
+            selection,
+            configOptions: this.configOptions,
+            logger: this.logger,
+        };
+    }
+    async setModel(modelId) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
+        }
+        if (!modelId) {
+            this.currentModel = null;
+            return;
+        }
+        const selection = resolveACPModelSelection({
+            modelId,
+            availableModels: this.availableModels,
+            configOptions: this.configOptions,
+        });
+        await this.setModelWithSelection({ modelId, selection });
+    }
+    async setModelWithSelection({ modelId, selection, }) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
+        }
+        if (selection.hasAvailableModels) {
+            if (!selection.availableModel) {
+                this.warnInvalidSelection(modelId, `is not a valid ${this.provider} model. Available options: ${this.availableModels
+                    ?.map((model) => model.modelId)
+                    .join(", ")}`);
+                return;
+            }
+            if (typeof this.connection.unstable_setSessionModel !== "function") {
+                throw new Error(this.modelSelectionUnavailableMessage());
+            }
+            try {
+                await this.connection.unstable_setSessionModel({
+                    sessionId: this.sessionId,
+                    modelId,
+                });
+                this.currentModel = modelId;
+                this.pushEvent({
+                    type: "model_changed",
+                    provider: this.provider,
+                    runtimeInfo: this.runtimeInfo(),
+                });
+                return;
+            }
+            catch {
+                // Fall through to config option path.
+            }
+        }
+        const modelOption = selection.configOption;
+        if (!modelOption) {
+            throw new Error(this.modelSelectionUnavailableMessage());
+        }
+        if (!selection.configChoice) {
+            this.warnInvalidSelection(modelId, `is not a valid ${this.provider} model config option. Available options: ${flattenSelectOptions(modelOption.options)
+                .map((option) => option.value)
+                .join(", ")}`);
+            return;
+        }
+        const response = await this.connection.setSessionConfigOption({
+            sessionId: this.sessionId,
+            configId: modelOption.id,
+            value: modelId,
+        });
+        this.currentModel = this.applyConfigOptionResponse({
+            response,
+            configId: modelOption.id,
+            category: "model",
+            requestedValue: modelId,
+            label: "model",
+        });
+        this.pushEvent({
+            type: "model_changed",
+            provider: this.provider,
+            runtimeInfo: this.runtimeInfo(),
+        });
+    }
+    async setThinkingOption(thinkingOptionId) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
+        }
+        if (!thinkingOptionId) {
+            this.thinkingOptionId = null;
+            return;
+        }
+        if (this.thinkingOptionWriter) {
+            await this.thinkingOptionWriter(this.connection, this.sessionId, thinkingOptionId);
+            this.thinkingOptionId = thinkingOptionId;
+            this.pushEvent({
+                type: "thinking_option_changed",
+                provider: this.provider,
+                thinkingOptionId: this.thinkingOptionId,
+            });
+            return;
+        }
+        const option = findSelectConfigOption({
+            configOptions: this.configOptions,
+            category: "thought_level",
+        });
+        if (!option) {
+            throw new Error(`${this.provider} does not expose ACP thought-level selection`);
+        }
+        const response = await this.connection.setSessionConfigOption({
+            sessionId: this.sessionId,
+            configId: option.id,
+            value: thinkingOptionId,
+        });
+        this.thinkingOptionId = this.applyConfigOptionResponse({
+            response,
+            configId: option.id,
+            category: "thought_level",
+            requestedValue: thinkingOptionId,
+            label: "thought-level",
+        });
+        this.pushEvent({
+            type: "thinking_option_changed",
+            provider: this.provider,
+            thinkingOptionId: this.thinkingOptionId,
+        });
+    }
+    async setFeature(featureId, value) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
+        }
+        if (featureId === ACP_AUTO_ACCEPT_FEATURE_ID) {
+            this.config.featureValues = {
+                ...this.config.featureValues,
+                [ACP_AUTO_ACCEPT_FEATURE_ID]: value === true,
+            };
+            return;
+        }
+        const featureOption = this.configFeatureOptions.find((option) => option.id === featureId);
+        if (!featureOption) {
+            throw new Error(`Unknown ${this.provider} feature: ${featureId}`);
+        }
+        const option = findSelectConfigFeatureOption(this.configOptions, featureOption);
+        if (!option) {
+            throw new Error(`${this.provider} does not expose ACP feature '${featureId}'`);
+        }
+        const requestedValue = normalizeConfigFeatureValue(value);
+        const choice = findSelectConfigChoice({ option, value: requestedValue });
+        if (!choice) {
+            throw new Error(`${this.provider} feature '${featureId}' does not include option '${requestedValue}'`);
+        }
+        const response = await this.connection.setSessionConfigOption({
+            sessionId: this.sessionId,
+            configId: option.id,
+            value: requestedValue,
+        });
+        const currentValue = this.applyConfigOptionResponse({
+            response,
+            configId: option.id,
+            category: featureOption.category,
+            requestedValue,
+            label: featureOption.label,
+        });
+        this.config.featureValues = { ...this.config.featureValues, [featureId]: currentValue };
+    }
+    applyConfigOptionResponse({ response, configId, category, requestedValue, label, }) {
+        this.configOptions = this.transformConfigOptions(response.configOptions);
+        const responseOption = category === undefined
+            ? findSelectConfigOptionById({ configOptions: this.configOptions, id: configId })
+            : findSelectConfigOption({
+                configOptions: this.configOptions,
+                category,
+                id: configId,
+            });
+        if (responseOption?.currentValue != null) {
+            return responseOption.currentValue;
+        }
+        this.logger.warn({ configId, value: requestedValue }, `ACP setSessionConfigOption response did not include the requested ${label} option currentValue; using requested value`);
+        return requestedValue;
+    }
+    getPendingPermissions() {
+        return Array.from(this.pendingPermissions.values(), (entry) => entry.request);
+    }
+    async respondToPermission(requestId, response) {
+        const pending = this.pendingPermissions.get(requestId);
+        if (!pending) {
+            throw new Error(`No pending permission request with id '${requestId}'`);
+        }
+        const selectedOption = selectPermissionOption(pending.options, response);
+        if (response.selectedActionId !== undefined && !selectedOption) {
+            throw new Error(`ACP permission action '${response.selectedActionId}' does not exist or does not match '${response.behavior}' behavior`);
+        }
+        this.pendingPermissions.delete(requestId);
+        pending.resolve(selectedOption
+            ? {
+                outcome: {
+                    outcome: "selected",
+                    optionId: selectedOption.optionId,
+                },
+            }
+            : { outcome: { outcome: "cancelled" } });
+        this.pushEvent({
+            type: "permission_resolved",
+            provider: this.provider,
+            requestId,
+            resolution: response,
+            turnId: pending.turnId ?? undefined,
+        });
+        // A denied prompt is stopped through the same boundary as Stop: the boundary
+        // closes admission before the cancellation write, so no replacement can
+        // cross the denied turn before its terminal and cancellation are settled.
+        if (response.behavior === "deny" && response.interrupt) {
+            await this.stopTurnOnPermissionDenial({
+                permissionRequestId: requestId,
+                ...(pending.turnId ? { turnId: pending.turnId } : {}),
+            });
+        }
+    }
+    /**
+     * Routes a deny+interrupt by stop kind. The generic router knows two kinds: a
+     * foreground turn gets the ordinary foreground stop plus its cancellation
+     * ledger, and no stop-able turn suppresses the write with an observable log.
+     * A subclass with another stop kind overrides this; the base deliberately
+     * carries no subclass-specific stop identity or routing knowledge.
+     */
+    async stopTurnOnPermissionDenial(correlation) {
+        await this.stopForegroundTurn({ reason: "permission-denied", correlation });
+    }
+    describePersistence() {
+        if (!this.sessionId) {
+            return null;
+        }
+        return {
+            provider: this.provider,
+            sessionId: this.sessionId,
+            nativeHandle: this.sessionId,
+            metadata: {
+                ...this.config,
+                title: this.currentTitle,
+            },
+        };
+    }
+    /**
+     * Cancels the current foreground turn through the stop boundary. Returning
+     * means the cancellation notification write settled — nothing more. It does not
+     * clear the stop, does not terminalize the turn, and does not make the session
+     * ready for a replacement.
+     */
+    async interrupt() {
+        for (const pending of this.pendingPermissions.values()) {
+            pending.resolve({ outcome: { outcome: "cancelled" } });
+        }
+        this.pendingPermissions.clear();
+        await this.stopForegroundTurn({ reason: "interrupt" });
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        // Marked closed before any asynchronous teardown: from here no new
+        // reservation is possible and no late settlement, control result, phase
+        // update, or terminal can touch admission state again.
+        this.closed = true;
+        const stop = this.stop;
+        if (stop) {
+            // One death path: the record being dropped settles exactly like an
+            // observed death. The staged successor keeps its "closed" rejection, and
+            // the closed ledger can no longer be reopened by a late settlement.
+            this.settleStopOnObservedDeath("closed");
+        }
+        this.stop = null;
+        this.admissionState = "idle";
+        this.deliverTranslatedEvents(this.flushPendingUserMessage());
+        this.settleCommandsReady();
+        for (const pending of this.pendingPermissions.values()) {
+            pending.resolve({ outcome: { outcome: "cancelled" } });
+        }
+        this.pendingPermissions.clear();
+        if (this.connection && this.sessionId) {
+            try {
+                if (this.activeForegroundTurnId) {
+                    await this.connection.cancel({ sessionId: this.sessionId });
+                }
+            }
+            catch { }
+            try {
+                if (this.agentCapabilities?.sessionCapabilities?.close) {
+                    await this.connection.unstable_closeSession({ sessionId: this.sessionId });
+                }
+            }
+            catch (error) {
+                this.logger.debug({ err: error }, "ACP closeSession failed during shutdown");
+            }
+        }
+        const terminalTerminations = Array.from(this.terminalEntries.values(), (terminal) => this.terminateProcess(terminal.child, {
+            gracefulTimeoutMs: 2000,
+            forceTimeoutMs: 2000,
+        }));
+        await Promise.all(terminalTerminations);
+        this.terminalEntries.clear();
+        if (this.child) {
+            await this.terminateProcess(this.child, { gracefulTimeoutMs: 2000, forceTimeoutMs: 2000 });
+        }
+        this.subscribers.clear();
+        this.connection = null;
+        this.child = null;
+        this.activeForegroundTurnId = null;
+    }
+    async requestPermission(params) {
+        const canAutoAccept = isACPAutoAcceptEnabled(this.config) && !isACPChooserRequest(params.options);
+        if (canAutoAccept) {
+            const allowOption = selectPermissionOption(params.options, { behavior: "allow" });
+            if (allowOption) {
+                this.logger.info({ toolCallId: params.toolCall.toolCallId, optionId: allowOption.optionId }, "Auto-accepting ACP permission request");
+                return {
+                    outcome: { outcome: "selected", optionId: allowOption.optionId },
+                };
+            }
+        }
+        // Match Zed acp.rs:3189-3220 when Paseo is not handling the request locally.
+        const requestId = randomUUID();
+        let toolSnapshot = this.toolCalls.get(params.toolCall.toolCallId) ??
+            mergeToolSnapshot(params.toolCall.toolCallId, params.toolCall);
+        if (this.toolSnapshotTransformer) {
+            toolSnapshot = this.toolSnapshotTransformer(toolSnapshot);
+        }
+        const request = mapPermissionRequest(this.provider, requestId, params, toolSnapshot);
+        const promise = new Promise((resolve, reject) => {
+            this.pendingPermissions.set(requestId, {
+                request,
+                options: params.options,
+                resolve,
+                reject,
+                turnId: this.activeForegroundTurnId,
+            });
+        });
+        this.pushEvent({
+            type: "permission_requested",
+            provider: this.provider,
+            request,
+            turnId: this.activeForegroundTurnId ?? undefined,
+        });
+        return promise;
+    }
+    async sessionUpdate(params) {
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: this.provider,
+            sessionId: params.sessionId,
+            rawEvent: params,
+        }, "provider.acp.raw_event");
+        if (params.sessionId !== this.sessionId) {
+            return;
+        }
+        const events = this.translateSessionUpdate(params.update);
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: this.provider,
+            sessionId: this.sessionId,
+            turnId: this.activeForegroundTurnId ?? undefined,
+            rawEvent: params,
+            events,
+        }, "provider.acp.parsed_event");
+        this.deliverTranslatedEvents(events);
+    }
+    deliverTranslatedEvents(events) {
+        if (this.replayingHistory) {
+            for (const event of events) {
+                if (event.type === "timeline") {
+                    this.persistedHistory.push(event.item);
+                }
+            }
+            return;
+        }
+        for (const event of events) {
+            this.pushEvent(event);
+        }
+    }
+    async extNotification(method, params) {
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: this.provider,
+            sessionId: typeof params.sessionId === "string" ? params.sessionId : undefined,
+            method,
+            rawEvent: params,
+        }, "provider.acp.extension_notification");
+        const parsedCommands = this.extensionCommandsParser?.(method, params);
+        if (parsedCommands) {
+            this.applyResolvedCommands(parsedCommands, {
+                sessionId: typeof params.sessionId === "string" ? params.sessionId : undefined,
+            });
+        }
+    }
+    // Cache an asynchronously-delivered slash-command batch and unblock any
+    // listCommands() call that is waiting on the initial batch. Used when a
+    // provider supplies an extensionCommandsParser whose result arrives after
+    // session/new (e.g. via a vendor extension notification). The ready gate is
+    // always settled — even for an empty batch — so a provider that legitimately
+    // reports no commands does not leave listCommands() blocked for the full
+    // initial-commands timeout. An optional sessionId scopes the batch to this
+    // session; notifications addressed to a different session are ignored.
+    applyResolvedCommands(commands, options) {
+        if (options?.sessionId !== undefined &&
+            this.sessionId !== null &&
+            options.sessionId !== this.sessionId) {
+            return;
+        }
+        if (commands.length > 0) {
+            this.cachedCommands = commands;
+        }
+        this.settleCommandsReady();
+    }
+    async readTextFile(params) {
+        const raw = await fs.readFile(params.path, "utf8");
+        if (!params.line && !params.limit) {
+            return { content: raw };
+        }
+        const lines = raw.split(/\r?\n/);
+        const start = Math.max((params.line ?? 1) - 1, 0);
+        const end = params.limit ? start + params.limit : undefined;
+        return { content: lines.slice(start, end).join("\n") };
+    }
+    async writeTextFile(params) {
+        await fs.mkdir(path.dirname(params.path), { recursive: true });
+        await fs.writeFile(params.path, params.content, "utf8");
+        return {};
+    }
+    async createTerminal(params) {
+        const terminalId = randomUUID();
+        const env = Object.fromEntries((params.env ?? []).map((entry) => [entry.name, entry.value]));
+        const terminalCommand = resolveTerminalCommand(params.command, params.args);
+        const commandEnvOverlays = terminalCommand.shell === false ? [env, createStringCommandShellEnvOverlay()] : [env];
+        const child = spawnProcess(terminalCommand.command, terminalCommand.args, {
+            cwd: params.cwd ?? this.config.cwd,
+            ...createProviderEnvSpec({
+                runtimeSettings: this.runtimeSettings,
+                overlays: commandEnvOverlays,
+            }),
+            shell: terminalCommand.shell,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let resolveExit;
+        let rejectExit;
+        const waitForExit = new Promise((resolve, reject) => {
+            resolveExit = resolve;
+            rejectExit = reject;
+        });
+        waitForExit.catch(() => undefined);
+        const entry = {
+            id: terminalId,
+            child,
+            output: "",
+            truncated: false,
+            outputByteLimit: params.outputByteLimit ?? null,
+            exit: null,
+            waitForExit,
+            resolveExit,
+            rejectExit,
+        };
+        child.stdout.on("data", (chunk) => appendTerminalOutput(entry, chunk.toString()));
+        child.stderr.on("data", (chunk) => appendTerminalOutput(entry, chunk.toString()));
+        child.once("error", (error) => {
+            const spawnError = error instanceof Error ? error : new Error(String(error));
+            appendTerminalOutput(entry, `${spawnError.message}\n`);
+            rejectExit(spawnError);
+        });
+        child.once("exit", (code, signal) => {
+            const exit = { exitCode: code, signal };
+            entry.exit = exit;
+            resolveExit(exit);
+        });
+        this.terminalEntries.set(terminalId, entry);
+        return { terminalId };
+    }
+    async terminalOutput(params) {
+        const entry = this.getTerminalEntry(params.terminalId);
+        return {
+            output: entry.output,
+            truncated: entry.truncated,
+            exitStatus: entry.exit ?? undefined,
+        };
+    }
+    async waitForTerminalExit(params) {
+        const entry = this.getTerminalEntry(params.terminalId);
+        return entry.waitForExit;
+    }
+    async releaseTerminal(params) {
+        const entry = this.getTerminalEntry(params.terminalId);
+        if (!entry.exit) {
+            await this.terminateProcess(entry.child, { gracefulTimeoutMs: 2000, forceTimeoutMs: 2000 });
+        }
+        this.terminalEntries.delete(params.terminalId);
+    }
+    async killTerminal(params) {
+        const entry = this.getTerminalEntry(params.terminalId);
+        if (!entry.exit) {
+            await this.terminateProcess(entry.child, { gracefulTimeoutMs: 2000, forceTimeoutMs: 2000 });
+        }
+        return {};
+    }
+    /**
+     * Subscribes the one death path to the connection's close signal, covering
+     * transport death that no process exit event reports. The SDK aborts
+     * `signal` when the connection's stream ends; test connections without one,
+     * and already-subscribed signals, are skipped.
+     */
+    observeConnectionDeath(connection) {
+        const signal = connection.signal;
+        if (!(signal instanceof AbortSignal) || this.connectionDeathSignal === signal) {
+            return;
+        }
+        this.connectionDeathSignal = signal;
+        signal.addEventListener("abort", () => {
+            // A replaced connection's signal says nothing about the live one.
+            if (this.closed || this.connection !== connection) {
+                return;
+            }
+            this.settleStopOnObservedDeath("connection-aborted");
+        }, { once: true });
+    }
+    async spawnProcess() {
+        const prefix = await resolveProviderLaunch({
+            commandConfig: this.runtimeSettings?.command,
+            defaultBinary: this.defaultCommand[0],
+        });
+        const availability = await checkProviderLaunchAvailable(prefix);
+        if (!availability.available) {
+            throw new Error(`${this.provider} command '${this.defaultCommand[0]}' not found`);
+        }
+        const command = prefix.command;
+        const args = [...prefix.args, ...this.defaultCommand.slice(1)];
+        const child = spawnProcess(command, args, {
+            cwd: this.config.cwd,
+            ...createProviderEnvSpec({
+                runtimeSettings: this.runtimeSettings,
+                overlays: [this.launchEnv],
+            }),
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        assertChildWithPipes(child);
+        const stderrChunks = [];
+        child.stderr.on("data", (chunk) => {
+            stderrChunks.push(chunk.toString());
+        });
+        child.once("exit", (code, signal) => {
+            if (this.closed) {
+                return;
+            }
+            const foregroundTurnId = this.activeForegroundTurnId;
+            if (foregroundTurnId) {
+                this.synthesizeCanceledToolCalls();
+                this.finishTurn(foregroundTurnId, {
+                    type: "turn_failed",
+                    provider: this.provider,
+                    error: `ACP agent exited unexpectedly (${code ?? "null"}${signal ? `, ${signal}` : ""})`,
+                    diagnostic: stderrChunks.join("").trim() || undefined,
+                    turnId: foregroundTurnId,
+                });
+            }
+            // Terminal first, then settlement: the death path runs after the
+            // synthesized foreground terminal, and also runs when there is none (an
+            // ownerless stop has no foreground turn to terminalize).
+            this.settleStopOnObservedDeath("agent-exited");
+        });
+        const stream = createLoggedNdJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout), { logger: this.logger, provider: this.provider });
+        const connection = new ClientSideConnection(() => this, stream);
+        // Take ownership before initialize so the outer initialization guard can
+        // close the process even when the ACP handshake itself rejects. The revision
+        // identifies this connection: stop boundaries capture it at install so a
+        // replacement connection can never be opened by an older stop's writes.
+        this.child = child;
+        this.connection = connection;
+        this.connectionRevision += 1;
+        this.observeConnectionDeath(connection);
+        const initialize = await this.runACPRequest(() => connection.initialize({
+            protocolVersion: PROTOCOL_VERSION,
+            clientCapabilities: buildACPClientCapabilities(this.clientCapabilityMeta, this.clientCapabilities),
+            clientInfo: { name: "Paseo", version: "dev" },
+        }));
+        return { child, connection, initialize };
+    }
+    async runACPRequest(request) {
+        try {
+            return await request();
+        }
+        catch (error) {
+            throw toACPRequestError(error);
+        }
+    }
+    acpMcpServers() {
+        return this.capabilities.supportsMcpServers ? normalizeMcpServers(this.config.mcpServers) : [];
+    }
+    applySessionState(response) {
+        const transformed = this.sessionResponseTransformer
+            ? this.sessionResponseTransformer(response)
+            : response;
+        this.configOptions = this.transformConfigOptions(transformed.configOptions ?? []);
+        const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, this.configOptions);
+        this.availableModes = modeInfo.modes;
+        this.currentMode = modeInfo.currentModeId ?? this.currentMode;
+        this.availableModels = transformed.models?.availableModels ?? null;
+        this.currentModel =
+            transformed.models?.currentModelId ?? deriveCurrentConfigValue(this.configOptions, "model");
+        this.thinkingOptionId =
+            deriveCurrentConfigValue(this.configOptions, "thought_level") ?? this.thinkingOptionId;
+    }
+    transformConfigOptions(configOptions) {
+        return this.configOptionsTransformer
+            ? this.configOptionsTransformer(configOptions)
+            : configOptions;
+    }
+    transformModeId(modeId) {
+        return this.modeIdTransformer ? this.modeIdTransformer(modeId) : modeId;
+    }
+    async applyConfiguredOverrides() {
+        const configuredModeId = this.config.modeId;
+        if (configuredModeId && configuredModeId !== this.currentMode) {
+            const selection = resolveACPModeSelection({
+                modeId: configuredModeId,
+                availableModes: this.availableModes,
+                configOptions: this.configOptions,
+            });
+            await this.setModeWithSelection({ modeId: configuredModeId, selection });
+        }
+        const configuredModelId = this.config.model;
+        if (configuredModelId && configuredModelId !== this.currentModel) {
+            const selection = resolveACPModelSelection({
+                modelId: configuredModelId,
+                availableModels: this.availableModels,
+                configOptions: this.configOptions,
+            });
+            try {
+                await this.setModelWithSelection({ modelId: configuredModelId, selection });
+            }
+            catch (error) {
+                if (!this.isModelSelectionUnavailableError(error)) {
+                    throw error;
+                }
+                this.logger.warn({ value: configuredModelId }, `${this.provider} does not expose ACP model selection; using provider default model`);
+            }
+        }
+        if (this.config.thinkingOptionId && this.config.thinkingOptionId !== this.thinkingOptionId) {
+            await this.setThinkingOption(this.config.thinkingOptionId);
+        }
+        const configuredFeatureValues = this.config.featureValues ?? {};
+        for (const featureOption of this.configFeatureOptions) {
+            if (!Object.prototype.hasOwnProperty.call(configuredFeatureValues, featureOption.id)) {
+                continue;
+            }
+            await this.setFeature(featureOption.id, configuredFeatureValues[featureOption.id]);
+        }
+    }
+    warnInvalidSelection(value, message) {
+        this.logger.warn({ value }, message);
+    }
+    modelSelectionUnavailableMessage() {
+        return `${this.provider} does not expose ACP model selection`;
+    }
+    isModelSelectionUnavailableError(error) {
+        return error instanceof Error && error.message === this.modelSelectionUnavailableMessage();
+    }
+    translateSessionUpdate(update) {
+        if (update.sessionUpdate === "user_message_chunk") {
+            return this.handleUserMessageChunk(update);
+        }
+        const pendingUserEvents = this.flushPendingUserMessage();
+        switch (update.sessionUpdate) {
+            case "agent_message_chunk": {
+                const item = this.createMessageTimelineItem("assistant_message", update);
+                return item ? [...pendingUserEvents, this.wrapTimeline(item)] : pendingUserEvents;
+            }
+            case "agent_thought_chunk": {
+                this.fallbackAssistantMessageId = null;
+                const item = this.createMessageTimelineItem("reasoning", update);
+                return item ? [...pendingUserEvents, this.wrapTimeline(item)] : pendingUserEvents;
+            }
+            case "tool_call":
+                this.fallbackAssistantMessageId = null;
+                return [
+                    ...pendingUserEvents,
+                    ...this.handleToolCallUpdate(update.toolCallId, update, undefined),
+                ];
+            case "tool_call_update":
+                return [
+                    ...pendingUserEvents,
+                    ...this.handleToolCallUpdate(update.toolCallId, update, this.toolCalls.get(update.toolCallId)),
+                ];
+            case "plan":
+                this.fallbackAssistantMessageId = null;
+                return [...pendingUserEvents, this.wrapTimeline(mapPlanToTimeline(update))];
+            case "current_mode_update":
+                this.handleCurrentModeUpdate(update);
+                return [
+                    ...pendingUserEvents,
+                    {
+                        type: "mode_changed",
+                        provider: this.provider,
+                        currentModeId: this.currentMode,
+                        availableModes: [...this.availableModes],
+                    },
+                ];
+            case "config_option_update":
+                return [...pendingUserEvents, ...this.handleConfigOptionUpdate(update)];
+            case "session_info_update":
+                this.handleSessionInfoUpdate(update);
+                return pendingUserEvents;
+            case "usage_update":
+                this.handleUsageUpdate(update);
+                return pendingUserEvents;
+            case "available_commands_update":
+                this.cachedCommands = update.availableCommands.map((command) => ({
+                    name: command.name,
+                    description: command.description,
+                    argumentHint: command.input?.hint ?? "",
+                    kind: "command",
+                }));
+                this.settleCommandsReady();
+                return pendingUserEvents;
+            default:
+                return pendingUserEvents;
+        }
+    }
+    handleUserMessageChunk(update) {
+        this.fallbackAssistantMessageId = null;
+        if (this.activeForegroundTurnId &&
+            this.submittedUserMessageTurnId === this.activeForegroundTurnId) {
+            return [];
+        }
+        const chunkText = contentBlockToText(update.content);
+        if (!chunkText) {
+            return [];
+        }
+        const messageId = update.messageId ?? undefined;
+        const pending = this.pendingUserMessage;
+        const startsNewMessage = Boolean(pending?.messageId && messageId && pending.messageId !== messageId);
+        const events = startsNewMessage ? this.flushPendingUserMessage() : [];
+        this.pendingUserMessage ?? (this.pendingUserMessage = {
+            text: "",
+            ...(messageId ? { messageId } : {}),
+        });
+        if (!this.pendingUserMessage.messageId && messageId) {
+            this.pendingUserMessage.messageId = messageId;
+        }
+        this.pendingUserMessage.text += chunkText;
+        return events;
+    }
+    flushPendingUserMessage() {
+        const pending = this.pendingUserMessage;
+        if (!pending) {
+            return [];
+        }
+        this.pendingUserMessage = null;
+        return [
+            this.wrapTimeline({
+                type: "user_message",
+                text: pending.text,
+                ...(pending.messageId ? { messageId: pending.messageId } : {}),
+            }),
+        ];
+    }
+    handleToolCallUpdate(toolCallId, update, previous) {
+        let snapshot = mergeToolSnapshot(toolCallId, update, previous);
+        if (this.toolSnapshotTransformer) {
+            snapshot = this.toolSnapshotTransformer(snapshot);
+        }
+        this.toolCalls.set(toolCallId, snapshot);
+        return [this.wrapTimeline(mapToolSnapshotToTimeline(snapshot, this.terminalEntries))];
+    }
+    createMessageTimelineItem(type, update) {
+        const chunkText = contentBlockToText(update.content);
+        if (!chunkText) {
+            return null;
+        }
+        if (type === "assistant_message") {
+            return {
+                type: "assistant_message",
+                text: chunkText,
+                messageId: this.resolveAssistantMessageId(update.messageId),
+            };
+        }
+        return { type: "reasoning", text: chunkText };
+    }
+    resolveAssistantMessageId(messageId) {
+        if (messageId) {
+            this.fallbackAssistantMessageId = null;
+            return messageId;
+        }
+        this.fallbackAssistantMessageId ?? (this.fallbackAssistantMessageId = randomUUID());
+        return this.fallbackAssistantMessageId;
+    }
+    handleCurrentModeUpdate(update) {
+        this.currentMode = this.transformModeId(update.currentModeId);
+    }
+    handleConfigOptionUpdate(update) {
+        this.configOptions = this.transformConfigOptions(update.configOptions);
+        const modeInfo = deriveModesFromACP(this.defaultModes, null, this.configOptions);
+        const nextMode = modeInfo.currentModeId;
+        const nextModel = deriveCurrentConfigValue(this.configOptions, "model");
+        const nextThinkingOptionId = deriveCurrentConfigValue(this.configOptions, "thought_level");
+        this.availableModes = modeInfo.modes;
+        this.currentMode = nextMode ?? this.currentMode;
+        this.currentModel = nextModel ?? this.currentModel;
+        this.thinkingOptionId = nextThinkingOptionId ?? this.thinkingOptionId;
+        const events = [];
+        if (nextMode !== null) {
+            events.push({
+                type: "mode_changed",
+                provider: this.provider,
+                currentModeId: this.currentMode,
+                availableModes: [...this.availableModes],
+            });
+        }
+        if (nextModel !== null) {
+            events.push({
+                type: "model_changed",
+                provider: this.provider,
+                runtimeInfo: this.runtimeInfo(),
+            });
+        }
+        if (nextThinkingOptionId !== null) {
+            events.push({
+                type: "thinking_option_changed",
+                provider: this.provider,
+                thinkingOptionId: this.thinkingOptionId,
+            });
+        }
+        return events;
+    }
+    handleSessionInfoUpdate(update) {
+        if ("title" in update) {
+            this.currentTitle = update.title ?? null;
+        }
+        if ("updatedAt" in update) {
+            this.lastActivityAt = update.updatedAt ?? null;
+        }
+    }
+    handleUsageUpdate(update) {
+        void update;
+    }
+    handlePromptResponse(response, turnId) {
+        this.currentTurnUsage = mapACPUsage(response.usage) ?? this.currentTurnUsage;
+        switch (response.stopReason) {
+            case "cancelled":
+                this.synthesizeCanceledToolCalls();
+                this.finishTurn(turnId, {
+                    type: "turn_canceled",
+                    provider: this.provider,
+                    reason: "Interrupted",
+                    turnId,
+                });
+                break;
+            case "end_turn":
+            case "max_tokens":
+            case "max_turn_requests":
+            case "refusal":
+            default:
+                this.finishTurn(turnId, {
+                    type: "turn_completed",
+                    provider: this.provider,
+                    usage: this.currentTurnUsage,
+                    turnId,
+                });
+                break;
+        }
+    }
+    wrapTimeline(item) {
+        return {
+            type: "timeline",
+            provider: this.provider,
+            item,
+            turnId: this.activeForegroundTurnId ?? undefined,
+        };
+    }
+    pushEvent(event) {
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: this.provider,
+            sessionId: this.sessionId,
+            turnId: getAgentStreamEventTurnId(event) ?? this.activeForegroundTurnId ?? undefined,
+            event,
+        }, "provider.acp.event_emit");
+        for (const subscriber of this.subscribers) {
+            subscriber(event);
+        }
+    }
+    emitSubmittedUserMessage(prompt, messageId, turnId, clientMessageId) {
+        const text = extractPromptText(prompt);
+        if (text.trim().length === 0) {
+            return;
+        }
+        this.submittedUserMessageTurnId = turnId;
+        this.pushEvent({
+            type: "timeline",
+            provider: this.provider,
+            turnId,
+            item: {
+                type: "user_message",
+                text,
+                messageId,
+                ...(clientMessageId ? { clientMessageId } : {}),
+            },
+        });
+    }
+    runtimeInfo() {
+        return {
+            provider: this.provider,
+            sessionId: this.sessionId,
+            model: this.currentModel,
+            thinkingOptionId: this.thinkingOptionId,
+            modeId: this.currentMode,
+            extra: {
+                title: this.currentTitle,
+                updatedAt: this.lastActivityAt,
+            },
+        };
+    }
+    /**
+     * Settles a foreground turn. `turnId` is checked against live state before
+     * anything moves:
+     *
+     * - the stopped turn of the installed boundary records terminal proof (once)
+     *   and releases the gate, without leaving the stopping phase while
+     *   cancellation writes are still unresolved or failed;
+     * - the current foreground turn settles ordinarily and hands the slot back;
+     * - anything else is a terminal from an earlier generation and is dropped
+     *   instead of clearing a reserved or running successor.
+     *
+     * After close nothing is emitted and no state moves.
+     */
+    finishTurn(turnId, event) {
+        if (this.closed) {
+            return;
+        }
+        const stop = this.stop;
+        if (stop && turnId === stop.stoppedTurnId) {
+            if (!this.stopIdentityMatches(stop)) {
+                this.logger.warn({ stopId: stop.stopId, turnId, sessionId: stop.sessionId }, "Ignored ACP terminal for the stopped turn: session identity changed");
+                return;
+            }
+            stop.terminalObserved = true;
+            this.logger.info({ stopId: stop.stopId, turnId, kind: stop.kind }, "provider.acp.stop_terminal_observed");
+            if (!stop.terminalDelivered) {
+                stop.terminalDelivered = true;
+                this.deliverTerminal(event);
+            }
+            this.evaluateStopGate(stop);
+            return;
+        }
+        if (turnId !== this.activeForegroundTurnId) {
+            this.logger.warn({ turnId, activeTurnId: this.activeForegroundTurnId ?? undefined }, "Ignored ACP terminal for a turn that no longer owns the foreground");
+            return;
+        }
+        this.deliverTerminal(event);
+        this.activeForegroundTurnId = null;
+        this.admissionState = "idle";
+    }
+    /** Emits a terminal event once, after the buffered provider echo is flushed. */
+    deliverTerminal(event) {
+        this.deliverTranslatedEvents(this.flushPendingUserMessage());
+        this.fallbackAssistantMessageId = null;
+        if (this.submittedUserMessageTurnId === event.turnId) {
+            this.submittedUserMessageTurnId = null;
+        }
+        this.pushEvent(event);
+    }
+    emitBootstrapThreadEvent() {
+        if (!this.bootstrapThreadEventPending || !this.sessionId) {
+            return;
+        }
+        this.bootstrapThreadEventPending = false;
+        this.pushEvent({
+            type: "thread_started",
+            provider: this.provider,
+            sessionId: this.sessionId,
+        });
+    }
+    synthesizeCanceledToolCalls() {
+        for (const snapshot of this.toolCalls.values()) {
+            const mapped = mapToolSnapshotToTimeline(snapshot, this.terminalEntries);
+            if (mapped.status === "running") {
+                this.pushEvent(this.wrapTimeline({
+                    ...mapped,
+                    status: "canceled",
+                    error: null,
+                }));
+            }
+        }
+    }
+    collectDiagnostic(message) {
+        const parts = [message];
+        if (this.child?.exitCode != null) {
+            parts.push(`exitCode=${this.child.exitCode}`);
+        }
+        if (this.child?.signalCode) {
+            parts.push(`signal=${this.child.signalCode}`);
+        }
+        return parts.length > 0 ? parts.join(" | ") : undefined;
+    }
+    getTerminalEntry(terminalId) {
+        const entry = this.terminalEntries.get(terminalId);
+        if (!entry) {
+            throw new Error(`Unknown terminal '${terminalId}'`);
+        }
+        return entry;
+    }
+}
+export function findSelectConfigOption({ configOptions, category, id, }) {
+    const option = configOptions?.find((entry) => entry.type === "select" && entry.category === category && (!id || entry.id === id));
+    return option ?? null;
+}
+function findSelectConfigOptionById({ configOptions, id, }) {
+    const option = configOptions?.find((entry) => entry.type === "select" && entry.id === id);
+    return option ?? null;
+}
+function findSelectConfigFeatureOption(configOptions, featureOption) {
+    const option = configOptions?.find((entry) => entry.type === "select" &&
+        entry.id === featureOption.configId &&
+        (featureOption.category === undefined || entry.category === featureOption.category));
+    return option ?? null;
+}
+function findSelectConfigChoice({ option, value, }) {
+    if (!option) {
+        return null;
+    }
+    return flattenSelectOptions(option.options).find((choice) => choice.value === value) ?? null;
+}
+function flattenSelectOptions(options) {
+    const flattened = [];
+    for (const option of options) {
+        if ("value" in option) {
+            flattened.push(option);
+            continue;
+        }
+        for (const groupOption of option.options) {
+            flattened.push({ ...groupOption, group: option.group });
+        }
+    }
+    return flattened;
+}
+function deriveConfigFeatureSelectOptions(option, featureOption) {
+    return flattenSelectOptions(option.options).map((choice) => ({
+        id: choice.value,
+        label: normalizeConfigFeatureOptionLabel(choice, featureOption),
+        description: choice.description ?? undefined,
+        isDefault: choice.value === option.currentValue,
+        metadata: choice.group ? { group: choice.group } : undefined,
+    }));
+}
+function normalizeConfigFeatureOptionLabel(choice, featureOption) {
+    const name = choice.name.trim();
+    if (name) {
+        return name;
+    }
+    if (choice.value === "" && featureOption.emptyOptionLabel) {
+        return featureOption.emptyOptionLabel;
+    }
+    return choice.value;
+}
+function normalizeConfigFeatureValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value === null) {
+        return "";
+    }
+    throw new Error(`ACP feature value must be a string`);
+}
+export function deriveSelectorOptions(configOptions, category) {
+    const option = findSelectConfigOption({ configOptions, category });
+    if (!option) {
+        return [];
+    }
+    return flattenSelectOptions(option.options).map((value) => ({
+        id: value.value,
+        label: value.name,
+        description: value.description ?? undefined,
+        isDefault: value.value === option.currentValue,
+        metadata: value.group ? { group: value.group } : undefined,
+    }));
+}
+function deriveCurrentConfigValue(configOptions, category) {
+    const option = configOptions?.find((entry) => entry.type === "select" && entry.category === category);
+    return option?.currentValue ?? null;
+}
+function normalizeMcpServers(servers) {
+    if (!servers) {
+        return [];
+    }
+    return Object.entries(servers).map(([name, config]) => {
+        if (config.type === "stdio") {
+            return {
+                name,
+                command: config.command,
+                args: config.args ?? [],
+                env: Object.entries(config.env ?? {}).map(([envName, value]) => ({
+                    name: envName,
+                    value,
+                })),
+            };
+        }
+        if (config.type === "http") {
+            return {
+                type: "http",
+                name,
+                url: config.url,
+                headers: Object.entries(config.headers ?? {}).map(([headerName, value]) => ({
+                    name: headerName,
+                    value,
+                })),
+            };
+        }
+        return {
+            type: "sse",
+            name,
+            url: config.url,
+            headers: Object.entries(config.headers ?? {}).map(([headerName, value]) => ({
+                name: headerName,
+                value,
+            })),
+        };
+    });
+}
+function toACPContentBlocks(prompt) {
+    if (typeof prompt === "string") {
+        return [{ type: "text", text: prompt }];
+    }
+    const contentBlocks = [];
+    for (const block of prompt) {
+        switch (block.type) {
+            case "text":
+                contentBlocks.push({ type: "text", text: block.text });
+                break;
+            case "image":
+                contentBlocks.push({ type: "image", data: block.data, mimeType: block.mimeType });
+                break;
+            default:
+                contentBlocks.push({ type: "text", text: renderPromptAttachmentAsText(block) });
+                break;
+        }
+    }
+    return contentBlocks;
+}
+function extractPromptText(prompt) {
+    if (typeof prompt === "string") {
+        return prompt;
+    }
+    return prompt
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("");
+}
+function contentBlockToText(content) {
+    switch (content.type) {
+        case "text":
+            return content.text;
+        case "resource_link":
+            return content.title ?? content.uri;
+        case "resource":
+            return "text" in content.resource
+                ? content.resource.text
+                : `[resource:${content.resource.mimeType ?? "binary"}]`;
+        case "image":
+            return "[image]";
+        case "audio":
+            return "[audio]";
+        default:
+            return "";
+    }
+}
+function normalizeACPImportPromptPreview(text) {
+    const normalized = text?.trim().replace(/\s+/g, " ") ?? "";
+    if (!normalized)
+        return null;
+    return normalized.length > 160 ? normalized.slice(0, 160) : normalized;
+}
+function isACPConversationUpdate(update) {
+    return (update.sessionUpdate === "user_message_chunk" ||
+        update.sessionUpdate === "agent_message_chunk" ||
+        update.sessionUpdate === "agent_thought_chunk" ||
+        update.sessionUpdate === "tool_call" ||
+        update.sessionUpdate === "tool_call_update" ||
+        update.sessionUpdate === "plan");
+}
+function coalesceDefined(next, previous, fallback) {
+    if (next !== undefined) {
+        return next;
+    }
+    if (previous !== undefined) {
+        return previous;
+    }
+    return fallback;
+}
+function mergeToolSnapshot(toolCallId, update, previous) {
+    return {
+        toolCallId,
+        title: update.title ?? previous?.title ?? toolCallId,
+        kind: update.kind ?? previous?.kind ?? null,
+        status: update.status ?? previous?.status ?? null,
+        content: coalesceDefined(update.content, previous?.content, null),
+        locations: coalesceDefined(update.locations, previous?.locations, null),
+        rawInput: update.rawInput !== undefined ? update.rawInput : previous?.rawInput,
+        rawOutput: update.rawOutput !== undefined ? update.rawOutput : previous?.rawOutput,
+    };
+}
+function mapPlanToTimeline(plan) {
+    return {
+        type: "todo",
+        items: plan.entries.map((entry) => ({
+            text: entry.content,
+            completed: entry.status === "completed",
+        })),
+    };
+}
+function mapToolSnapshotToTimeline(snapshot, terminals) {
+    const status = mapToolStatus(snapshot.status);
+    const detail = mapToolDetail(snapshot, terminals);
+    const base = {
+        type: "tool_call",
+        callId: snapshot.toolCallId,
+        name: snapshot.kind ?? snapshot.title,
+        detail,
+        metadata: {
+            kind: snapshot.kind ?? undefined,
+            title: snapshot.title,
+        },
+    };
+    if (status === "failed") {
+        return {
+            ...base,
+            status: "failed",
+            error: { message: readErrorMessage(snapshot.rawOutput) },
+        };
+    }
+    if (status === "completed") {
+        return {
+            ...base,
+            status: "completed",
+            error: null,
+        };
+    }
+    return {
+        ...base,
+        status: "running",
+        error: null,
+    };
+}
+function mapToolStatus(status) {
+    switch (status) {
+        case "completed":
+            return "completed";
+        case "failed":
+            return "failed";
+        case "pending":
+        case "in_progress":
+        default:
+            return "running";
+    }
+}
+function mapToolDetail(snapshot, terminals) {
+    const context = {
+        snapshot,
+        firstLocation: snapshot.locations?.[0]?.path,
+        textContent: extractToolText(snapshot.content),
+        diffContent: extractDiffContent(snapshot.content),
+        terminalContent: extractTerminalContent(snapshot.content, terminals),
+        rawInput: readRecord(snapshot.rawInput),
+        rawOutput: readRecord(snapshot.rawOutput),
+    };
+    switch (snapshot.kind) {
+        case "read":
+            return buildReadToolDetail(context);
+        case "edit":
+        case "delete":
+            return buildEditToolDetail(context);
+        case "search":
+            return buildSearchAcpToolDetail(context);
+        case "execute":
+            return buildShellToolDetail(context);
+        case "fetch":
+            return buildFetchToolDetail(context);
+        case "think":
+            return {
+                type: "plain_text",
+                label: snapshot.title,
+                icon: "brain",
+                text: context.textContent ?? stringifyUnknown(snapshot.rawOutput),
+            };
+        case "switch_mode":
+            return {
+                type: "plain_text",
+                label: snapshot.title,
+                icon: "sparkles",
+                text: context.textContent ?? stringifyUnknown(snapshot.rawInput),
+            };
+        default:
+            return buildDefaultToolDetail(context);
+    }
+}
+function buildReadToolDetail(context) {
+    const { snapshot, firstLocation, textContent, rawInput, rawOutput } = context;
+    return {
+        type: "read",
+        filePath: firstLocation ?? readString(rawInput, ["path", "filePath", "file"]) ?? snapshot.title,
+        content: textContent ?? readString(rawOutput, ["content", "text"]),
+        offset: readNumber(rawInput, ["offset", "line"]),
+        limit: readNumber(rawInput, ["limit"]),
+    };
+}
+function buildEditToolDetail(context) {
+    const { snapshot, firstLocation, textContent, diffContent, rawInput } = context;
+    return {
+        type: "edit",
+        filePath: firstLocation ?? readString(rawInput, ["path", "filePath", "file"]) ?? snapshot.title,
+        oldString: diffContent?.oldText ?? readString(rawInput, ["oldText", "oldString"]),
+        newString: snapshot.kind === "delete"
+            ? ""
+            : (diffContent?.newText ?? readString(rawInput, ["newText", "newString"])),
+        unifiedDiff: textContent ?? undefined,
+    };
+}
+function buildSearchAcpToolDetail(context) {
+    const { snapshot, textContent, rawInput, rawOutput } = context;
+    return {
+        type: "search",
+        query: readString(rawInput, ["query", "pattern"]) ?? snapshot.title,
+        toolName: "search",
+        content: textContent ?? readString(rawOutput, ["content", "text"]),
+        filePaths: snapshot.locations?.map((location) => location.path),
+    };
+}
+function buildShellToolDetail(context) {
+    const { snapshot, textContent, terminalContent, rawInput, rawOutput } = context;
+    return {
+        type: "shell",
+        command: terminalContent?.command ??
+            buildShellCommand(rawInput) ??
+            readString(rawInput, ["command"]) ??
+            snapshot.title,
+        cwd: terminalContent?.cwd ?? readString(rawInput, ["cwd"]),
+        output: terminalContent?.output ?? textContent ?? readString(rawOutput, ["output", "text"]),
+        exitCode: terminalContent?.exitCode ?? readNumber(rawOutput, ["exitCode"]),
+    };
+}
+function buildFetchToolDetail(context) {
+    const { snapshot, textContent, rawInput, rawOutput } = context;
+    return {
+        type: "fetch",
+        url: readString(rawInput, ["url"]) ?? snapshot.title,
+        prompt: readString(rawInput, ["prompt"]),
+        result: textContent ?? readString(rawOutput, ["result", "text", "content"]),
+        code: readNumber(rawOutput, ["status", "code"]),
+    };
+}
+function buildDefaultToolDetail(context) {
+    const { snapshot, textContent, terminalContent } = context;
+    if (terminalContent) {
+        return {
+            type: "shell",
+            command: terminalContent.command ?? snapshot.title,
+            cwd: terminalContent.cwd,
+            output: terminalContent.output,
+            exitCode: terminalContent.exitCode,
+        };
+    }
+    if (textContent) {
+        return {
+            type: "plain_text",
+            label: snapshot.title,
+            text: textContent,
+            icon: "wrench",
+        };
+    }
+    return {
+        type: "unknown",
+        input: snapshot.rawInput ?? null,
+        output: snapshot.rawOutput ?? null,
+    };
+}
+function extractToolText(content) {
+    if (!content) {
+        return undefined;
+    }
+    const parts = [];
+    for (const item of content) {
+        if (item.type === "content") {
+            const text = contentBlockToText(item.content);
+            if (text) {
+                parts.push(text);
+            }
+        }
+    }
+    return parts.length > 0 ? parts.join("\n") : undefined;
+}
+function extractDiffContent(content) {
+    const diff = content?.find((item) => item.type === "diff");
+    return diff ? { oldText: diff.oldText ?? undefined, newText: diff.newText } : null;
+}
+function extractTerminalContent(content, terminals) {
+    const terminal = content?.find((item) => item.type === "terminal");
+    if (!terminal) {
+        return undefined;
+    }
+    const entry = terminals.get(terminal.terminalId);
+    if (!entry) {
+        return undefined;
+    }
+    return {
+        output: entry.output,
+        exitCode: entry.exit?.exitCode ?? null,
+    };
+}
+function mapPermissionRequest(provider, requestId, params, snapshot) {
+    const kind = snapshot.kind === "switch_mode" ? "mode" : "tool";
+    const chooserText = isACPChooserRequest(params.options)
+        ? extractToolText(params.toolCall.content)
+        : undefined;
+    return {
+        id: requestId,
+        provider,
+        name: snapshot.kind ?? snapshot.title,
+        kind,
+        title: params.toolCall.title ?? snapshot.title,
+        detail: chooserText
+            ? {
+                type: "plain_text",
+                label: params.toolCall.title ?? snapshot.title,
+                text: chooserText,
+                icon: "wrench",
+            }
+            : mapToolDetail(snapshot, new Map()),
+        actions: params.options.map((option) => ({
+            id: option.optionId,
+            label: option.name,
+            behavior: option.kind.startsWith("allow") ? "allow" : "deny",
+        })),
+        metadata: {
+            toolCallId: params.toolCall.toolCallId,
+            rawRequest: params,
+            options: params.options,
+        },
+    };
+}
+function selectPermissionOption(options, response) {
+    if (response.selectedActionId !== undefined) {
+        const selectedOption = options.find((option) => option.optionId === response.selectedActionId);
+        if (!selectedOption)
+            return null;
+        const selectedBehavior = selectedOption.kind.startsWith("allow") ? "allow" : "deny";
+        return selectedBehavior === response.behavior ? selectedOption : null;
+    }
+    const order = response.behavior === "allow"
+        ? ["allow_once", "allow_always"]
+        : ["reject_once", "reject_always"];
+    for (const kind of order) {
+        const match = options.find((option) => option.kind === kind);
+        if (match) {
+            return match;
+        }
+    }
+    return null;
+}
+function isACPChooserRequest(options) {
+    const allowKinds = new Set();
+    for (const option of options) {
+        if (!option.kind.startsWith("allow")) {
+            continue;
+        }
+        if (allowKinds.has(option.kind)) {
+            return true;
+        }
+        allowKinds.add(option.kind);
+    }
+    return false;
+}
+function appendTerminalOutput(entry, chunk) {
+    entry.output += chunk;
+    const limit = entry.outputByteLimit;
+    if (!limit) {
+        return;
+    }
+    while (Buffer.byteLength(entry.output, "utf8") > limit && entry.output.length > 0) {
+        entry.output = entry.output.slice(1);
+        entry.truncated = true;
+    }
+}
+function readRecord(value) {
+    return isRecord(value) ? value : null;
+}
+function readString(record, keys) {
+    if (!record) {
+        return undefined;
+    }
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function readNumber(record, keys) {
+    if (!record) {
+        return undefined;
+    }
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function buildShellCommand(record) {
+    if (!record) {
+        return undefined;
+    }
+    const command = readString(record, ["command"]);
+    const args = Array.isArray(record["args"])
+        ? record["args"].filter((value) => typeof value === "string")
+        : [];
+    if (!command) {
+        return undefined;
+    }
+    return args.length > 0 ? `${command} ${args.join(" ")}` : command;
+}
+function readErrorMessage(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    const record = readRecord(value);
+    return readString(record, ["message", "error"]) ?? "Tool call failed";
+}
+function stringifyUnknown(value) {
+    if (value == null) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return typeof value === "bigint" ? String(value) : "[unserializable]";
+    }
+}
+function coerceSessionConfigMetadata(metadata) {
+    if (!metadata || typeof metadata !== "object") {
+        return {};
+    }
+    return metadata;
+}
+async function terminateChildProcess(child, timeoutMs, terminate) {
+    try {
+        await terminate(child, { gracefulTimeoutMs: timeoutMs, forceTimeoutMs: timeoutMs });
+    }
+    finally {
+        child.stdin.destroy();
+        child.stdout.destroy();
+        child.stderr.destroy();
+    }
+}
+//# sourceMappingURL=acp-agent.js.map