@agentclientprotocol/claude-agent-acp 0.85.2-preview.19 → 0.85.2-preview.3

package/dist/acp-agent.js

@@ -4,7 +4,7 @@ import { GOAL_ACTIONS, GOAL_CONTROL_METHOD, GOAL_EXTENSION_VERSION, goalUpdateFr
 import { sanitizeTitle, SessionTitles } from "./session-titles.js";
 import { AIR_NATIVE_SUBAGENT_SESSIONS_CAPABILITY, asSdkSessionNotification, clientSupportsSubagents, } from "./acp-subagents.js";
 import { isNativeSubagentControlTool, isNativeSubagentControlUpdate, NativeSubagentRuntime, nativeSubagentState, resumedNativeSubagentId, sendMessageResumePrompt, } from "./native-subagents.js";
-import { AIR_ASYNC_TASKS_CAPABILITY, AIR_DIFF_PATCH_CAPABILITY, AIR_PLAN_FILE_CAPABILITY, AIR_GOAL_KEY, AIR_KIND_KEY, AIR_RECOMMENDED_CONFIG_VALUE_CAPABILITY, AIR_SKILL_PATH_KEY, clientSupportsAirCapability, withAirMeta, } from "./air-extension.js";
+import { AIR_ASYNC_TASKS_CAPABILITY, AIR_DIFF_PATCH_CAPABILITY, AIR_PLAN_FILE_CAPABILITY, AIR_GOAL_KEY, AIR_RECOMMENDED_CONFIG_VALUE_CAPABILITY, clientSupportsAirCapability, withAirMeta, } from "./air-extension.js";
 import { AsyncTaskRuntime, backgroundBashTaskFromToolResult, clientSupportsAsyncTasks, } from "./async-tasks.js";
 import { AUTH_STATUS_PROBE_TIMEOUT_MS, AUTH_STATUS_UPDATE_METHOD, authStatusCapability, fromAccountInfo, fromCliStatus, gatewayAuthStatus, mergeAuthStatus, notLoggedInAuthStatus, sameAuthStatus, } from "./auth-status.js";
 import { execFile } from "node:child_process";
@@ -16,12 +16,12 @@ import packageJson from "../package.json" with { type: "json" };
 import { applyAskElicitationResponse, askUserQuestionsToCreateRequest, createElicitationResponseToElicitResult, extractAskUserQuestions, extractRefusalFallbackPrompt, mcpElicitationToCreateRequest, REFUSAL_FALLBACK_DIALOG_KIND, refusalFallbackResultFromResponse, refusalFallbackToCreateRequest, } from "./elicitation.js";
 import { forkSession } from "./fork-session.js";
 import { subagentHistory } from "./subagent-history.js";
-import { readResumedSession, readResumedTail, } from "./resumed-session.js";
+import { readResumedModel, readResumedSession, } from "./resumed-session.js";
 import { SessionTiming } from "./session-timing.js";
-import { ALLOW_BYPASS } from "./permissions/modes.js";
+import { ALLOW_BYPASS, resolvePermissionMode } from "./permissions/modes.js";
 import { normalizeDurablePermissionChangeSet } from "./permissions/normalization.js";
 import { buildClaudePermissionOptions } from "./permissions/options.js";
-import { buildClaudePermissionPresentation, } from "./permissions/presentation.js";
+import { buildClaudePermissionPresentation } from "./permissions/presentation.js";
 import { decodeClaudePermissionResponse } from "./permissions/response.js";
 import { SettingsManager } from "./settings.js";
 import { activeUsageLimitMessage, airSessionFailureCapabilityMeta, assistantMessageText, createSessionFailureState, isSyntheticUsageLimitMessage, providerFailureCategory, SessionFailureController, sessionFailureMeta, supportsAirSessionFailures, } from "./session-failure-extension.js";
@@ -36,13 +36,11 @@ import { ChangedMetaFilter } from "./tool-calls/changed-meta-filter.js";
 import { ToolCallFieldTracker } from "./tool-calls/field-tracker.js";
 import { ClientCapabilities as ToolCallClientCapabilities } from "./tool-calls/client-capabilities.js";
 import { AcpToolCallRenderer } from "./tool-calls/renderer.js";
-import { resolveSkillPath } from "./tool-calls/reporters/interaction.js";
-import { nodeToWebReadable, nodeToWebWritable, Pushable, raceTimeoutAndAbort, unreachable, } from "./utils.js";
+import { nodeToWebReadable, nodeToWebWritable, Pushable, unreachable } from "./utils.js";
 import { acceptedPlanToolResult, ExitPlanCoordinator, isExitPlanInterruptionResult, observeExitPlanToolResults, } from "./exit-plan.js";
 import { parseToolResultMeta } from "./tool-result-meta.js";
 import { formatUsageResponse, isUsageCommandText, parseUsageResponse } from "./usage-markdown.js";
-import { MCP_AVAILABLE_COMMAND, parseMcpCommand, runMcpCommand } from "./mcp-command.js";
-import { MODE_CONFIG_ID, resolveInitialPermissionMode, SessionModeManager, } from "./session-mode.js";
+import { MODE_CONFIG_ID, SessionModeManager } from "./session-mode.js";
 import { applyAvailableModelsAllowlist, buildModelConfigOption, getAvailableModels, MODEL_CONFIG_ID, resolveModelPreference, } from "./session-model.js";
 import { buildEffortConfigOption, EFFORT_CONFIG_ID, effortFlagSettings, mergeEffortSettings, settingsEffortForModel, } from "./session-effort.js";
 export { EFFORT_CONFIG_ID, settingsEffortForModel } from "./session-effort.js";
@@ -79,10 +77,6 @@ const DEFAULT_CONTEXT_WINDOW = 200000;
  *  pre-empt a slow-but-healthy interrupt. */
 const DEFAULT_FORCE_CANCEL_GRACE_MS = 30_000;
 const STRUCTURED_USAGE_TIMEOUT_MS = 5_000;
-/** How long a session teardown waits for the turns that it cancels to end.
- *  The teardown wakes the consumer itself, so they end within a few ticks
- *  unless the consumer is wedged. */
-const TEARDOWN_TURN_END_TIMEOUT_MS = 5_000;
 /** The number of settled subagents whose parent tool call a session keeps for
  *  a later resume (see `resumableSubagents`). */
 const MAX_RESUMABLE_SUBAGENTS = 256;
@@ -111,18 +105,32 @@ function settleLiveBackgroundTask(session, taskId) {
 async function structuredUsageMarkdown(query, signal, logger) {
     if (signal.aborted)
         return null;
+    let timeout;
+    let onAbort;
     try {
-        const outcome = await raceTimeoutAndAbort(
-        // Keeping the deliberately unstable method name visible makes an SDK
-        // upgrade fail at compile time if Anthropic removes or renames it.
-        query.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET(), STRUCTURED_USAGE_TIMEOUT_MS, signal);
-        if (outcome.type !== "done") {
-            if (outcome.type === "timeout") {
+        const response = await Promise.race([
+            // Keeping the deliberately unstable method name visible makes an SDK
+            // upgrade fail at compile time if Anthropic removes or renames it.
+            query.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET(),
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(null), STRUCTURED_USAGE_TIMEOUT_MS);
+                timeout.unref?.();
+            }),
+            new Promise((resolve) => {
+                onAbort = () => resolve(null);
+                if (signal.aborted)
+                    onAbort();
+                else
+                    signal.addEventListener("abort", onAbort, { once: true });
+            }),
+        ]);
+        if (response === null) {
+            if (!signal.aborted) {
                 logger.error("Structured /usage timed out; preserving Claude Code output");
             }
             return null;
         }
-        const usage = parseUsageResponse(outcome.value);
+        const usage = parseUsageResponse(response);
         if (!usage) {
             logger.error("Structured /usage returned an incompatible response; preserving Claude Code output");
             return null;
@@ -133,6 +141,12 @@ async function structuredUsageMarkdown(query, signal, logger) {
         logger.error(`Structured /usage failed; preserving Claude Code output: ${error}`);
         return null;
     }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+        if (onAbort)
+            signal.removeEventListener("abort", onAbort);
+    }
 }
 /** Claude Code keeps the OAuth callback listener open in the background after
  *  `mcpAuthenticate` returns the authorization URL. The SDK does not expose
@@ -666,7 +680,6 @@ const REPLAY_HIDDEN_COMMANDS = new Set([
     ...LOCAL_ONLY_COMMANDS,
     "/compact",
     "/model",
-    "/mcp",
     "/status",
     "/usage",
 ]);
@@ -1004,19 +1017,12 @@ const mcpAuthentications = new WeakMap();
  *  authentication. This runs after session creation has returned so an
  *  interactive browser flow never delays `session/new`. */
 function startMcpAuthentication(host, sessionId, mcpServers) {
-    if (mcpServers.length === 0)
-        return;
-    startMcpServerAuthentication(host, sessionId, new Set(mcpServers.map((server) => server.name)));
-}
-/** Start OAuth in the background for the servers in `requestedServers` that
- *  Claude reports as needing authentication. Startup and `/mcp` use it. It
- *  does nothing while another OAuth run of the session is in progress. */
-function startMcpServerAuthentication(host, sessionId, requestedServers) {
-    if (!host.clientCapabilities?.elicitation?.url)
+    if (!host.clientCapabilities?.elicitation?.url || mcpServers.length === 0)
         return;
     const session = host.sessions[sessionId];
     if (!session || mcpAuthentications.has(session))
         return;
+    const requestedServers = new Set(mcpServers.map((server) => server.name));
     const authentication = authenticateMcpServers(host, sessionId, session.query, requestedServers)
         .catch((error) => {
         if (!session.abortController.signal.aborted) {
@@ -1155,14 +1161,7 @@ export class ClaudeAcpAgent {
      *  return "cancelled". See {@link DEFAULT_FORCE_CANCEL_GRACE_MS}. Mutable so
      *  tests can shrink it. */
     forceCancelGraceMs = DEFAULT_FORCE_CANCEL_GRACE_MS;
-    /**
-     * The connection serves ACP v2 (`src/v2/`). The agent still speaks v1
-     * types, except for the tool call content that v2 needs and v1 cannot
-     * express: see {@link ToolCallClientCapabilities.v2}.
-     */
-    v2;
-    constructor(client, logger, options = {}) {
-        this.v2 = options.v2 ?? false;
+    constructor(client, logger) {
         this.sessions = {};
         this.client = new ChangedMetaClient(client, () => this.toolCallCapabilities.air.client);
         this.logger = logger ?? console;
@@ -1219,9 +1218,7 @@ export class ClaudeAcpAgent {
     }
     async initialize(request) {
         this.clientCapabilities = request.clientCapabilities;
-        this.toolCallCapabilities = ToolCallClientCapabilities.from(request.clientCapabilities, {
-            v2: this.v2,
-        });
+        this.toolCallCapabilities = ToolCallClientCapabilities.from(request.clientCapabilities);
         // Learn the auth identity in the background: `initialize` never waits on
         // the CLI probe, and no snapshot rides in its response. When the probe
         // lands it calls `setAuthStatus`, which pushes `_auth/status_update` — the
@@ -1405,56 +1402,6 @@ export class ClaudeAcpAgent {
         }, 0);
         return response;
     }
-    /**
-     * Start the CLI of a loaded session, and replay the history while the CLI
-     * starts. The CLI start takes most of the load time, and the replay needs
-     * only the transcript and the {@link ReplayState}. An invalid `cwd` fails
-     * before the first update. A failed CLI start stops the replay.
-     */
-    async createSessionWhileReplaying(params, timing) {
-        await this.validateCwd(params.cwd);
-        const pending = {
-            state: {
-                cwd: params.cwd,
-                taskState: new Map(),
-                forwardSubagentText: this.forwardsSubagentText(params._meta),
-                messageIdToUuid: new Map(),
-                sessionFailureState: createSessionFailureState(),
-            },
-            stopped: false,
-        };
-        const transcript = readResumedSession(params.sessionId, this.logger);
-        const replay = transcript
-            .then(({ messages }) => this.replaySessionHistory(params.sessionId, messages, pending))
-            .then(() => ({ ok: true }), (error) => ({ ok: false, error }));
-        let response;
-        try {
-            response = await this.createSession({
-                cwd: params.cwd,
-                mcpServers: params.mcpServers ?? [],
-                additionalDirectories: params.additionalDirectories,
-                _meta: params._meta,
-            }, {
-                resume: params.sessionId,
-                resumedModelHint: transcript.then(({ model }) => model),
-                replayState: pending.state,
-            });
-        }
-        catch (error) {
-            pending.stopped = true;
-            await replay;
-            throw error;
-        }
-        timing.phase("session-ready");
-        const replayed = await replay;
-        if (!replayed.ok)
-            throw replayed.error;
-        return {
-            sessionId: response.sessionId,
-            modes: response.modes,
-            configOptions: response.configOptions,
-        };
-    }
     async unstable_forkSession(params) {
         if (this.providerUpdate)
             await this.providerUpdate;
@@ -1479,16 +1426,10 @@ export class ClaudeAcpAgent {
         const timing = new SessionTiming(this.logger, "load", params.sessionId);
         if (this.providerUpdate)
             await this.providerUpdate;
-        let result;
-        if (this.sessions[params.sessionId]) {
-            const resumedSession = await readResumedSession(params.sessionId, this.logger);
-            result = await this.getOrCreateSession(params, resumedSession);
-            timing.phase("session-ready");
-            await this.replaySessionHistory(params.sessionId, resumedSession.messages);
-        }
-        else {
-            result = await this.createSessionWhileReplaying(params, timing);
-        }
+        const resumedSession = await readResumedSession(params.sessionId, this.logger);
+        const result = await this.getOrCreateSession(params, resumedSession);
+        timing.phase("session-ready");
+        await this.replaySessionHistory(params.sessionId, resumedSession.messages);
         timing.phase("replay");
         // Send available commands after replay so it doesn't interleave with history
         setTimeout(() => {
@@ -1871,47 +1812,6 @@ export class ClaudeAcpAgent {
             this.setAuthStatus(notLoggedInAuthStatus());
         }
     }
-    /** The structured replacement for a prompt that is exactly `/usage` or a
-     *  `/mcp` command. Claude Code runs the command, and the replacement takes
-     *  the place of its text. Claude Code refuses a `/mcp` reconnect, enable,
-     *  or disable in SDK mode. The `/mcp` producer runs them through the SDK
-     *  control API when the text arrives, so the action stays in the turn. */
-    localCommandMarkdown(params) {
-        const text = params.prompt.length === 1 && params.prompt[0]?.type === "text"
-            ? params.prompt[0].text
-            : undefined;
-        if (text === undefined)
-            return undefined;
-        if (isUsageCommandText(text)) {
-            return {
-                startsAtActivation: true,
-                produce: (query, signal) => structuredUsageMarkdown(query, signal, this.logger),
-            };
-        }
-        const command = parseMcpCommand(text);
-        if (!command)
-            return undefined;
-        let reconnected = [];
-        return {
-            startsAtActivation: false,
-            produce: async (query, signal, originalOutput) => {
-                const outcome = await runMcpCommand(query, command, originalOutput, signal, (message) => this.logger.error(message));
-                reconnected = outcome.reconnected;
-                return outcome.markdown;
-            },
-            // A reconnect starts OAuth for the ACP servers that it tried, as the
-            // session start does. A plain `/mcp` and a cancelled turn start none.
-            afterDelivery: () => {
-                const session = this.sessions[params.sessionId];
-                if (!session || session.cancelled)
-                    return;
-                const acpServers = new Set((session.creationParams?.mcpServers ?? []).map((server) => server.name));
-                const servers = new Set(reconnected.filter((server) => acpServers.has(server)));
-                if (servers.size > 0)
-                    startMcpServerAuthentication(this, params.sessionId, servers);
-            },
-        };
-    }
     /**
      * Serves an ACP v1 `session/prompt`, which answers when the turn ends. The
      * outcome of a turn is field for field a v1 prompt response.
@@ -1978,8 +1878,10 @@ export class ClaudeAcpAgent {
         const firstText = params.prompt[0]?.type === "text" ? params.prompt[0].text : "";
         const isLocalOnlyCommand = firstText.startsWith("/") && LOCAL_ONLY_COMMANDS.has(firstText.split(" ", 1)[0]);
         const fileChangeReport = session.fileChangeReporter?.request(params._meta);
-        const localCommand = this.localCommandMarkdown(params);
-        const localCommandAbort = localCommand ? new AbortController() : undefined;
+        const isUsageCommand = params.prompt.length === 1 &&
+            params.prompt[0]?.type === "text" &&
+            isUsageCommandText(params.prompt[0].text);
+        const usageMarkdownAbort = isUsageCommand ? new AbortController() : undefined;
         session.titles.onPrompt(params.prompt);
         // Each prompt is a Turn that the persistent consumer settles once the
         // turn's outcome is known. `startTurn()` owns no loop: it enqueues the
@@ -1990,8 +1892,8 @@ export class ClaudeAcpAgent {
             promptUuid,
             events,
             isLocalOnlyCommand,
-            ...(localCommand ? { localCommand } : {}),
-            ...(localCommandAbort ? { localCommandAbort } : {}),
+            ...(isUsageCommand ? { isUsageCommand: true } : {}),
+            ...(usageMarkdownAbort ? { usageMarkdownAbort } : {}),
             ...(fileChangeReport ? { fileChangeReport } : {}),
             settled: false,
             completion: new Promise((resolve) => {
@@ -2001,8 +1903,8 @@ export class ClaudeAcpAgent {
                 events.ended(outcome);
                 completeTurn();
             },
-            reject: (error, title) => {
-                events.failed(error, title);
+            reject: (error) => {
+                events.failed(error);
                 completeTurn();
             },
         };
@@ -2113,10 +2015,7 @@ export class ClaudeAcpAgent {
         try {
             // `resume` names the Claude session, which shares the ACP session id, so
             // the new query continues the same conversation under the same id.
-            await this.createSession(creationParams, {
-                resume: sessionId,
-                permissionMode: session.modes.currentModeId,
-            });
+            await this.createSession(creationParams, { resume: sessionId });
         }
         catch (error) {
             if (error instanceof RequestError && error.code === RequestError.resourceNotFound().code) {
@@ -2126,10 +2025,7 @@ export class ClaudeAcpAgent {
                 // better answer than a session the client can never use again.
                 this.logger.log(`session ${sessionId} was never persisted; starting a fresh query under the same id`);
                 try {
-                    await this.createSession(creationParams, {
-                        reuseSessionId: sessionId,
-                        permissionMode: session.modes.currentModeId,
-                    });
+                    await this.createSession(creationParams, { reuseSessionId: sessionId });
                     return;
                 }
                 catch (fallbackError) {
@@ -2591,11 +2487,11 @@ export class ClaudeAcpAgent {
             };
         };
         const internalErrorForClient = (data, rawDetail) => RequestError.internalError(data, supportsAirSessionFailures(this.clientCapabilities) ? undefined : rawDetail);
-        const ensureLocalCommandMarkdown = (turn, originalOutput = "") => {
-            if (!turn.localCommand || !turn.localCommandAbort)
+        const ensureUsageMarkdown = (turn) => {
+            if (!turn.isUsageCommand || !turn.usageMarkdownAbort)
                 return undefined;
-            turn.localCommandMarkdown ??= turn.localCommand.produce(session.query, turn.localCommandAbort.signal, originalOutput);
-            return turn.localCommandMarkdown;
+            turn.usageMarkdown ??= structuredUsageMarkdown(session.query, turn.usageMarkdownAbort.signal, this.logger);
+            return turn.usageMarkdown;
         };
         const resetTurnScratch = () => {
             lastAssistantTotalUsage = null;
@@ -2638,8 +2534,7 @@ export class ClaudeAcpAgent {
             session.activeTurn = turn;
             session.cancelled = false;
             compaction.resume();
-            if (turn.localCommand?.startsAtActivation)
-                ensureLocalCommandMarkdown(turn);
+            ensureUsageMarkdown(turn);
             session.pendingOrphanResults = 0;
             session.orphanCommands?.clear();
             // Two-phase sweep of registry entries the level signal ended (see
@@ -2667,23 +2562,18 @@ export class ClaudeAcpAgent {
                 }
             }
             resetTurnScratch();
-            // Without a command_lifecycle "started" frame before it (see that
-            // handler), activation is the first sign that Claude Code took the
-            // prompt in: its echo, or for an echo-less command, its result.
-            reportInserted(turn);
+            // Activation is when Claude Code takes the prompt in: its echo, or for an
+            // echo-less command, its result. That inserts it into the conversation.
+            // A turn can be settled by now: an echo hand-off awaits settling the
+            // previous turn, and a cancel in that window settles the queued one.
+            if (!turn.insertedReported && !turn.settled) {
+                turn.insertedReported = true;
+                turn.events.inserted(turn.promptUuid);
+            }
             // A request can already be open: Claude Code asks for a queued prompt
             // before the consumer reaches its echo.
             this.syncAwaitingUser(session);
         };
-        /** Report that Claude Code took the turn's prompt in, once. A turn can be
-         *  settled by now: an echo hand-off awaits settling the previous turn, and
-         *  a cancel in that window settles the queued one. */
-        const reportInserted = (turn) => {
-            if (turn.insertedReported || turn.settled)
-                return;
-            turn.insertedReported = true;
-            turn.events.inserted(turn.promptUuid);
-        };
         /** Ensure there is an active turn before a user-turn result that carries no
          *  echo to activate it, by promoting the queue head. Most turns are
          *  activated by their replayed user message before their result, but some
@@ -2842,28 +2732,27 @@ export class ClaudeAcpAgent {
          *  the autonomous stretch-close guard. */
         const firstUnsettledQueuedTurn = () => (session.turnQueue ?? []).find((t) => !t.settled);
         /** Claim the structured replacement for the turn currently producing a
-         * local-command output. Undefined means this is not a structured
-         * local-command turn (or its request failed), null means another SDK
-         * message shape already delivered it, and string is the one replacement
-         * to publish. */
-        const takeLocalCommandMarkdown = async (originalOutput) => {
+         * local-command output. Undefined means this is not a structured usage
+         * turn (or its request failed), null means another SDK message shape
+         * already delivered it, and string is the one replacement to publish. */
+        const takeUsageMarkdown = async (originalOutput) => {
             const turn = session.activeTurn ?? firstUnsettledQueuedTurn();
             if (!turn)
                 return undefined;
-            const pending = ensureLocalCommandMarkdown(turn, originalOutput);
-            if (!pending)
+            const usageMarkdown = ensureUsageMarkdown(turn);
+            if (!usageMarkdown)
                 return undefined;
-            const markdown = await pending;
+            const markdown = await usageMarkdown;
             if (markdown === null)
                 return undefined;
-            if (turn.localCommandDelivered) {
+            if (turn.usageMarkdownDelivered) {
                 // Different SDK message shapes can mirror the same local-command
                 // output. Suppress an exact mirror, but let a later, distinct frame
                 // (for example an interruption diagnostic) follow the normal path.
-                return turn.localCommandOriginalOutput === originalOutput ? null : undefined;
+                return turn.usageOriginalOutput === originalOutput ? null : undefined;
             }
-            turn.localCommandDelivered = true;
-            turn.localCommandOriginalOutput = originalOutput;
+            turn.usageMarkdownDelivered = true;
+            turn.usageOriginalOutput = originalOutput;
             return markdown;
         };
         /** Registers a live background task (see `liveBackgroundTasks`). A
@@ -3016,9 +2905,7 @@ export class ClaudeAcpAgent {
             // Captured before the settled flip below (isHeldOpen tests !settled).
             const wasHeld = isHeldOpen(turn);
             turn.settled = true;
-            turn.localCommandAbort?.abort();
-            if (turn.localCommandDelivered)
-                turn.localCommand?.afterDelivery?.();
+            turn.usageMarkdownAbort?.abort();
             disarmForceCancel(session);
             session.turnQueue = (session.turnQueue ?? []).filter((t) => t !== turn);
             session.activeTurn = null;
@@ -3042,7 +2929,7 @@ export class ClaudeAcpAgent {
         };
         /** Reject the active turn (auth required, error result, …) without tearing
          *  down the consumer: the stream continues to idle and later turns proceed. */
-        const failActive = (error, title) => {
+        const failActive = (error) => {
             disarmForceCancel(session);
             const turn = session.activeTurn;
             if (!turn || turn.settled) {
@@ -3059,7 +2946,7 @@ export class ClaudeAcpAgent {
             // start the next stretch clean, or its stale delivery record would
             // suppress the next turn's issue-#453 result-text fallback.
             session.emittedAssistantText = false;
-            turn.reject(error, title);
+            turn.reject(error);
         };
         /** Complete a negotiated terminal failure on the prompt response itself,
          *  which is the canonical AIR carrier. Legacy clients keep the historical
@@ -3083,7 +2970,7 @@ export class ClaudeAcpAgent {
                 return;
             }
             if (!supportsAirSessionFailures(this.clientCapabilities)) {
-                failActive(error, title);
+                failActive(error);
                 return;
             }
             if (!session.activeTurn || session.activeTurn.settled) {
@@ -3093,7 +2980,7 @@ export class ClaudeAcpAgent {
             }
             const failure = await createSessionFailure(kind, { title });
             if (!failure) {
-                failActive(error, title);
+                failActive(error);
                 return;
             }
             sessionFailures.recordActive(failure);
@@ -3197,7 +3084,7 @@ export class ClaudeAcpAgent {
                         }
                     }
                     await compaction.interrupt();
-                    await settleActive(cancelledOutcome(session, session.activeTurn));
+                    await settleActive(turnOutcome(session, "cancelled"));
                     // The cancelled turn's result may never come (that's why the
                     // backstop fired) — close its delivery stretch here so partial
                     // streamed text can't suppress the next turn's issue-#453 fallback.
@@ -3253,7 +3140,7 @@ export class ClaudeAcpAgent {
                     const inFlight = session.activeTurn;
                     await finishLifecycle(session.cancelled ? "cancelled" : "failed", session.cancelled ? "stopped" : "failed", "at end of stream");
                     await settleActive(session.cancelled
-                        ? cancelledOutcome(session, inFlight)
+                        ? turnOutcome(session, "cancelled")
                         : (inFlight?.deferredSettle ?? turnOutcome(session, stopReason)));
                     // Queued turns the SDK never started never ran, so reject them rather
                     // than reporting a success (end_turn) — or a misleading "cancelled" —
@@ -3288,10 +3175,10 @@ export class ClaudeAcpAgent {
                 // prompt() stamps a uuid on every message. The frame is @internal and
                 // absent from the SDKMessage union, so handle it BEFORE the exhaustive
                 // switch: it must not reach `unreachable`'s error log, and a `case`
-                // for it wouldn't typecheck. It feeds the orphan accounting (see
-                // Session.orphanCommands) and reports a turn inserted at "started";
-                // turn activation and settlement stay driven by echoes/results/idle.
-                // (Raw-mode emission above still forwards these frames.)
+                // for it wouldn't typecheck. It feeds only the orphan accounting (see
+                // Session.orphanCommands); turn settlement stays driven by
+                // echoes/results/idle. (Raw-mode emission above still forwards these
+                // frames.)
                 if (message.type === "command_lifecycle") {
                     const frame = message;
                     switch (frame.state) {
@@ -3302,17 +3189,6 @@ export class ClaudeAcpAgent {
                             if (queued) {
                                 queued.commandStarted = true;
                                 compaction.resume();
-                                // Claude Code took the prompt in: it drained into a turn. A
-                                // fresh turn reports that before anything it produces, its echo
-                                // and first stream events included, so this is the earliest
-                                // insertion point. (A prompt folded into a running turn reports
-                                // it after its echo, which already activated it.) While another
-                                // turn is still active (held for background work, steered, or
-                                // cancelled and awaiting its trailing idle), insertion waits
-                                // for this turn's echo, whose hand-off ends that turn first.
-                                const active = session.activeTurn;
-                                if (!active || active.settled || active === queued)
-                                    reportInserted(queued);
                             }
                             // ...and promote an already-orphaned command: once dispatched,
                             // a bare `cancelled` no longer means "dropped without running".
@@ -3489,18 +3365,17 @@ export class ClaudeAcpAgent {
                                 if (compaction.consumeDuplicateErrorOutput(message.content)) {
                                     break;
                                 }
-                                const commandTurn = session.activeTurn ?? firstUnsettledQueuedTurn();
-                                const commandMarkdown = await takeLocalCommandMarkdown(message.content);
-                                if (commandTurn?.localCommand && session.cancelled)
+                                const usageTurn = session.activeTurn ?? firstUnsettledQueuedTurn();
+                                const usageMarkdown = await takeUsageMarkdown(message.content);
+                                if (usageTurn?.isUsageCommand && session.cancelled)
                                     break;
-                                if (commandMarkdown === null)
+                                if (usageMarkdown === null)
                                     break;
                                 await sendUpdate({
                                     sessionId: params.sessionId,
                                     update: {
                                         sessionUpdate: "agent_message_chunk",
-                                        content: { type: "text", text: commandMarkdown ?? message.content },
-                                        messageId: messageIdForGrouping(message),
+                                        content: { type: "text", text: usageMarkdown ?? message.content },
                                     },
                                 });
                                 break;
@@ -3557,13 +3432,7 @@ export class ClaudeAcpAgent {
                                     // the interrupted turn's tokens entirely (issue #844). Zero
                                     // when the cancel pre-empted the result (wedge/force-cancel).
                                     if (session.cancelled && session.activeTurn && !session.activeTurn.settled) {
-                                        // A held turn's result passed long ago; this idle is the
-                                        // trailer of the followup cycle the cancel interrupted,
-                                        // whose result (an autonomous one) recorded it as owed.
-                                        if (isHeldOpen(session.activeTurn) && session.owedTrailingIdles > 0) {
-                                            session.owedTrailingIdles--;
-                                        }
-                                        await settleActive(cancelledOutcome(session, session.activeTurn));
+                                        await settleActive(turnOutcome(session, "cancelled"));
                                         // An interrupt can pre-empt the turn's result entirely
                                         // (nothing ran the result-case `finally`), so close the
                                         // delivery stretch here: idle is the SDK's authoritative
@@ -3665,12 +3534,11 @@ export class ClaudeAcpAgent {
                                 // list with this payload. Forward message.commands directly —
                                 // it's authoritative, and re-querying supportedCommands()
                                 // would just return the same list with an extra round-trip.
-                                session.skillPaths = new Map();
                                 await sendUpdate({
                                     sessionId: params.sessionId,
                                     update: {
                                         sessionUpdate: "available_commands_update",
-                                        availableCommands: getAvailableSlashCommands(message.commands, session.terminalSlashCommands, this.toolCallCapabilities.air.client ? session.cwd : undefined, session.skillPaths),
+                                        availableCommands: getAvailableSlashCommands(message.commands, session.terminalSlashCommands),
                                     },
                                 });
                                 break;
@@ -4442,7 +4310,6 @@ export class ClaudeAcpAgent {
                                         update: {
                                             sessionUpdate: "agent_message_chunk",
                                             content: { type: "text", text: lastRefusalExplanation },
-                                            messageId: messageIdForGrouping(message),
                                         },
                                     });
                                 }
@@ -4517,13 +4384,10 @@ export class ClaudeAcpAgent {
                                             (message.usage.output_tokens ?? 0) === 0 &&
                                             !session.activeTurn?.noticeTexts?.includes(normalizeNoticeText(message.result)));
                                     if (shouldForwardResult) {
-                                        const commandTurn = session.activeTurn ?? firstUnsettledQueuedTurn();
-                                        const commandMarkdown = await takeLocalCommandMarkdown(message.result);
-                                        if (commandTurn?.localCommand && session.cancelled)
+                                        const usageMarkdown = await takeUsageMarkdown(message.result);
+                                        if (usageMarkdown === null)
                                             break;
-                                        if (commandMarkdown === null)
-                                            break;
-                                        for (const notification of toAcpNotifications(commandMarkdown ?? message.result, "assistant", params.sessionId, session.toolUseCache, routedNotificationClient, this.logger, { messageId: messageIdForGrouping(message) })) {
+                                        for (const notification of toAcpNotifications(usageMarkdown ?? message.result, "assistant", params.sessionId, session.toolUseCache, routedNotificationClient, this.logger)) {
                                             await sendUpdate(notification);
                                         }
                                     }
@@ -4736,7 +4600,6 @@ export class ClaudeAcpAgent {
                         }
                         for (const notification of streamEventToAcpNotifications(message, params.sessionId, session.toolUseCache, this.client, this.logger, {
                             clientCapabilities: this.clientCapabilities,
-                            toolCallCapabilities: this.toolCallCapabilities,
                             cwd: session.cwd,
                             taskState: session.taskState,
                             emittedToolCalls: session.emittedToolCalls,
@@ -4806,7 +4669,7 @@ export class ClaudeAcpAgent {
                                             session.owedTrailingIdles++;
                                             // Before activateTurn resets the accumulator, so the
                                             // usage still belongs to the cancelled turn.
-                                            await settleActive(cancelledOutcome(session, session.activeTurn));
+                                            await settleActive(turnOutcome(session, "cancelled"));
                                         }
                                         else if (isHeldOpen(session.activeTurn)) {
                                             // A turn held open for its background subagents (see
@@ -4917,16 +4780,16 @@ export class ClaudeAcpAgent {
                         // Depending on the Claude Code build, a local command can arrive
                         // as the dedicated system message above or as a synthetic
                         // assistant message. Replace only the output owned by the exact
-                        // /usage or /mcp turn; no content signatures or text parsing are involved.
+                        // /usage turn; no content signatures or text parsing are involved.
                         if (message.type === "assistant" &&
                             message.parent_tool_use_id === null &&
                             message.message.model === "<synthetic>") {
-                            const commandMarkdown = await takeLocalCommandMarkdown(assistantMessageText(message.message) ?? "");
+                            const usageMarkdown = await takeUsageMarkdown(assistantMessageText(message.message) ?? "");
                             if (session.cancelled)
                                 break;
-                            if (commandMarkdown !== undefined) {
-                                if (commandMarkdown !== null) {
-                                    for (const notification of toAcpNotifications(commandMarkdown, "assistant", params.sessionId, session.toolUseCache, routedNotificationClient, this.logger, { messageId: messageIdForGrouping(message) })) {
+                            if (usageMarkdown !== undefined) {
+                                if (usageMarkdown !== null) {
+                                    for (const notification of toAcpNotifications(usageMarkdown, "assistant", params.sessionId, session.toolUseCache, routedNotificationClient, this.logger, { messageId: messageIdForGrouping(message) })) {
                                         await sendUpdate(notification);
                                     }
                                 }
@@ -4940,7 +4803,6 @@ export class ClaudeAcpAgent {
                             if (typeof stripped === "string") {
                                 for (const notification of toAcpNotifications(stripped, message.message.role, params.sessionId, session.toolUseCache, routedNotificationClient, this.logger, {
                                     clientCapabilities: this.clientCapabilities,
-                                    toolCallCapabilities: this.toolCallCapabilities,
                                     parentToolUseId: message.parent_tool_use_id,
                                     cwd: session.cwd,
                                     taskState: session.taskState,
@@ -5022,7 +4884,6 @@ export class ClaudeAcpAgent {
                         }
                         for (const notification of toAcpNotifications(content, message.message.role, params.sessionId, session.toolUseCache, routedNotificationClient, this.logger, {
                             clientCapabilities: this.clientCapabilities,
-                            toolCallCapabilities: this.toolCallCapabilities,
                             parentToolUseId: message.parent_tool_use_id,
                             cwd: session.cwd,
                             taskState: session.taskState,
@@ -5212,36 +5073,6 @@ export class ClaudeAcpAgent {
             session.pendingOrphanResults = (session.pendingOrphanResults ?? 0) + 1;
         }
     }
-    /** Ask Claude Code to drop user messages it still has queued, so that a
-     *  prompt a cancel settled is not run after all. Claude Code keeps queued
-     *  messages through an interrupt and runs them next (the receipt's
-     *  `still_queued`), unless they are cancelled first with
-     *  `cancel_async_message`: a no-op for a message it already dequeued, which
-     *  then still runs, as an orphan (see `orphanCommands`).
-     *
-     *  Not awaited: the SDK writes control requests in call order, so the drops
-     *  reach Claude Code before a request sent after them, and a wedged CLI must
-     *  not hold up the cancel. The orphan accounting needs no update here: a
-     *  dropped message gets a `cancelled` lifecycle frame and is missing from the
-     *  interrupt receipt's `still_queued`, which both already account for. The
-     *  SDK implements the request as `Query.cancelAsyncMessage` without typing
-     *  it, so it is looked up, and a CLI that lacks it rejects the request. */
-    dropQueuedMessages(sessionId, query, uuids) {
-        const cancelAsyncMessage = query
-            .cancelAsyncMessage;
-        if (typeof cancelAsyncMessage !== "function")
-            return;
-        const logFailure = (uuid, error) => this.logger.error(`Session ${sessionId}: could not drop the queued message ${uuid} from Claude Code:`, error);
-        for (const uuid of uuids) {
-            // Called synchronously: deferring it would let the interrupt go first.
-            try {
-                Promise.resolve(cancelAsyncMessage.call(query, uuid)).catch((error) => logFailure(uuid, error));
-            }
-            catch (error) {
-                logFailure(uuid, error);
-            }
-        }
-    }
     async cancel(params) {
         await this.cancelTurns(params, { awaitInterrupt: true });
     }
@@ -5258,7 +5089,7 @@ export class ClaudeAcpAgent {
         }
         session.cancelled = true;
         for (const turn of session.turnQueue ?? [])
-            turn.localCommandAbort?.abort();
+            turn.usageMarkdownAbort?.abort();
         session.pendingExitPlanModeInterruption = undefined;
         session.pendingExitPlanContextReset = undefined;
         // The stream already ended (see closeQueryStream): every in-flight turn was
@@ -5287,16 +5118,12 @@ export class ClaudeAcpAgent {
             session.toolCallFields?.clear();
             clearHookCallbacks(params.sessionId);
         }
-        // The user messages this cancel abandons while Claude Code may still have
-        // them queued: they are dropped from its queue before the interrupt.
-        const abandoned = [];
         // A priority steer may still be queued in the SDK when cancellation
         // settles its owning turn. Its later echo matches no live turn, and its
         // result must be skipped rather than promoted onto the next prompt.
         if (isSteering(session.activeTurn)) {
             for (const uuid of session.activeTurn.steeredEchoes) {
                 this.trackOrphanCommand(session, uuid, "pending");
-                abandoned.push(uuid);
             }
         }
         // Capture the orphan-accounting lane before anything can await: the
@@ -5320,13 +5147,11 @@ export class ClaudeAcpAgent {
                     // accumulator (the active turn's tally) is not its spend.
                     turn.resolve({ stopReason: "cancelled" });
                     orphanedTurns.push(turn);
-                    abandoned.push(turn.promptUuid);
                 }
             }
-            // Each removed queued turn's user message was already pushed to the SDK.
-            // It is dropped from Claude Code's queue below (see dropQueuedMessages),
-            // but one Claude Code already dequeued still runs, FIFO, and emits a
-            // result with no user echo to match (0.3.246+ CLIs do stamp results with the
+            // Each removed queued turn's user message was already pushed to the SDK,
+            // which processes input FIFO and will still emit a result for it with no
+            // user echo to match (0.3.246+ CLIs do stamp results with the
             // triggering send's user_message_uuid, which ensureActiveTurn uses as
             // an exact join when present). Track those so the consumer skips them
             // (see ensureActiveTurn) rather than misattributing them to the head.
@@ -5389,23 +5214,15 @@ export class ClaudeAcpAgent {
         }
         // A deferred active turn (see Turn.deferredSettle) already has its result
         // and is only held open for subagents. A settling turn likewise has its
-        // result but is awaiting the bounded checkpoint preview. Settle it
-        // "cancelled" NOW where the consumer cannot: it cannot process the
-        // interrupt's trailing idle while blocked in that preview, and a held turn
-        // whose session sits idle gets no trailing idle (the interrupt emits
-        // nothing; with no state events consumed yet, the same is assumed).
-        // A held turn whose followup cycle is live (running, or blocked on a
-        // permission request) is left to that idle, like any live turn: the
-        // interrupt still flushes the cycle's output, which must reach the client
-        // before the turn ends cancelled. The captured outcome preserves usage and
-        // metadata (issue #844), while reporter state makes a late checkpoint
-        // response harmless.
+        // result but is awaiting the bounded checkpoint preview. Settle either one
+        // "cancelled" NOW: the consumer cannot process the interrupt's trailing
+        // idle while blocked in that preview, and a held turn may already be idle.
+        // The captured outcome preserves usage and metadata (issue #844), while
+        // reporter state makes a late checkpoint response harmless.
         {
             const active = session.activeTurn;
-            const followupLive = session.lastSessionState === "running" || session.lastSessionState === "requires_action";
-            if (active &&
-                (active.settling || (isHeldOpen(active) && !followupLive)) &&
-                (active.deferredSettle ?? active.settlingOutcome)) {
+            const pendingOutcome = active?.deferredSettle ?? active?.settlingOutcome;
+            if (active && pendingOutcome && (isHeldOpen(active) || active.settling)) {
                 session.fileChangeReporter?.finish(active.fileChangeReport, "cancelled");
                 active.settled = true;
                 // Mirror settleActive's invariants (it is consumer-scoped and
@@ -5419,16 +5236,17 @@ export class ClaudeAcpAgent {
                 // text since the last boundary was its followups', and left latched
                 // it would suppress a following replayed turn's issue-#453 fallback.
                 session.emittedAssistantText = false;
-                // When the interrupt below pre-empts a live cycle (a settling turn's,
-                // or one no state event reported), it produces a trailer idle with no
-                // counted result; that idle would be un-owed and could lag past the
-                // next prompt's echo — read as the fresh turn ending without a result
-                // (issue #825 false-fail).
-                // Pre-count it unless the session sits idle: there the interrupt
-                // emits nothing, and a debt that never drains would mask one future
-                // #825 detection. (lastSessionState is last-CONSUMED, so both stale
-                // reads exist and both are accepted one-cycle windows: a running
-                // transition still in the backlog reads as stale idle and
+                // When the interrupt below pre-empts a live cycle — running, or
+                // blocked on a permission request (requires_action, the #866 shape
+                // users cancel out of) — it produces a trailer idle with no counted
+                // result; with the hold's own trailer typically already absorbed,
+                // that idle would be un-owed and could lag past the next prompt's
+                // echo — read as the fresh turn ending without a result (issue #825
+                // false-fail). Pre-count it unless the session sits idle: there the
+                // interrupt emits nothing, and a debt that never drains would mask
+                // one future #825 detection. (lastSessionState is last-CONSUMED, so
+                // both stale reads exist and both are accepted one-cycle windows: a
+                // running transition still in the backlog reads as stale idle and
                 // under-counts — that false-fail additionally needs the trailer to
                 // lag past the next echo — while a cycle already completed into the
                 // backlog reads as stale non-idle and over-counts, masking one
@@ -5438,7 +5256,14 @@ export class ClaudeAcpAgent {
                 if (session.lastSessionState !== "idle") {
                     session.owedTrailingIdles++;
                 }
-                active.resolve(cancelledOutcome(session, active));
+                // Carries the held outcome's `_meta` too: a deferred outcome's only
+                // metadata is its quota breakdown, the counterpart of the usage taken
+                // from it here.
+                active.resolve({
+                    stopReason: "cancelled",
+                    usage: pendingOutcome.usage,
+                    ...(pendingOutcome._meta ? { _meta: pendingOutcome._meta } : {}),
+                });
             }
         }
         // A steered active turn (see Turn.steeredEchoes) settles "cancelled" in the
@@ -5471,9 +5296,6 @@ export class ClaudeAcpAgent {
                 cancelController.abort();
             }, this.forceCancelGraceMs);
         }
-        // Before the interrupt: once it stops the running turn, Claude Code starts
-        // the next queued message right away.
-        this.dropQueuedMessages(params.sessionId, session.query, abandoned);
         const interrupt = session.query.interrupt();
         if (!options.awaitInterrupt) {
             // The caller closes the query next, which rejects the pending reply.
@@ -5570,18 +5392,12 @@ export class ClaudeAcpAgent {
         session.query.close();
     }
     /** Cleanly tear down a session: cancel in-flight work, release stream
-     *  resources, and remove it from the session map. Returns once the turns it
-     *  cancels have ended, so their end (a v1 `session/prompt` response, a v2
-     *  `idle` state) goes out before the caller answers: ACP v2's
-     *  `session/close` cancels "as if `session/cancel` had been called", then
-     *  frees the session. A wedged consumer holds it at most
-     *  {@link TEARDOWN_TURN_END_TIMEOUT_MS}. */
+     *  resources, and remove it from the session map. */
     async teardownSession(sessionId) {
         const session = this.sessions[sessionId];
         if (!session) {
             return;
         }
-        const turnsEnded = Promise.all((session.turnQueue ?? []).flatMap((turn) => (turn.completion ? [turn.completion] : [])));
         try {
             await this.cancelTurns({ sessionId }, { awaitInterrupt: false });
         }
@@ -5609,10 +5425,6 @@ export class ClaudeAcpAgent {
         session.nativeSubagentRuntime?.clear();
         session.asyncTaskRuntime?.clear();
         delete this.sessions[sessionId];
-        const ended = await raceTimeoutAndAbort(turnsEnded, TEARDOWN_TURN_END_TIMEOUT_MS, new AbortController().signal);
-        if (ended.type === "timeout") {
-            this.logger.error(`Session ${sessionId}: its cancelled turns did not end within ${TEARDOWN_TURN_END_TIMEOUT_MS}ms of the teardown`);
-        }
     }
     /** Tear down all active sessions. Called when the ACP connection closes. */
     async dispose() {
@@ -5719,15 +5531,13 @@ export class ClaudeAcpAgent {
         await this.applyConfigOptionValue(params.sessionId, session, params.configId, effectiveValue);
         return { configOptions: session.configOptions };
     }
-    async replaySessionHistory(sessionId, resumedMessages, pending) {
+    async replaySessionHistory(sessionId, resumedMessages) {
         const replayStartedAt = performance.now();
         const toolUseCache = {};
         const messages = resumedMessages ?? (await getSessionMessages(sessionId));
         const historyLoadedAt = performance.now();
         this.logger.log(`[session/replay] sessionId=${sessionId} phase=read durationMs=${Math.round(historyLoadedAt - replayStartedAt)} messages=${messages.length}`);
-        // A pending replay has no session record yet. It uses the state that the record takes later.
-        const replayState = () => pending?.state ?? this.sessions[sessionId];
-        const session = replayState();
+        const session = this.sessions[sessionId];
         // A replay rebuilds the client view, so its plan goes out again.
         if (session?.taskState)
             forgetPublishedTaskPlan(session.taskState);
@@ -5739,12 +5549,7 @@ export class ClaudeAcpAgent {
                 sessionId,
                 state: session.sessionFailureState,
                 capabilities: this.clientCapabilities,
-                isCurrent: () => {
-                    const live = this.sessions[sessionId];
-                    if (!live)
-                        return pending !== undefined && !pending.stopped;
-                    return live.sessionFailureState === session.sessionFailureState;
-                },
+                isCurrent: () => this.sessions[sessionId] === session,
                 sendUpdate: (notification) => this.client.sessionUpdate(notification),
                 logger: this.logger,
             })
@@ -5899,7 +5704,7 @@ export class ClaudeAcpAgent {
             await replayAsyncTasks.taskNotification(notification);
         };
         const replayMessage = async (message) => {
-            if (pending?.stopped || isReplayHiddenMetaMessage(message)) {
+            if (isReplayHiddenMetaMessage(message)) {
                 return;
             }
             if (message.type === "user" &&
@@ -5913,7 +5718,7 @@ export class ClaudeAcpAgent {
             // a client-supplied id without an extra getSessionMessages read. Not read
             // yet (see Session.messageIdToUuid).
             const replayMessageId = messageIdForGrouping(message);
-            const replaySession = replayState();
+            const replaySession = this.sessions[sessionId];
             if (replaySession && replayMessageId && message.uuid) {
                 replaySession.messageIdToUuid.set(replayMessageId, message.uuid);
             }
@@ -6007,9 +5812,8 @@ export class ClaudeAcpAgent {
                 registerHooks: false,
                 replay: true,
                 clientCapabilities: this.clientCapabilities,
-                toolCallCapabilities: this.toolCallCapabilities,
-                cwd: replayState()?.cwd,
-                taskState: replayState()?.taskState,
+                cwd: this.sessions[sessionId]?.cwd,
+                taskState: this.sessions[sessionId]?.taskState,
                 messageId: replayMessageId,
                 parentToolUseId,
             })) {
@@ -6054,7 +5858,7 @@ export class ClaudeAcpAgent {
         };
         for (const message of messages)
             await replayMessage(message);
-        if (nativeReplayEnabled && !pending?.stopped) {
+        if (nativeReplayEnabled) {
             // Claude history persists sidechain messages and Agent/Task tool uses,
             // but not task_started/task_updated lifecycle frames. Recover terminal
             // state from the launch tool_result. Missing results and malformed or
@@ -6147,10 +5951,8 @@ export class ClaudeAcpAgent {
         // Do not rely on every ACP client settling requestPermission after the
         // cancellation signal. The local race guarantees that Claude's tool call
         // is released even when an older or broken client ignores $/cancel_request.
-        // The request goes to a subagent's child session for a tool call of that
-        // subagent, but it blocks the turn of the owner session.
         try {
-            return await this.withPendingUserInput(ownerSessionId, () => raceWithAbort(this.client.requestPermission(params, signal), signal));
+            return await this.withPendingUserInput(params.sessionId, () => raceWithAbort(this.client.requestPermission(params, signal), signal));
         }
         catch (error) {
             if (signal.aborted) {
@@ -6260,7 +6062,7 @@ export class ClaudeAcpAgent {
                 // Like permission requests, the elicitation references this toolUseID, so
                 // make sure the tool_call has surfaced to the client before we send it.
                 await this.ensureToolCallEmitted(sessionId, toolName, toolUseID, toolInput, parentToolUseId, signal, permissionSessionId);
-                return this.handleAskUserQuestion(sessionId, permissionSessionId, toolInput, toolUseID, signal);
+                return this.handleAskUserQuestion(permissionSessionId, toolInput, toolUseID, signal);
             }
             // Do not auto-allow here based on the session's advertised mode. Claude
             // Code applies bypassPermissions before invoking canUseTool; a request
@@ -6276,8 +6078,8 @@ export class ClaudeAcpAgent {
             const noPersistentRule = matchedAskRule !== undefined || suppressAlwaysAllowRule === true;
             const durableChangeSet = normalizeDurablePermissionChangeSet(suggestions, noPersistentRule);
             const capabilities = this.toolCallCapabilities;
-            const previewContent = capabilities.diffPatch || capabilities.v2
-                ? await previewPatchContent(toolName, toolInput, session.cwd, capabilities.v2 ? "v2" : "air")
+            const previewContent = capabilities.diffPatch
+                ? await previewPatchContent(toolName, toolInput, session.cwd)
                 : undefined;
             const presentation = buildClaudePermissionPresentation({
                 toolName,
@@ -6414,15 +6216,13 @@ export class ClaudeAcpAgent {
      * Present the built-in AskUserQuestion tool's questions as an ACP form
      * elicitation and return the answers as the tool's `updatedInput`. Called from
      * `canUseTool` since that is where the SDK routes the tool's permission check.
-     * The elicitation goes to `requestSessionId`, a subagent's child session for
-     * a question it asks, and blocks the turn of `sessionId`.
      */
-    async handleAskUserQuestion(sessionId, requestSessionId, toolInput, toolUseID, signal) {
+    async handleAskUserQuestion(sessionId, toolInput, toolUseID, signal) {
         const questions = extractAskUserQuestions(toolInput);
         if (!questions) {
             return { behavior: "deny", message: "AskUserQuestion called with no valid questions." };
         }
-        const createRequest = askUserQuestionsToCreateRequest(questions, requestSessionId, toolUseID, this.toolCallCapabilities.air.client);
+        const createRequest = askUserQuestionsToCreateRequest(questions, sessionId, toolUseID, this.toolCallCapabilities.air.client);
         let response;
         try {
             response = await this.withPendingUserInput(sessionId, () => this.client.createElicitation(createRequest, signal));
@@ -6492,7 +6292,7 @@ export class ClaudeAcpAgent {
             sessionId,
             update: {
                 sessionUpdate: "available_commands_update",
-                availableCommands: getAvailableSlashCommands(commands, session.terminalSlashCommands, this.toolCallCapabilities.air.client ? session.cwd : undefined, (session.skillPaths ??= new Map())),
+                availableCommands: getAvailableSlashCommands(commands, session.terminalSlashCommands),
             },
         });
     }
@@ -6813,8 +6613,6 @@ export class ClaudeAcpAgent {
     }
     async getOrCreateSession(params, resumedSession) {
         const existingSession = this.sessions[params.sessionId];
-        // A recreated live session keeps its mode, not the mode of the transcript.
-        const livePermissionMode = existingSession?.modes.currentModeId;
         if (existingSession) {
             const fingerprint = computeSessionFingerprint(params);
             if (fingerprint === existingSession.sessionFingerprint) {
@@ -6830,6 +6628,9 @@ export class ClaudeAcpAgent {
             // up the new values.
             await this.teardownSession(params.sessionId);
         }
+        const resumedModelHint = resumedSession
+            ? resumedSession.model
+            : await readResumedModel(params.sessionId, this.logger);
         const response = await this.createSession({
             cwd: params.cwd,
             mcpServers: params.mcpServers ?? [],
@@ -6837,8 +6638,7 @@ export class ClaudeAcpAgent {
             _meta: params._meta,
         }, {
             resume: params.sessionId,
-            permissionMode: livePermissionMode,
-            ...(resumedSession ? { resumedModelHint: resumedSession.model } : {}),
+            resumedModelHint,
         });
         return {
             sessionId: response.sessionId,
@@ -6867,12 +6667,6 @@ export class ClaudeAcpAgent {
             throw RequestError.invalidParams({ cwd }, `\`cwd\` is not a directory: ${cwd}`);
         }
     }
-    /** Whether the session forwards the text and the thinking of a subagent. */
-    forwardsSubagentText(meta) {
-        return (clientSupportsSubagents(this.clientCapabilities) ||
-            supportsSubagentTranscript(this.clientCapabilities) ||
-            meta?.claudeCode?.options?.forwardSubagentText === true);
-    }
     async createSession(params, creationOpts = {}) {
         const createStartedAt = performance.now();
         // Validate `cwd` up front. The ACP spec requires an absolute path, and the
@@ -6910,15 +6704,10 @@ export class ClaudeAcpAgent {
         // sign-out respawn, provider rerouting), so fill the same fast local hint
         // here when the caller did not provide it. Never fall back to the slow
         // getContextUsage control request.
-        // The same tail read gives the permission mode of the resumed session.
         let resumedModelHint = creationOpts.resumedModelHint;
-        let resumedPermissionMode;
-        if (creationOpts.resume !== undefined) {
-            const withModel = !Object.prototype.hasOwnProperty.call(creationOpts, "resumedModelHint");
-            const tail = await readResumedTail(creationOpts.resume, this.logger, withModel);
-            if (withModel)
-                resumedModelHint = tail.model;
-            resumedPermissionMode = tail.permissionMode;
+        if (creationOpts.resume !== undefined &&
+            !Object.prototype.hasOwnProperty.call(creationOpts, "resumedModelHint")) {
+            resumedModelHint = await readResumedModel(creationOpts.resume, this.logger);
             timing.phase("resume-transcript");
         }
         const input = new Pushable();
@@ -6980,11 +6769,7 @@ export class ClaudeAcpAgent {
         const allowBypass = ALLOW_BYPASS &&
             settingsManager.getSettings().permissions?.disableBypassPermissionsMode !== "disable" &&
             sessionMeta?.claudeCode?.options?.allowDangerouslySkipPermissions !== false;
-        const initialPermissionMode = resolveInitialPermissionMode({
-            explicit: creationOpts.permissionMode,
-            resumed: resumedPermissionMode,
-            defaultMode: settingsManager.getSettings().permissions?.defaultMode,
-        }, this.logger, allowBypass);
+        const initialPermissionMode = resolvePermissionMode(creationOpts.permissionMode ?? settingsManager.getSettings().permissions?.defaultMode, this.logger, allowBypass);
         const userProvidedOptions = sessionMeta?.claudeCode?.options
             ? { ...sessionMeta.claudeCode.options }
             : undefined;
@@ -6993,7 +6778,9 @@ export class ClaudeAcpAgent {
         // hidden state that the Client cannot inspect or change.
         if (userProvidedOptions)
             delete userProvidedOptions.agent;
-        const forwardSubagentText = this.forwardsSubagentText(params._meta);
+        const forwardSubagentText = clientSupportsSubagents(this.clientCapabilities) ||
+            supportsSubagentTranscript(this.clientCapabilities) ||
+            userProvidedOptions?.forwardSubagentText === true;
         // Configure thinking behavior from environment variable
         const thinking = resolveThinkingConfig(process.env.MAX_THINKING_TOKENS, this.logger);
         // Parse model configuration from environment (e.g. Bedrock model overrides)
@@ -7019,7 +6806,7 @@ export class ClaudeAcpAgent {
         // Per-session task state. Created here (rather than in the session record
         // below) so the TaskCreated/TaskCompleted hook callbacks can close over
         // the same Map that the streaming message handler will read from.
-        const taskState = creationOpts.replayState?.taskState ?? new Map();
+        const taskState = new Map();
         // Resolve every workspace root once. The native checkpoint report uses
         // this same set for lexical path validation, and the SDK receives it below.
         const acpAdditionalDirectories = params.additionalDirectories ?? sessionMeta?.additionalRoots ?? [];
@@ -7312,7 +7099,7 @@ export class ClaudeAcpAgent {
             const allowedModels = Array.isArray(settingsAvailableModels)
                 ? applyAvailableModelsAllowlist(initializationResult.models, settingsAvailableModels, settingsModelOverrides, settingsManager.getManagedDeniedModels())
                 : initializationResult.models;
-            const models = await getAvailableModels(q, allowedModels, initializationResult.models, settingsManager, this.logger, creationOpts.resume !== undefined, sessionId, await resumedModelHint);
+            const models = await getAvailableModels(q, allowedModels, initializationResult.models, settingsManager, this.logger, creationOpts.resume !== undefined, sessionId, resumedModelHint);
             timing.phase("models");
             // Resolve the current model's capabilities separately from the stable
             // permission-mode catalog advertised to ACP clients.
@@ -7461,8 +7248,8 @@ export class ClaudeAcpAgent {
                 nativeSubagentParentByToolUseId: new Map(),
                 emittedAssistantText: false,
                 owedTrailingIdles: 0,
-                messageIdToUuid: creationOpts.replayState?.messageIdToUuid ?? new Map(),
-                sessionFailureState: creationOpts.replayState?.sessionFailureState ?? createSessionFailureState(),
+                messageIdToUuid: new Map(),
+                sessionFailureState: createSessionFailureState(),
                 claudeSubscriptionGuard,
                 accountKind: fromAccountInfo(initializationResult.account)?.kind,
                 fileChangeReporter,
@@ -7503,10 +7290,7 @@ export class ClaudeAcpAgent {
                 this.closeQueryStream(session);
                 delete this.sessions[sessionId];
                 try {
-                    await this.createSession(session.creationParams, {
-                        resume: sessionId,
-                        permissionMode: session.modes.currentModeId,
-                    });
+                    await this.createSession(session.creationParams, { resume: sessionId });
                 }
                 catch (error) {
                     // One session that cannot come back must not abort the switch. The
@@ -7600,20 +7384,6 @@ function turnOutcome(session, stopReason, extraMeta) {
         _meta: { ...turnQuotaMeta(session), ...extraMeta },
     };
 }
-/** The outcome of `turn` when a cancel ends it. A turn that already has its
- *  result, because it is held open for its background subagents (see
- *  Turn.deferredSettle) or is settling (see Turn.settlingOutcome), keeps the
- *  usage and metadata that result recorded (issue #844). */
-function cancelledOutcome(session, turn) {
-    const recorded = turn?.deferredSettle ?? turn?.settlingOutcome;
-    if (!recorded)
-        return turnOutcome(session, "cancelled");
-    return {
-        stopReason: "cancelled",
-        usage: recorded.usage,
-        ...(recorded._meta ? { _meta: recorded._meta } : {}),
-    };
-}
 /** `_meta.quota` for a prompt response: what the turn spent, shaped like
  *  codex-acp's (snake_case container keys, camelCase counters) so a client
  *  reads one shape from either agent.
@@ -8001,20 +7771,7 @@ function getAvailableSlashCommands(commands,
 // Names the CLI tagged terminal-bound on `system`/init (their UX lives in
 // the CLI's own terminal, which ACP clients aren't) — filtered alongside
 // the static list. Raw CLI names, matched before the MCP rename.
-terminalCommands, 
-// The session cwd of an AIR client, or undefined for every other client.
-// AIR gets the kind and the SKILL.md path of each skill command.
-airSkillCwd, 
-// The resolved SKILL.md paths of the session, keyed by the cwd and the name.
-skillPaths) {
-    const skillPath = (name, cwd) => {
-        const key = `${cwd}\0${name}`;
-        if (skillPaths?.has(key))
-            return skillPaths.get(key);
-        const resolved = resolveSkillPath(name, cwd);
-        skillPaths?.set(key, resolved);
-        return resolved;
-    };
+terminalCommands) {
     const UNSUPPORTED_COMMANDS = [
         "clear",
         "cost",
@@ -8025,10 +7782,8 @@ skillPaths) {
         "release-notes",
         "todos",
     ];
-    // The adapter replaces the terminal text of `/mcp` and runs its actions,
-    // even when Claude Code tags the command terminal-bound.
-    const advertised = commands
-        .filter((command) => command.name !== "mcp" && !terminalCommands?.includes(command.name))
+    return commands
+        .filter((command) => !terminalCommands?.includes(command.name))
         .map((command) => {
         const input = command.argumentHint
             ? {
@@ -8038,26 +7793,16 @@ skillPaths) {
             }
             : null;
         let name = command.name;
-        const mcpPrompt = command.name.endsWith(" (MCP)");
-        if (mcpPrompt) {
+        if (command.name.endsWith(" (MCP)")) {
             name = `mcp:${name.replace(" (MCP)", "")}`;
         }
-        const skillMdPath = airSkillCwd && !command.builtin && !mcpPrompt
-            ? skillPath(command.name, airSkillCwd)
-            : undefined;
         return {
             name,
             description: command.description || "",
             input,
-            ...(skillMdPath
-                ? {
-                    _meta: withAirMeta(withAirMeta(undefined, AIR_KIND_KEY, "skill"), AIR_SKILL_PATH_KEY, skillMdPath),
-                }
-                : {}),
         };
     })
         .filter((command) => !UNSUPPORTED_COMMANDS.includes(command.name));
-    return [...advertised, MCP_AVAILABLE_COMMAND];
 }
 function formatUriAsLink(uri) {
     try {
@@ -8232,19 +7977,10 @@ function toolCallFieldsOf(session) {
  * Convert an SDKAssistantMessage (Claude) to a SessionNotification (ACP).
  * Only handles text, image, and thinking chunks for now.
  */
-/**
- * The renderer of the notification functions: the agent's tool call
- * capabilities when they are passed, else those of the ACP capabilities.
- */
-function toolCallRenderer(options) {
-    return options?.toolCallCapabilities
-        ? new AcpToolCallRenderer(options.toolCallCapabilities, options.replay)
-        : AcpToolCallRenderer.for(options?.clientCapabilities, options?.replay);
-}
 export function toAcpNotifications(content, role, sessionId, toolUseCache, client, logger, options) {
     const taskState = options?.taskState ?? new Map();
     const registerHooks = options?.registerHooks !== false;
-    const renderer = toolCallRenderer(options);
+    const renderer = AcpToolCallRenderer.for(options?.clientCapabilities, options?.replay);
     if (typeof content === "string") {
         if (content.length === 0) {
             return [];
@@ -8582,7 +8318,6 @@ export function streamEventToAcpNotifications(message, sessionId, toolUseCache,
     const streamedToolInputs = options?.streamedToolInputs;
     const forwardedOptions = {
         clientCapabilities: options?.clientCapabilities,
-        toolCallCapabilities: options?.toolCallCapabilities,
         parentToolUseId: message.parent_tool_use_id,
         cwd: options?.cwd,
         taskState: options?.taskState,
@@ -8646,7 +8381,7 @@ export function streamEventToAcpNotifications(message, sessionId, toolUseCache,
                 // TodoWrite and the Task* tools never surfaced a tool_call to refine.
                 if (!shouldEmitToolCall(streamedInput.name))
                     return [];
-                const update = toolCallRenderer(options).partialRefinement(streamedInput, input, options?.cwd);
+                const update = AcpToolCallRenderer.for(options?.clientCapabilities).partialRefinement(streamedInput, input, options?.cwd);
                 if (message.parent_tool_use_id)
                     stampParentToolUseId(update, message.parent_tool_use_id);
                 applyMessageId(update, options?.messageId);