@prestyj/cli 5.9.0 → 5.11.0

package/dist/modes/acp-mode.js

@@ -0,0 +1,1366 @@
+/**
+ * ACP mode: expose EZ Coder as an Agent Client Protocol agent over stdio.
+ *
+ * This is the integration surface for ACP clients (Zed, pew2, any editor that
+ * speaks the protocol). It is deliberately a sibling of `rpc-mode.ts` — same
+ * shape, same `AgentSession`, same NDJSON-on-stdio transport — but the frames
+ * are the standard protocol instead of ezcoder's bespoke one, so a client
+ * written against the spec works with no ezcoder-specific code.
+ *
+ * Spec: https://agentclientprotocol.com/protocol/overview
+ *
+ * Scope: `initialize`, `session/new`, `session/prompt`, `session/cancel`,
+ * `session/list`, `session/load`, `session/resume`, `session/close`,
+ * `session/delete`, `session/set_mode` and `session/set_config_option`.
+ * Everything advertised in `agentCapabilities` is implemented, because a client
+ * must be able to trust that list — advertising a method that then errors is
+ * worse than advertising nothing.
+ *
+ * stdout carries protocol frames ONLY. Anything diagnostic goes to stderr or
+ * the log file; a stray `console.log` anywhere in the process corrupts the
+ * stream and the client disconnects.
+ */
+import readline from "node:readline";
+import path from "node:path";
+import { readFileSync, statSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { isAbortError } from "@prestyj/agent";
+import { getAllModels, getMaxThinkingLevel, getModel } from "@prestyj/core";
+import { AgentSession } from "../core/agent-session.js";
+import { PROMPT_COMMANDS } from "../core/prompt-commands.js";
+import { loadCustomCommands } from "../core/custom-commands.js";
+import { findSessionById, listAllSessions, listSessionSummaries, loadSessionCheckpointChain, } from "../session.js";
+import { getHistoryMessageVisibility, reconstructCheckpointHistory, restoreUserRow, } from "../core/session-history.js";
+import { findUserSessionPrompt } from "../core/session-preview.js";
+import { sessionGroupPaths } from "../core/session-storage.js";
+import { extractPlanSteps, findCompletedMarkers, markStepsCompleted, rebasePlanSteps, } from "../utils/plan-steps.js";
+import { formatUserError } from "../utils/error-handler.js";
+import { closeLogger } from "../core/logger.js";
+/** The ACP major version this mode implements. Bumped only for breaking changes. */
+export const ACP_PROTOCOL_VERSION = 1;
+/** JSON-RPC 2.0 reserved codes. ACP adds no codes of its own. */
+const RPC_PARSE_ERROR = -32700;
+const RPC_INVALID_REQUEST = -32600;
+const RPC_METHOD_NOT_FOUND = -32601;
+const RPC_INVALID_PARAMS = -32602;
+const RPC_INTERNAL_ERROR = -32603;
+/**
+ * The client asked for something impossible, as opposed to the agent failing.
+ *
+ * Typed rather than sniffed from the message text, so that a client can tell a
+ * bug in its own sequencing from an agent that fell over — and so that a later
+ * reworded message cannot silently change the code on the wire.
+ */
+class InvalidParams extends Error {
+}
+// ── Tool mapping ───────────────────────────────────────────
+/**
+ * ezcoder tool name → ACP `ToolKind`.
+ *
+ * Purely cosmetic on the client (icon + progress treatment), so an unmapped
+ * tool falls back to `other` rather than failing. Keep in step with
+ * `src/tools/index.ts` as tools are added.
+ */
+const TOOL_KINDS = {
+    read: "read",
+    ls: "read",
+    find: "read",
+    grep: "search",
+    code_search: "search",
+    web_search: "search",
+    edit: "edit",
+    write: "edit",
+    bash: "execute",
+    screenshot: "execute",
+    web_fetch: "fetch",
+    source_path: "fetch",
+    subagent: "think",
+    spawn_agent: "think",
+    enter_plan: "switch_mode",
+    exit_plan: "switch_mode",
+};
+function toolKind(name) {
+    return TOOL_KINDS[name] ?? "other";
+}
+/**
+ * A one-line tool title for the client's activity list.
+ *
+ * The first string-ish argument is nearly always the interesting one (a path, a
+ * command, a query), and it is truncated because this renders on a phone.
+ */
+function toolTitle(name, args) {
+    for (const value of Object.values(args)) {
+        if (typeof value !== "string" || value.length === 0)
+            continue;
+        const flat = value.replace(/\s+/g, " ").trim();
+        const clipped = flat.length > 80 ? `${flat.slice(0, 79)}…` : flat;
+        return `${name}(${clipped})`;
+    }
+    return name;
+}
+// ── Tool locations ─────────────────────────────────────────
+/**
+ * Argument names that hold the path a tool works on, most specific first.
+ *
+ * Deliberately a small allowlist rather than "any string that looks like a
+ * path": `bash`'s command and `web_fetch`'s url would both pass a heuristic and
+ * both would send the client's editor somewhere that does not exist.
+ */
+const PATH_ARG_KEYS = ["file_path", "path", "out_path"];
+/**
+ * The file a tool call touches, which is what drives "follow the agent" in a
+ * client: the editor jumps to whatever GG is reading or editing right now.
+ *
+ * Paths are resolved to absolute against the session cwd, because the client
+ * runs somewhere else entirely and cannot know what a relative path was
+ * relative to. A wrong location is worse than none, so anything unrecognised
+ * reports nothing.
+ */
+function toolLocations(args, cwd) {
+    for (const key of PATH_ARG_KEYS) {
+        const value = args[key];
+        if (typeof value !== "string" || !value)
+            continue;
+        const absolute = path.isAbsolute(value) ? value : path.resolve(cwd, value);
+        // `read`'s offset is a 1-based line, which is exactly what ACP wants for
+        // scrolling the client to the region being looked at.
+        const offset = args.offset;
+        return typeof offset === "number" && Number.isInteger(offset) && offset > 0
+            ? [{ path: absolute, line: offset }]
+            : [{ path: absolute }];
+    }
+    return [];
+}
+// ── File diffs ─────────────────────────────────────────────
+/** Tools whose whole purpose is changing a file's contents. */
+const DIFF_TOOLS = new Set(["edit", "write"]);
+/**
+ * Largest file we will snapshot to build a diff.
+ *
+ * The contents cross the wire twice (old and new) and are read on the event
+ * loop, so a generated bundle or lockfile would stall the turn and flood the
+ * client with a diff no human is going to read.
+ */
+const MAX_DIFF_BYTES = 256 * 1024;
+/**
+ * Read a file for diffing, SYNCHRONOUSLY and on purpose.
+ *
+ * The "before" snapshot is taken inside the `tool_call_start` handler, and the
+ * tool it belongs to begins writing in the same tick. An async read would race
+ * that write and could capture the file as it is AFTER the edit, which renders
+ * in the client as a real change with an empty diff.
+ */
+function snapshotForDiff(filePath) {
+    let size;
+    try {
+        size = statSync(filePath).size;
+    }
+    catch {
+        // Missing: `write` creating a new file. ACP represents that as a null
+        // `oldText`, which clients render as an all-additions diff.
+        return { text: null };
+    }
+    if (size > MAX_DIFF_BYTES)
+        return undefined;
+    try {
+        return { text: readFileSync(filePath, "utf8") };
+    }
+    catch {
+        return undefined;
+    }
+}
+// ── Plans ──────────────────────────────────────────────────
+/**
+ * GG's plan steps as ACP plan entries.
+ *
+ * ACP requires a priority per entry and GG's plans have no such concept, so
+ * every entry reports `medium` rather than inventing a ranking the user never
+ * expressed. The first unfinished step is reported `in_progress`: entries are
+ * worked in order, so this is what the agent is actually doing now, and it
+ * gives the client a live marker instead of a list that only ever flips from
+ * pending to completed.
+ */
+function planEntries(steps) {
+    let activeMarked = false;
+    return steps.map((step) => {
+        let status;
+        if (step.completed) {
+            status = "completed";
+        }
+        else if (activeMarked) {
+            status = "pending";
+        }
+        else {
+            activeMarked = true;
+            status = "in_progress";
+        }
+        return { content: step.text, priority: "medium", status };
+    });
+}
+/** Read a plan markdown file, or empty string when it has gone missing. */
+function readPlanFile(planPath) {
+    try {
+        return readFileSync(planPath, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Why the current prompt turn ended.
+ *
+ * ACP has a closed set; ezcoder's `turn_end` carries whatever the provider
+ * said. Only the reasons that map cleanly are translated — everything else is
+ * a normal completion, which is what the client renders anyway.
+ */
+function stopReasonFor(truncation, hitMaxTurns) {
+    if (hitMaxTurns)
+        return "max_turn_requests";
+    if (truncation === "max_tokens")
+        return "max_tokens";
+    if (truncation === "refusal")
+        return "refusal";
+    return "end_turn";
+}
+// ── Config options ─────────────────────────────────────
+/** The selectors this agent exposes. Ids are part of the wire contract. */
+export const MODEL_CONFIG_ID = "model";
+export const THINKING_CONFIG_ID = "thinking";
+export const MODE_CONFIG_ID = "mode";
+/** ACP session modes, mapped onto GG's plan mode. */
+const MODE_DEFAULT = "default";
+const MODE_PLAN = "plan";
+/** Thinking off is a real choice, so it needs a value id of its own. */
+const THINKING_OFF = "off";
+const THINKING_LADDER = [
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+    "ultra",
+];
+/**
+ * Thinking levels this model actually honours, hardest last.
+ *
+ * Offering levels above the model's ceiling would let a phone pick a setting
+ * that silently degrades to something else — a control that lies.
+ */
+function thinkingOptionsFor(modelId) {
+    const ceiling = getMaxThinkingLevel(modelId);
+    const top = THINKING_LADDER.indexOf(ceiling);
+    const levels = THINKING_LADDER.slice(0, top < 0 ? THINKING_LADDER.length : top + 1);
+    return [
+        { value: THINKING_OFF, name: "Off", description: "No extended reasoning" },
+        ...levels.map((level) => ({ value: level, name: level })),
+    ];
+}
+/**
+ * The selectors a client renders for a session, with their live values.
+ *
+ * Model and thinking come from ezcoder's own registry rather than anything
+ * pew2- or Zed-specific, which is what lets a phone show EZ Coder's real model
+ * list without either side hard-coding the other's.
+ */
+function configOptionsFor(session) {
+    const { model } = session.getState();
+    const thinking = session.getThinkingLevel();
+    return [
+        {
+            id: MODEL_CONFIG_ID,
+            name: "Model",
+            category: "model",
+            type: "select",
+            currentValue: model,
+            options: getAllModels().map((entry) => ({
+                value: entry.id,
+                name: entry.name,
+                description: entry.provider,
+            })),
+        },
+        {
+            id: THINKING_CONFIG_ID,
+            name: "Thinking",
+            description: "Extended reasoning effort",
+            category: "thought_level",
+            type: "select",
+            // A model that cannot think reports `off`, which is the truth rather than
+            // a level it would ignore.
+            currentValue: getModel(model)?.supportsThinking ? (thinking ?? THINKING_OFF) : THINKING_OFF,
+            options: thinkingOptionsFor(model),
+        },
+        {
+            id: MODE_CONFIG_ID,
+            name: "Mode",
+            description: "Plan mode is read-only research until a plan is approved",
+            category: "mode",
+            type: "select",
+            currentValue: session.getPlanMode() ? MODE_PLAN : MODE_DEFAULT,
+            options: [
+                { value: MODE_DEFAULT, name: "Default", description: "Full tool access" },
+                { value: MODE_PLAN, name: "Plan", description: "Read-only until exit_plan" },
+            ],
+        },
+    ];
+}
+/** What a prompt-template command does with whatever follows the name. */
+const TEMPLATE_ARG_HINT = "extra instructions (optional)";
+/**
+ * The argument hint for a registry command, taken from its own usage string.
+ *
+ * `/add-dir [path] — no path lists the current roots` becomes `[path]`: the
+ * client renders a hint, not a man page, and the prose after the dash is the
+ * description's job.
+ */
+function hintFromUsage(name, usage) {
+    const withoutName = usage.replace(new RegExp(`^\\s*/${name}\\b`), "").trim();
+    const hint = withoutName.split("—")[0].split(" - ")[0].trim();
+    return hint ? { hint } : undefined;
+}
+/**
+ * Every slash command this session would actually honour, in the precedence
+ * `AgentSession.resolveSlashInput` uses: built-in prompt templates, then
+ * `.ezcoder/commands/*.md` from the project, then registry commands.
+ *
+ * That order is not cosmetic. `resolveSlashInput` looks for a template body
+ * FIRST and only falls through to the registry when there is none, so a project
+ * file named `new.md` really does shadow the registry's `/new`. Listing the
+ * registry entry for that name would point a client's user at a description of
+ * something the agent will not run.
+ *
+ * Names already claimed — including a built-in's ALIASES, which
+ * `getPromptCommand` matches — are dropped rather than listed twice.
+ */
+async function availableCommands(session, cwd) {
+    const commands = [];
+    const taken = new Set();
+    const add = (command) => {
+        if (taken.has(command.name))
+            return;
+        taken.add(command.name);
+        commands.push(command);
+    };
+    for (const command of PROMPT_COMMANDS) {
+        for (const alias of command.aliases)
+            taken.add(alias);
+        add({
+            name: command.name,
+            description: command.description,
+            input: { hint: TEMPLATE_ARG_HINT },
+        });
+    }
+    // Project commands are files on disk, so a client that never rescans still
+    // gets whatever existed when the session opened.
+    for (const command of await loadCustomCommands(cwd)) {
+        add({
+            name: command.name,
+            description: command.description,
+            input: { hint: TEMPLATE_ARG_HINT },
+        });
+    }
+    // Last: anything above with the same NAME beats a registry command. An alias
+    // collision does not, so aliases are deliberately not claimed here — a
+    // project `q.md` shadows `/q` without hiding `/quit` itself.
+    for (const command of session.slashCommands?.getAll() ?? []) {
+        add({
+            name: command.name,
+            description: command.description,
+            input: hintFromUsage(command.name, command.usage),
+        });
+    }
+    return commands;
+}
+/** The `modes` block ACP clients like Zed read from session/new and session/load. */
+function sessionModes(session) {
+    return {
+        currentModeId: session.getPlanMode() ? MODE_PLAN : MODE_DEFAULT,
+        availableModes: [
+            { id: MODE_DEFAULT, name: "Default", description: "Full tool access" },
+            { id: MODE_PLAN, name: "Plan", description: "Read-only research until a plan is approved" },
+        ],
+    };
+}
+// ── History replay ───────────────────────────────────
+/** Flatten a persisted message's content to the text a client would show. */
+function messageText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((block) => block?.type === "text")
+        .map((block) => block.text ?? "")
+        .join("");
+}
+/**
+ * Turn a restored conversation into the `session/update` stream a client needs
+ * to draw it.
+ *
+ * ACP has no "here is the transcript" response: a loaded session is replayed as
+ * the same notifications a live turn produces, so the client needs no second
+ * rendering path. Thinking is deliberately NOT replayed — it is transient by
+ * design, and a wall of stale reasoning above a resumed conversation buries the
+ * thing the user came back for.
+ *
+ * Each replayed chunk carries a `messageId` so a client can group chunks into
+ * the messages they came from; ids are per-replay and positional, which is all
+ * the protocol needs of them.
+ */
+export function historyUpdates(messages) {
+    const updates = [];
+    let replayed = 0;
+    const nextMessageId = () => `hist-${++replayed}`;
+    for (const message of messages) {
+        if (getHistoryMessageVisibility(message) === "hidden")
+            continue;
+        if (message.role === "user") {
+            const restored = restoreUserRow(message.content, message.provenance);
+            if (restored.autopilotInjected || restored.notification)
+                continue;
+            if (restored.text) {
+                updates.push({
+                    sessionUpdate: "user_message_chunk",
+                    messageId: nextMessageId(),
+                    content: { type: "text", text: restored.text },
+                });
+            }
+            continue;
+        }
+        if (message.role === "assistant") {
+            const text = messageText(message.content);
+            if (text) {
+                updates.push({
+                    sessionUpdate: "agent_message_chunk",
+                    messageId: nextMessageId(),
+                    content: { type: "text", text },
+                });
+            }
+            if (Array.isArray(message.content)) {
+                for (const block of message.content) {
+                    if (block.type !== "tool_call")
+                        continue;
+                    const call = block;
+                    const args = call.args ?? {};
+                    updates.push({
+                        sessionUpdate: "tool_call",
+                        toolCallId: call.id,
+                        title: toolTitle(call.name, args),
+                        name: call.name,
+                        kind: toolKind(call.name),
+                        // History is settled: a replayed call that still said `in_progress`
+                        // would leave a spinner running forever on a resumed session.
+                        status: "completed",
+                        rawInput: args,
+                    });
+                }
+            }
+            continue;
+        }
+        for (const result of message.content) {
+            const entry = result;
+            updates.push({
+                sessionUpdate: "tool_call_update",
+                toolCallId: entry.toolCallId,
+                status: entry.isError ? "failed" : "completed",
+                content: [
+                    {
+                        type: "content",
+                        content: { type: "text", text: messageText(entry.content) },
+                    },
+                ],
+            });
+        }
+    }
+    return updates;
+}
+// ── Mode ───────────────────────────────────────────────────
+/**
+ * Serve ACP on stdio until the input stream ends.
+ *
+ * Resolves when the client disconnects; the caller owns process exit.
+ */
+export async function runAcpMode(options) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    function write(frame) {
+        output.write(`${JSON.stringify(frame)}\n`);
+    }
+    function respond(id, result) {
+        write({ jsonrpc: "2.0", id, result });
+    }
+    function fail(id, code, message) {
+        write({ jsonrpc: "2.0", id, error: { code, message } });
+    }
+    /**
+     * The single session this process serves.
+     *
+     * ACP allows many per connection, but an ACP client spawns one agent process
+     * per session anyway, and `AgentSession` owns process-wide state (cwd, tool
+     * registry, session file). One-per-process is the honest model; a second
+     * `session/new` replaces the first rather than pretending to multiplex.
+     */
+    let session = null;
+    let sessionId = "";
+    let abort = new AbortController();
+    /** Set while a `session/prompt` is in flight, so a second one is rejected. */
+    let running = false;
+    let cancelled = false;
+    let truncation;
+    let hitMaxTurns = false;
+    /** Detaches every event listener when the session is replaced or disposed. */
+    let unwire = [];
+    /**
+     * Chunk grouping. A message runs until something interrupts it — a tool call
+     * or the end of the turn — so the id is minted lazily on the first chunk and
+     * dropped at those boundaries, which is exactly where the client should start
+     * a new bubble.
+     */
+    let messageSeq = 0;
+    let currentMessageId = null;
+    /** Before-snapshots for in-flight `edit`/`write` calls, keyed by tool call. */
+    const diffSnapshots = new Map();
+    /** The approved plan being implemented, and how far through it the agent is. */
+    let planPath;
+    let planSteps = [];
+    const completedSteps = new Set();
+    /** This turn's assistant text, scanned for `[DONE:n]` markers. */
+    let turnText = "";
+    /** Whether this session has already announced a title to the client. */
+    let titleAnnounced = false;
+    function notifyUpdate(update) {
+        write({
+            jsonrpc: "2.0",
+            method: "session/update",
+            params: { sessionId, update },
+        });
+    }
+    /**
+     * Report context-window usage to the client.
+     *
+     * Sent whenever token accounting moves — after each model response and after
+     * a compaction — because a client's context meter is otherwise frozen at
+     * whatever it last inferred. Compaction is only visible to a client as a drop
+     * in `used` at unchanged `size`, so the post-compaction emit is what makes
+     * that detectable at all.
+     *
+     * `used`/`size` are required by the schema; a session that cannot count
+     * tokens sends nothing rather than a zero, which would render as an empty
+     * context the user does not have.
+     */
+    function notifyUsage(target = session) {
+        if (!target || target !== session || !sessionId)
+            return;
+        const usage = target.getContextUsage?.();
+        if (!usage || !Number.isFinite(usage.used) || !Number.isFinite(usage.size))
+            return;
+        notifyUpdate({
+            sessionUpdate: "usage_update",
+            used: usage.used,
+            size: usage.size,
+            ...(usage.costUsd === undefined ? {} : { cost: { amount: usage.costUsd, currency: "USD" } }),
+        });
+    }
+    /**
+     * State for a session that was just created or restored, sent after the
+     * response that told the client the session exists.
+     *
+     * Same deferral (and same staleness guard) as {@link notifyAvailableCommands}:
+     * a notification addressed to a sessionId the client has not seen yet has
+     * nowhere to land. Without this a resumed conversation shows no usage and no
+     * title until its first reply, which is exactly when they matter least.
+     */
+    function announceSessionSoon(target) {
+        const forSession = sessionId;
+        setTimeout(() => {
+            if (session !== target || sessionId !== forSession)
+                return;
+            notifyUsage(target);
+            notifySessionInfo(target);
+        }, 0);
+    }
+    /**
+     * The id chunks of the current agent message share, minted on demand.
+     */
+    function messageId() {
+        currentMessageId ??= `msg-${++messageSeq}`;
+        return currentMessageId;
+    }
+    /** Start a new message at the next chunk (tool call, or end of turn). */
+    function endMessage() {
+        currentMessageId = null;
+    }
+    /**
+     * Send the whole plan, which is what ACP requires: the client REPLACES its
+     * copy on every update rather than patching it, so a partial list would
+     * silently delete steps.
+     */
+    function notifyPlan() {
+        if (planSteps.length === 0)
+            return;
+        notifyUpdate({ sessionUpdate: "plan", entries: planEntries(planSteps) });
+    }
+    /**
+     * Adopt a freshly approved plan and show it to the client as a to-do list.
+     *
+     * Progress resets with the plan: `[DONE:n]` markers are relative to the plan
+     * that was approved, so carrying completions across a new one would mark
+     * steps of the new plan done that nobody has started.
+     */
+    function adoptPlan(approvedPath) {
+        planPath = approvedPath;
+        planSteps = extractPlanSteps(readPlanFile(approvedPath));
+        completedSteps.clear();
+        notifyPlan();
+    }
+    /**
+     * Advance the plan from `[DONE:n]` markers in the agent's own text.
+     *
+     * The plan is re-read rather than trusted from approval time because the
+     * agent is allowed to rewrite it while implementing (a 2-step plan becoming
+     * 12 is normal), and a frozen snapshot would report the wrong total and drop
+     * markers for steps it has never heard of.
+     */
+    function refreshPlanProgress() {
+        if (planSteps.length === 0)
+            return;
+        let advanced = false;
+        for (const step of findCompletedMarkers(turnText)) {
+            if (completedSteps.has(step))
+                continue;
+            completedSteps.add(step);
+            advanced = true;
+        }
+        if (!advanced)
+            return;
+        const fresh = planPath ? extractPlanSteps(readPlanFile(planPath)) : [];
+        planSteps = markStepsCompleted(rebasePlanSteps(planSteps, fresh), completedSteps);
+        notifyPlan();
+    }
+    /**
+     * Give the session a human-readable title, once.
+     *
+     * ACP expects this "after the first meaningful exchange", and GG already
+     * derives the same first-prompt title for its own session list — reusing it
+     * means a session is named identically on a phone, in the picker, and on
+     * disk instead of three near-misses.
+     */
+    function notifySessionInfo(target) {
+        if (titleAnnounced || target !== session || !sessionId)
+            return;
+        const prompt = findUserSessionPrompt(target.getMessages()).replace(/\s+/g, " ").trim();
+        if (!prompt)
+            return;
+        titleAnnounced = true;
+        notifyUpdate({
+            sessionUpdate: "session_info_update",
+            title: prompt.length > 80 ? `${prompt.slice(0, 79)}…` : prompt,
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    /**
+     * Tell the client the session mode changed outside a request it made — the
+     * model itself can enter/exit plan mode mid-run via the enter_plan/exit_plan
+     * tools, and a picker that only tracks its own changes would lie.
+     */
+    function notifyModeChange(modeId) {
+        if (!session)
+            return;
+        notifyUpdate({ sessionUpdate: "current_mode_update", currentModeId: modeId });
+        notifyUpdate({
+            sessionUpdate: "config_option_update",
+            configOptions: configOptionsFor(session),
+        });
+    }
+    /**
+     * Tell the client which slash commands exist, once the session is up.
+     *
+     * Sent as a notification AFTER the response that created the session (a
+     * timer, not a microtask, so it cannot overtake it): the payload is addressed
+     * by sessionId, and a client that has not yet seen its own session/new result
+     * has nowhere to put it. The agent is the only party that can know its
+     * built-ins, so a client scanning `.ezcoder/commands` on its own would miss them.
+     */
+    function notifyAvailableCommands(target) {
+        const forSession = sessionId;
+        setTimeout(() => {
+            // A second session/new (or a dispose) beat us here; that session will
+            // announce its own commands.
+            if (session !== target || sessionId !== forSession)
+                return;
+            void availableCommands(target, options.cwd)
+                .then((commands) => {
+                if (session !== target || sessionId !== forSession)
+                    return;
+                notifyUpdate({
+                    sessionUpdate: "available_commands_update",
+                    availableCommands: commands,
+                });
+            })
+                // Command discovery reads the disk. A failure there must not take down
+                // a session that is otherwise fine.
+                .catch(() => { });
+        }, 0);
+    }
+    /**
+     * The finished tool call's result as an ACP file diff, or undefined when we
+     * cannot honestly produce one.
+     *
+     * A real diff is what lets a client render a reviewable side-by-side edit
+     * instead of a wall of text. It REPLACES the tool's text result rather than
+     * accompanying it: `edit` already returns a unified diff as prose, and
+     * showing both means the same change twice in two formats.
+     *
+     * A failed call is left as text on purpose — the error message is the useful
+     * output, and the file on disk did not change.
+     */
+    function diffContent(toolCallId, isError) {
+        const snapshot = diffSnapshots.get(toolCallId);
+        if (!snapshot)
+            return undefined;
+        diffSnapshots.delete(toolCallId);
+        if (isError || !snapshot.before)
+            return undefined;
+        const after = snapshotForDiff(snapshot.path);
+        // `newText` is required by the schema, so a file that vanished or grew past
+        // the diff budget mid-call falls back to the tool's own text output.
+        if (!after || after.text === null)
+            return undefined;
+        return [
+            {
+                type: "diff",
+                path: snapshot.path,
+                oldText: snapshot.before.text,
+                newText: after.text,
+            },
+        ];
+    }
+    /**
+     * Bridge ezcoder's event bus onto `session/update` notifications.
+     *
+     * Every handler is synchronous and writes immediately, which is what keeps
+     * updates ordered ahead of the `session/prompt` response — a client that sees
+     * the result before the chunks renders an empty turn.
+     */
+    function wire(target) {
+        const bus = target.eventBus;
+        unwire = [
+            bus.on("text_delta", ({ text }) => {
+                notifyUpdate({
+                    sessionUpdate: "agent_message_chunk",
+                    messageId: messageId(),
+                    content: { type: "text", text },
+                });
+                // Plan markers arrive inside this text and can straddle two deltas, so
+                // the scan runs over the turn's accumulated text rather than the chunk.
+                // Only a delta that closes a bracket can complete a marker, which keeps
+                // this from re-scanning the whole turn on every token.
+                turnText += text;
+                if (text.includes("]"))
+                    refreshPlanProgress();
+            }),
+            bus.on("thinking_delta", ({ text }) => {
+                notifyUpdate({
+                    sessionUpdate: "agent_thought_chunk",
+                    content: { type: "text", text },
+                });
+            }),
+            bus.on("tool_call_start", ({ toolCallId, name, args }) => {
+                // A tool call ends the message it interrupted; whatever the agent says
+                // afterwards is a new one.
+                endMessage();
+                const locations = toolLocations(args, options.cwd);
+                // Snapshot BEFORE the tool runs. This handler is synchronous and the
+                // tool starts writing immediately after it, which is the only window
+                // where the file still holds its pre-edit contents.
+                if (DIFF_TOOLS.has(name) && locations[0]) {
+                    diffSnapshots.set(toolCallId, {
+                        path: locations[0].path,
+                        before: snapshotForDiff(locations[0].path),
+                    });
+                }
+                notifyUpdate({
+                    sessionUpdate: "tool_call",
+                    toolCallId,
+                    title: toolTitle(name, args),
+                    name,
+                    kind: toolKind(name),
+                    status: "in_progress",
+                    rawInput: args,
+                    ...(locations.length > 0 ? { locations } : {}),
+                });
+            }),
+            // Mid-flight tool progress. The payload is tool-defined, so it rides in
+            // `rawOutput` rather than being invented into content the client would
+            // then render as if it were final.
+            bus.on("tool_call_update", ({ toolCallId, update }) => {
+                notifyUpdate({
+                    sessionUpdate: "tool_call_update",
+                    toolCallId,
+                    status: "in_progress",
+                    rawOutput: update,
+                });
+            }),
+            bus.on("tool_call_end", ({ toolCallId, result, isError }) => {
+                notifyUpdate({
+                    sessionUpdate: "tool_call_update",
+                    toolCallId,
+                    status: isError ? "failed" : "completed",
+                    content: diffContent(toolCallId, isError) ?? [
+                        { type: "content", content: { type: "text", text: result } },
+                    ],
+                });
+            }),
+            // Turn-level outcomes are remembered rather than sent: ACP reports them
+            // once, as the `stopReason` of the prompt response.
+            bus.on("truncated", ({ reason }) => {
+                truncation = reason;
+            }),
+            bus.on("max_turns", () => {
+                hitMaxTurns = true;
+            }),
+            // Token accounting changes: after every model response, and after a
+            // compaction rebuilds the context. `compaction_end` fires once the
+            // compacted messages are installed, so the emit carries the POST-
+            // compaction count — the drop the client watches for.
+            bus.on("turn_end", () => {
+                notifyUsage(target);
+                notifySessionInfo(target);
+                // The turn is over: the next chunk starts a new message, and the next
+                // turn's markers are scanned against its own text.
+                endMessage();
+                turnText = "";
+            }),
+            bus.on("compaction_end", () => {
+                notifyUsage(target);
+            }),
+        ];
+    }
+    function unwireAll() {
+        for (const off of unwire)
+            off();
+        unwire = [];
+    }
+    /**
+     * Drop everything scoped to one session's lifetime. A new session inherits
+     * none of it: another session's plan progress, half-finished diffs or message
+     * numbering would all be reported as if they were its own.
+     */
+    function resetSessionState() {
+        diffSnapshots.clear();
+        planPath = undefined;
+        planSteps = [];
+        completedSteps.clear();
+        turnText = "";
+        titleAnnounced = false;
+        currentMessageId = null;
+        messageSeq = 0;
+    }
+    async function disposeSession() {
+        if (!session)
+            return;
+        unwireAll();
+        resetSessionState();
+        const previous = session;
+        session = null;
+        sessionId = "";
+        await previous.dispose();
+    }
+    /**
+     * Plan mode. Supplying these callbacks is what registers the
+     * enter_plan/exit_plan tools at all — without them the mode exists but the
+     * model cannot move between states. EZ Coder runs without approvals, so a
+     * submitted plan is auto-approved, the [DONE:n] contract is baked in so
+     * progress markers work as on the desktop, and the client is told about every
+     * mode change.
+     *
+     * They act on the CURRENT session rather than closing over one: a tool can
+     * only run inside a prompt, which is long after `startSession` published it.
+     */
+    const planHooks = {
+        onEnterPlan: async () => {
+            await session?.setPlanMode(true);
+            notifyModeChange(MODE_PLAN);
+        },
+        onExitPlan: async (approvedPath) => {
+            await session?.setPlanMode(false);
+            await session?.setApprovedPlan(approvedPath);
+            notifyModeChange(MODE_DEFAULT);
+            // The approved plan becomes the client's to-do list, which then advances
+            // from the [DONE:n] markers the returned instruction asks for.
+            adoptPlan(approvedPath);
+            return "Plan approved. Proceed with implementation, marking each completed step with [DONE:n].";
+        },
+    };
+    const createSession = options.createSession ??
+        ((signal, hooks) => new AgentSession({
+            provider: options.provider,
+            model: options.model,
+            cwd: options.cwd,
+            baseUrl: options.baseUrl,
+            systemPrompt: options.systemPrompt,
+            thinkingLevel: options.thinkingLevel,
+            // MCP connect (spawning stdio servers, HTTP handshakes) takes seconds
+            // and would otherwise sit on the critical path of session/new and
+            // session/load. The desktop sidecar already ships this path: the tool
+            // catalog is seeded from the disk cache so tools are visible
+            // immediately, and live connections promote in the background. A phone
+            // client gets its session in milliseconds and the same tools a moment
+            // later.
+            backgroundMcpConnect: true,
+            onEnterPlan: hooks.onEnterPlan,
+            onExitPlan: hooks.onExitPlan,
+            signal,
+        }));
+    // ── Method handlers ──────────────────────────────────────
+    function handleInitialize() {
+        return {
+            protocolVersion: ACP_PROTOCOL_VERSION,
+            agentCapabilities: {
+                loadSession: true,
+                promptCapabilities: { image: false, audio: false, embeddedContext: false },
+                mcpCapabilities: { http: false, sse: false, acp: false },
+                // `{}` is how ACP says "supported" for a capability with no options of
+                // its own. Omitting the key means unsupported, so this is not cosmetic.
+                sessionCapabilities: { list: {}, resume: {}, close: {}, delete: {} },
+            },
+            authMethods: [],
+            agentInfo: { name: "ezcoder", title: "EZ Coder", version: options.version },
+        };
+    }
+    /**
+     * Start a session, optionally replaying a stored one into it.
+     *
+     * `session/new` and `session/load` differ only in whether history is
+     * restored first, so they share this path rather than drifting apart.
+     */
+    async function startSession(restorePath) {
+        // Replacing an in-flight session would strand the prompt that is running
+        // on it, so the old one is stopped first, deliberately and visibly.
+        await disposeSession();
+        abort = new AbortController();
+        const created = createSession(abort.signal, planHooks);
+        await created.initialize();
+        if (restorePath)
+            await created.loadSession(restorePath);
+        session = created;
+        sessionId = created.getState().sessionId;
+        wire(created);
+        return created;
+    }
+    async function handleNewSession() {
+        const created = await startSession();
+        notifyAvailableCommands(created);
+        announceSessionSoon(created);
+        return { sessionId, configOptions: configOptionsFor(created), modes: sessionModes(created) };
+    }
+    /** The directory a request is about, defaulting to the one we were started in. */
+    function requestCwd(params) {
+        const cwd = params?.cwd;
+        return typeof cwd === "string" && cwd ? cwd : options.cwd;
+    }
+    /**
+     * Stored sessions, newest first.
+     *
+     * This is the answer to "see everything that was on EZ Coder": the phone asks
+     * the agent, and the agent reads the same `~/.ezcoder/sessions` files the desktop
+     * browses — no separate index to fall out of step.
+     *
+     * ACP makes `cwd` nullable here on purpose. Omitted means EVERY project, not
+     * the agent's own directory: a remote client is asking what you have been
+     * working on, and that spans checkouts. Each entry carries its own `cwd` so
+     * the client can group by project.
+     */
+    async function handleListSessions(params) {
+        const scope = params?.cwd;
+        const stored = typeof scope === "string" && scope
+            ? await listSessionSummaries(scope)
+            : await listAllSessions();
+        return {
+            sessions: stored
+                // An empty session has nothing to resume and nothing to title; listing
+                // it would fill the phone with identical blank rows.
+                .filter((entry) => entry.hasMessages)
+                .map((entry) => ({
+                sessionId: entry.id,
+                cwd: entry.cwd,
+                // Captured during the listing pass, so titling the whole machine's
+                // history costs no extra reads.
+                title: entry.preview ?? null,
+                updatedAt: entry.lastActivity,
+            })),
+        };
+    }
+    /**
+     * Resume a stored session and replay it to the client.
+     *
+     * The transcript is streamed as `session/update` notifications BEFORE this
+     * resolves, which is what the protocol requires and what lets a client draw a
+     * resumed conversation with its normal live-turn rendering.
+     */
+    async function handleLoadSession(params) {
+        const requested = params?.sessionId;
+        if (typeof requested !== "string" || !requested) {
+            throw new InvalidParams("session/load requires a sessionId.");
+        }
+        // Searched by id across every project directory, not just `cwd`: a client
+        // lists sessions from wherever it probed and reopens them against the
+        // directory the session belongs to, so those two rarely match.
+        const sessionPath = await findSessionById(requested, requestCwd(params));
+        if (!sessionPath)
+            throw new InvalidParams(`Unknown session '${requested}'.`);
+        const restored = await startSession(sessionPath);
+        // Display history is reconstructed separately. The live AgentSession above
+        // deliberately keeps only the canonical newest checkpoint as model context.
+        const checkpoints = await loadSessionCheckpointChain(sessionPath);
+        const displayMessages = reconstructCheckpointHistory(checkpoints);
+        // The id the client asked for is the id it keeps using; `loadSession` may
+        // adopt a different internal one, and answering with that would leave the
+        // client addressing a session it never heard of.
+        sessionId = requested;
+        for (const update of historyUpdates(displayMessages))
+            notifyUpdate(update);
+        notifyAvailableCommands(restored);
+        announceSessionSoon(restored);
+        return { configOptions: configOptionsFor(restored), modes: sessionModes(restored) };
+    }
+    /**
+     * Abort the running turn and WAIT for it to unwind.
+     *
+     * `handleCancel` only signals: `session.prompt()` keeps unwinding after it
+     * returns, and its last act is persisting the turn. Disposing before that
+     * finishes clears the session path out from under the write, so the final
+     * exchange is silently dropped and the session is missing its tail when the
+     * user comes back to it. The read loop's own teardown already waits like
+     * this; a lifecycle request that tears a session down mid-turn must too.
+     */
+    async function cancelAndSettle() {
+        handleCancel();
+        await Promise.allSettled([...inFlight]);
+    }
+    /** The sessionId a lifecycle request names, validated. */
+    function requestedSessionId(params, method) {
+        const requested = params?.sessionId;
+        if (typeof requested !== "string" || !requested) {
+            throw new InvalidParams(`${method} requires a sessionId.`);
+        }
+        return requested;
+    }
+    /**
+     * Reconnect to a stored session WITHOUT replaying it.
+     *
+     * The difference from `session/load` is the whole point: a client that still
+     * holds the transcript (it was showing this session a moment ago) wants the
+     * agent-side context back, not a second copy of every message pushed at it.
+     */
+    async function handleResumeSession(params) {
+        const requested = requestedSessionId(params, "session/resume");
+        const sessionPath = await findSessionById(requested, requestCwd(params));
+        if (!sessionPath)
+            throw new InvalidParams(`Unknown session '${requested}'.`);
+        const restored = await startSession(sessionPath);
+        // As in session/load: the client keeps addressing the id it asked for.
+        sessionId = requested;
+        notifyAvailableCommands(restored);
+        announceSessionSoon(restored);
+        return { configOptions: configOptionsFor(restored), modes: sessionModes(restored) };
+    }
+    /**
+     * Close the active session, cancelling whatever it is doing.
+     *
+     * The spec requires the in-flight turn to be cancelled exactly as
+     * `session/cancel` would, so this reuses that path rather than tearing the
+     * session down underneath a running agent loop.
+     */
+    async function handleCloseSession(params) {
+        const requested = requestedSessionId(params, "session/close");
+        if (!session || requested !== sessionId) {
+            throw new InvalidParams(`Session '${requested}' is not active.`);
+        }
+        await cancelAndSettle();
+        await disposeSession();
+        return {};
+    }
+    /**
+     * Delete a stored session from disk.
+     *
+     * Hard delete, including the archive and asset siblings, because a session
+     * left half-present would come back as a broken row in the next
+     * `session/list`. Deleting something that is not there succeeds silently:
+     * the spec asks for idempotence, and the user's intent is already satisfied.
+     */
+    async function handleDeleteSession(params) {
+        const requested = requestedSessionId(params, "session/delete");
+        const sessionPath = await findSessionById(requested, requestCwd(params));
+        if (!sessionPath)
+            return {};
+        // Deleting the session we are serving would leave a live AgentSession
+        // appending to a file that no longer exists, quietly recreating it.
+        if (session && requested === sessionId) {
+            await cancelAndSettle();
+            await disposeSession();
+        }
+        const group = sessionGroupPaths(sessionPath);
+        for (const target of [group.plainPath, group.archivePath, group.assetsPath]) {
+            await rm(target, { recursive: true, force: true });
+        }
+        return {};
+    }
+    /**
+     * Switch session mode (ACP `session/set_mode`; Zed's mode picker uses this,
+     * pew2 routes it through session/set_config_option with configId "mode").
+     */
+    async function handleSetMode(params) {
+        if (!session)
+            throw new InvalidParams("No session. Call session/new first.");
+        const modeId = params?.modeId;
+        if (modeId !== MODE_DEFAULT && modeId !== MODE_PLAN) {
+            throw new InvalidParams(`Unknown mode '${String(modeId)}'.`);
+        }
+        const plan = modeId === MODE_PLAN;
+        if (session.getPlanMode() !== plan) {
+            await session.setPlanMode(plan);
+            notifyModeChange(modeId);
+        }
+        return {};
+    }
+    /**
+     * Apply a selector change from the client.
+     *
+     * Replies with the COMPLETE option set rather than the one that changed:
+     * switching model can move the thinking ceiling, and a client that only
+     * patched the field it sent would keep offering levels the new model ignores.
+     */
+    async function handleSetConfigOption(params) {
+        if (!session)
+            throw new InvalidParams("No session. Call session/new first.");
+        const { configId, value } = (params ?? {});
+        if (typeof configId !== "string" || typeof value !== "string") {
+            throw new InvalidParams("session/set_config_option requires a configId and a string value.");
+        }
+        if (configId === MODEL_CONFIG_ID) {
+            const target = getModel(value);
+            if (!target)
+                throw new InvalidParams(`Unknown model '${value}'.`);
+            await session.switchModel(target.provider, target.id);
+            // Thinking levels are per-model, so a level the previous model allowed can
+            // be above the new one's ceiling. Clamping here keeps the session's actual
+            // effort equal to what the client is about to be told it is.
+            const current = session.getThinkingLevel();
+            if (current) {
+                const allowed = thinkingOptionsFor(target.id).map((option) => option.value);
+                if (!allowed.includes(current))
+                    session.setThinkingLevel(getMaxThinkingLevel(target.id));
+            }
+        }
+        else if (configId === MODE_CONFIG_ID) {
+            // Share the dedicated handler so both entry points behave identically.
+            await handleSetMode({
+                sessionId: params?.sessionId,
+                modeId: value,
+            });
+        }
+        else if (configId === THINKING_CONFIG_ID) {
+            if (value === THINKING_OFF) {
+                session.setThinkingLevel(undefined);
+            }
+            else {
+                const { model } = session.getState();
+                const allowed = thinkingOptionsFor(model).map((option) => option.value);
+                if (!allowed.includes(value)) {
+                    throw new InvalidParams(`Model '${model}' does not support thinking level '${value}'.`);
+                }
+                session.setThinkingLevel(value);
+            }
+        }
+        else {
+            throw new InvalidParams(`Unknown config option '${configId}'.`);
+        }
+        return { configOptions: configOptionsFor(session) };
+    }
+    /** Flatten ACP prompt blocks to the plain text `AgentSession` accepts. */
+    function promptText(params) {
+        const blocks = params?.prompt;
+        if (!Array.isArray(blocks))
+            return "";
+        return blocks
+            .map((block) => {
+            const entry = block;
+            return entry?.type === "text" && typeof entry.text === "string" ? entry.text : "";
+        })
+            .filter(Boolean)
+            .join("\n")
+            .trim();
+    }
+    async function handlePrompt(params) {
+        if (!session)
+            throw new InvalidParams("No session. Call session/new first.");
+        if (running)
+            throw new InvalidParams("A prompt is already running in this session.");
+        const text = promptText(params);
+        if (!text)
+            throw new InvalidParams("prompt must contain at least one non-empty text block.");
+        running = true;
+        cancelled = false;
+        truncation = undefined;
+        hitMaxTurns = false;
+        try {
+            await session.prompt(text);
+        }
+        catch (err) {
+            // A cancel aborts the loop, which surfaces here. The spec requires the
+            // turn to still resolve with `cancelled` rather than reject — the client
+            // is confirming its own cancel, not being told something went wrong.
+            if (cancelled || isAbortError(err))
+                return { stopReason: "cancelled" };
+            throw err;
+        }
+        finally {
+            running = false;
+            // Drop any before-snapshot whose tool never reported an end. A cancelled
+            // turn stops emitting tool events, so `diffContent` — the only other
+            // place these are removed — never runs for the call that was in flight,
+            // and its file contents would stay pinned for the rest of the session.
+            // Cleared here rather than on `turn_end`, which fires before that turn's
+            // tools execute and would discard snapshots still in use.
+            diffSnapshots.clear();
+        }
+        return { stopReason: cancelled ? "cancelled" : stopReasonFor(truncation, hitMaxTurns) };
+    }
+    function handleCancel() {
+        if (!running || !session)
+            return;
+        cancelled = true;
+        abort.abort();
+        // `AgentSession` keeps the construction signal for future turns. Re-arm it
+        // immediately after aborting this turn, or every later prompt sees an
+        // already-aborted signal and silently completes with no output.
+        abort = new AbortController();
+        session.setSignal(abort.signal);
+    }
+    async function dispatch(method, params) {
+        switch (method) {
+            case "initialize":
+                return handleInitialize();
+            case "session/new":
+                return handleNewSession();
+            case "session/prompt":
+                return handlePrompt(params);
+            case "session/list":
+                return handleListSessions(params);
+            case "session/load":
+                return handleLoadSession(params);
+            case "session/resume":
+                return handleResumeSession(params);
+            case "session/close":
+                return handleCloseSession(params);
+            case "session/delete":
+                return handleDeleteSession(params);
+            case "session/set_config_option":
+                return handleSetConfigOption(params);
+            case "session/set_mode":
+                return handleSetMode(params);
+            default:
+                return undefined;
+        }
+    }
+    // ── Read loop ────────────────────────────────────────────
+    const rl = readline.createInterface({ input, terminal: false });
+    /**
+     * Requests still being served.
+     *
+     * Requests are dispatched WITHOUT blocking the read loop, because
+     * `session/prompt` runs for as long as the agent does — awaiting it here
+     * would mean `session/cancel` is not read until the turn it cancels has
+     * already finished. That is a deadlock, not a slow path.
+     */
+    const inFlight = new Set();
+    function serve(id, method, params) {
+        const task = (async () => {
+            try {
+                const result = await dispatch(method, params);
+                if (result === undefined) {
+                    fail(id, RPC_METHOD_NOT_FOUND, `Unsupported method: ${method}`);
+                    return;
+                }
+                respond(id, result);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                const code = err instanceof InvalidParams ? RPC_INVALID_PARAMS : RPC_INTERNAL_ERROR;
+                fail(id, code, message);
+            }
+        })();
+        inFlight.add(task);
+        void task.finally(() => inFlight.delete(task));
+    }
+    try {
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            let frame;
+            try {
+                frame = JSON.parse(line);
+            }
+            catch {
+                // No id to answer against, so this is the one case that uses a null id,
+                // exactly as JSON-RPC 2.0 prescribes for unparseable input.
+                write({
+                    jsonrpc: "2.0",
+                    id: null,
+                    error: { code: RPC_PARSE_ERROR, message: "Invalid JSON" },
+                });
+                continue;
+            }
+            const { id, method } = frame;
+            if (typeof method !== "string") {
+                if (id !== undefined)
+                    fail(id, RPC_INVALID_REQUEST, "Missing 'method'");
+                continue;
+            }
+            // Notifications: no id, no response, ever — answering one is a protocol
+            // violation that some clients treat as a fatal desync.
+            if (id === undefined) {
+                if (method === "session/cancel")
+                    handleCancel();
+                continue;
+            }
+            serve(id, method, frame.params);
+        }
+    }
+    finally {
+        rl.close();
+        // The client is gone, so a turn still running has nowhere to report to.
+        // Cancelling first is what stops the wait below from being unbounded.
+        handleCancel();
+        // A disconnect mid-turn must still not tear the session out from under the
+        // run that is writing to it.
+        await Promise.allSettled([...inFlight]);
+        await disposeSession().catch(() => { });
+    }
+}
+/**
+ * CLI entry point: serve ACP on the real stdio, then exit.
+ *
+ * Split from {@link runAcpMode} so the protocol can be tested without the
+ * process-level side effects (signal handlers, logger teardown, exit codes).
+ */
+export async function runAcpModeCli(options) {
+    const onSigint = () => {
+        // An ACP agent is driven entirely by its client; Ctrl-C is the user asking
+        // the process to end, not the current turn to stop.
+        process.exit(130);
+    };
+    process.on("SIGINT", onSigint);
+    try {
+        await runAcpMode(options);
+    }
+    catch (err) {
+        process.stderr.write(`${formatUserError(err)}\n`);
+        process.exitCode = 1;
+    }
+    finally {
+        process.removeListener("SIGINT", onSigint);
+        closeLogger();
+    }
+}
+//# sourceMappingURL=acp-mode.js.map