@agentclientprotocol/claude-agent-acp 0.74.0 → 0.75.1

package/dist/acp-agent.js

@@ -6,6 +6,7 @@ import { AIR_NATIVE_SUBAGENT_SESSIONS_CAPABILITY, asSdkSessionNotification, clie
 import { isNativeSubagentControlTool, isNativeSubagentControlUpdate, NativeSubagentRuntime, } from "./native-subagents.js";
 import { AIR_ASYNC_TASKS_CAPABILITY, 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";
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
@@ -16,6 +17,8 @@ import { promisify } from "node:util";
 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 { readResumedSession } from "./resumed-session.js";
+import { SessionTiming } from "./session-timing.js";
 import { ALLOW_BYPASS, resolvePermissionMode } from "./permissions/modes.js";
 import { normalizeDurablePermissionChangeSet } from "./permissions/normalization.js";
 import { buildClaudePermissionOptions } from "./permissions/options.js";
@@ -25,11 +28,13 @@ import { SettingsManager } from "./settings.js";
 import { activeUsageLimitMessage, airSessionFailureCapabilityMeta, assistantMessageText, createSessionFailureState, isSyntheticUsageLimitMessage, providerFailureCategory, SessionFailureController, sessionFailureMeta, supportsAirSessionFailures, } from "./session-failure-extension.js";
 import { billsClaudeSubscription, CLAUDE_SUBSCRIPTION_NOT_SUPPORTED_MESSAGE, CLAUDE_SUBSCRIPTION_NOT_SUPPORTED_REASON, claudeLoginRequiredError, claudeSubscriptionNotSupportedError, holdsNonSubscriptionCredential, refuseClaudeSubscriptionTurn, shouldHideClaudeAuth, warnClaudeSubscriptionGuardDegraded, } from "./hide-claude-auth.js";
 import { AGENT_FILE_CHANGE_REPORT_CAPABILITY, agentFileChangeReportMeta, agentFileChangeReportRequestId, containsFileChangeAuditMarker, createFileChangeAuditSupport, createFileChangeAuditTurnState, FILE_CHANGE_AUDIT_SERVER_NAME, isFileChangeAuditReportPhase, isFileChangeAuditTool, supportsAgentFileChangeReport, } from "./file-change-audit.js";
+import { ContextCompactionLifecycle, contextCompactionMetadataFromBoundary, } from "./context-compaction.js";
 import { applyTaskCreate, applyTaskList, applyTaskUpdate, clearHookCallbacks, completeHookCallback, createPostToolUseHook, createTaskHook, parseTaskCreateOutput, parseTaskListOutput, parseTaskUpdateOutput, planEntries, registerHookCallback, taskStateToPlanEntries, toolInfoFromToolUse, toolUpdateFromDiffToolResponse, toolUpdateFromToolResult, unregisterHookCallback, } from "./tools.js";
 import { nodeToWebReadable, nodeToWebWritable, Pushable, unreachable } from "./utils.js";
 import { acceptedPlanToolResult, ExitPlanCoordinator, executionDiagnostic, exitPlanModeRawOutput, observeExitPlanToolResults, } from "./exit-plan.js";
 import { DEFAULT_AGENT_ID, EFFORT_CONFIG_ID } from "./session-config-ids.js";
 import { parseToolResultMeta } from "./tool-result-meta.js";
+import { formatUsageResponse, isUsageCommandText, parseUsageResponse } from "./usage-markdown.js";
 export { DEFAULT_AGENT_ID, EFFORT_CONFIG_ID } from "./session-config-ids.js";
 import { MODE_CONFIG_ID, SessionModeManager } from "./session-mode.js";
 export const CLAUDE_CONFIG_DIR = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
@@ -65,6 +70,57 @@ const DEFAULT_CONTEXT_WINDOW = 200000;
  *  "obviously stuck" ceiling, not a guess at interrupt latency, so it can't
  *  pre-empt a slow-but-healthy interrupt. */
 const DEFAULT_FORCE_CANCEL_GRACE_MS = 30_000;
+const STRUCTURED_USAGE_TIMEOUT_MS = 5_000;
+/** Best-effort structured presentation for a local `/usage` turn. The command
+ * itself always runs through Claude Code; null tells the consumer to forward
+ * its original output unchanged. The timeout prevents an unstable control
+ * request from holding an otherwise-completed local command indefinitely. */
+async function structuredUsageMarkdown(query, signal, logger) {
+    if (signal.aborted)
+        return null;
+    let timeout;
+    let onAbort;
+    try {
+        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(response);
+        if (!usage) {
+            logger.error("Structured /usage returned an incompatible response; preserving Claude Code output");
+            return null;
+        }
+        return formatUsageResponse(usage);
+    }
+    catch (error) {
+        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
  *  that listener's completion promise, so watch the server status while the
@@ -654,6 +710,25 @@ export class ClaudeAcpAgent {
     /** Serializes provider changes while every open query is recreated between turns. */
     providerUpdate = null;
     exitPlan;
+    /** Last auth identity reported to the client, connection-scoped like
+     *  `authenticate`/`logout`. Undefined means "not determined yet". */
+    currentAuthStatus;
+    /** In-flight `claude auth status --json` probe, shared by every caller so
+     *  a concurrent `initialize` and start-of-prompt read never spawn two CLI
+     *  processes. */
+    cliAuthProbe = null;
+    /** Counts auth-affecting events (`authenticate`, `logout`) on this
+     *  connection. A probe records it at start and publishes only if it has not
+     *  moved, so a slow read can never overwrite a newer login or logout. */
+    authEpoch = 0;
+    /** Keeps the "session account told us nothing" note to one line per process
+     *  instead of one per session. */
+    loggedUninformativeAccount = false;
+    /** Same, for the "client provider override active" note. */
+    loggedOverriddenAccount = false;
+    /** Same, for the "the CLI probe timed out" warning: a wedged CLI stays wedged
+     *  and would otherwise warn once per probe, i.e. once per user prompt. */
+    loggedProbeTimeout = false;
     /** Grace period before a `session/cancel` forces a wedged prompt loop to
      *  return "cancelled". See {@link DEFAULT_FORCE_CANCEL_GRACE_MS}. Mutable so
      *  tests can shrink it. */
@@ -711,6 +786,12 @@ export class ClaudeAcpAgent {
     }
     async initialize(request) {
         this.clientCapabilities = 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
+        // connection's first push, and unconditional, because nothing was reported
+        // before it. It is therefore sent after this response, never before it.
+        void this.probeCliAuthStatus();
         // Bypasses standard auth by routing requests through a custom Anthropic-protocol gateway.
         // Only offered when the client advertises `auth._meta.gateway` capability.
         const supportsGatewayAuth = request.clientCapabilities?.auth?._meta?.gateway === true;
@@ -822,6 +903,11 @@ export class ClaudeAcpAgent {
                     claudeCode: {
                         promptQueueing: true,
                     },
+                    // Capability marker for the `authStatus` extension: presence means
+                    // "this agent pushes its identity" and the object stays empty — it is
+                    // never a status payload. The state itself travels on
+                    // `_auth/status_update`; there is nothing for a client to ask for.
+                    authStatus: authStatusCapability(),
                 },
                 promptCapabilities: {
                     image: true,
@@ -885,6 +971,7 @@ export class ClaudeAcpAgent {
             await this.providerUpdate;
         return forkSession(params, {
             liveMessageIdToUuid: this.sessions[params.sessionId]?.messageIdToUuid,
+            logger: this.logger,
             messageIdForGrouping,
         });
     }
@@ -900,10 +987,14 @@ export class ClaudeAcpAgent {
         return result;
     }
     async loadSession(params) {
+        const timing = new SessionTiming(this.logger, "load", params.sessionId);
         if (this.providerUpdate)
             await this.providerUpdate;
-        const result = await this.getOrCreateSession(params);
-        await this.replaySessionHistory(params.sessionId);
+        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(() => {
             this.sendAvailableCommandsUpdate(params.sessionId);
@@ -952,10 +1043,201 @@ export class ClaudeAcpAgent {
                 }
             }
             this.gatewayAuthRequest = _params;
+            // The gateway holds the credentials from here on, so it replaces
+            // whatever the CLI store reported. Bumping the epoch discards any probe
+            // that started before this login: its answer is now stale.
+            this.authEpoch += 1;
+            this.setAuthStatus(gatewayAuthStatus(gatewayRequestToProviderConfig(this.gatewayAuthRequest)?.baseUrl));
             return;
         }
         throw new Error("Method not implemented.");
     }
+    /**
+     * Stores `next` and pushes it to the client.
+     *
+     * A push goes out only when the payload changed. The identity is read on many
+     * occasions — each session create, each guarded turn, the start of each user
+     * prompt — and almost all of them see the same login. Clients replace their
+     * whole state on each update and tolerate duplicates, so a repeat is
+     * harmless, but it is also pure noise; {@link sameAuthStatus} drops it.
+     *
+     * What the agent owes is truth — a stale or uninformative source must not
+     * reach here at all (see the epoch check in the probe and the guards at
+     * session create).
+     */
+    setAuthStatus(next) {
+        if (!next) {
+            return;
+        }
+        if (sameAuthStatus(this.currentAuthStatus, next)) {
+            return;
+        }
+        this.currentAuthStatus = next;
+        // ACP notifications get no reply, and clients that do not know the method
+        // drop it silently — send unconditionally and never fail a caller on it.
+        void Promise.resolve()
+            .then(() => this.client.extNotification(AUTH_STATUS_UPDATE_METHOD, { authStatus: next }))
+            .catch((error) => {
+            this.logger.error("Failed to send _auth/status_update:", error);
+        });
+    }
+    /**
+     * Report the identity behind a session's `AccountInfo`.
+     *
+     * `AccountInfo` is richer than the CLI probe (it is what the live query
+     * actually authenticates with). Called before the `--hide-claude-auth` guard
+     * may refuse the session or the turn: that flag blocks the *use* of a
+     * subscription, it does not make the state secret, and a refusal is when the
+     * client most needs to know the account it was refused for.
+     *
+     * Two cases skip it:
+     *
+     * - ACP gateway *authentication* (`gatewayAuthRequest`): the gateway, not
+     *   this account, is the agent-owned identity — already reported as
+     *   `kind: "gateway"` by `authenticate`.
+     * - A client-driven provider override (`providers/set`): the session then
+     *   routes through the client's endpoint and `AccountInfo` describes that
+     *   route (e.g. `apiProvider: "gateway"`), which is NOT agent-owned state.
+     *   `authStatus` reports the agent's own login only, so the CLI probe —
+     *   which reads the credential store the override never touches — stays
+     *   authoritative.
+     *
+     * An account with no identity signal (e.g. `{apiProvider: "firstParty"}`
+     * under an apiKeyHelper) means "nothing to add", not "logged out" — keep
+     * what the CLI probe already established instead of overwriting it.
+     */
+    publishSessionAccountIdentity(account) {
+        if (this.providerConfig) {
+            if (!this.loggedOverriddenAccount) {
+                this.loggedOverriddenAccount = true;
+                this.logger.log("[authStatus] client provider override active; keeping agent-owned probe state");
+            }
+            return;
+        }
+        if (this.gatewayAuthRequest) {
+            return;
+        }
+        const fromSession = fromAccountInfo(account);
+        if (fromSession) {
+            this.setAuthStatus(fromSession);
+        }
+        else if (!this.loggedUninformativeAccount) {
+            this.loggedUninformativeAccount = true;
+            this.logger.log("[authStatus] session account carries no identity signal; keeping probe");
+        }
+    }
+    /** Shares one in-flight `claude auth status --json` run between callers. The
+     *  promise is released once settled so a later call re-probes instead of
+     *  replaying a stale verdict. `fresh` forces a new run even when one is in
+     *  flight — `logout` needs a read that started after the credentials were
+     *  cleared. */
+    probeCliAuthStatus(options) {
+        if (!options?.fresh && this.cliAuthProbe) {
+            return this.cliAuthProbe;
+        }
+        const probe = this.runCliAuthProbe();
+        this.cliAuthProbe = probe;
+        void probe.finally(() => {
+            if (this.cliAuthProbe === probe) {
+                this.cliAuthProbe = null;
+            }
+        });
+        return probe;
+    }
+    /** Never rejects: an unavailable CLI means "not reported", not an error. */
+    async runCliAuthProbe() {
+        // Monotonicity: a read that started before the connection's latest
+        // auth-affecting event describes a world that no longer exists. Remember
+        // which one this read belongs to and drop the answer if it moved on.
+        const epoch = this.authEpoch;
+        // ACP gateway auth bypasses the CLI credential store entirely, so the
+        // probe would report an identity that is not the one being used. A mere
+        // client provider override (`providers/set`) does NOT skip the probe: it
+        // reroutes traffic without touching the credential store, and the store is
+        // exactly the agent-owned login `authStatus` reports.
+        if (this.gatewayAuthRequest) {
+            return this.currentAuthStatus;
+        }
+        let stdout;
+        try {
+            const cliPath = await claudeCliPath();
+            ({ stdout } = await execFileAsync(cliPath, ["auth", "status", "--json"], {
+                timeout: AUTH_STATUS_PROBE_TIMEOUT_MS,
+            }));
+        }
+        catch (error) {
+            const failed = error;
+            // Node killed the child on the timeout. Whatever it printed so far is a
+            // truncated fragment, never valid JSON: report nothing and keep the last
+            // known state, so nothing regresses and no push goes out.
+            if (failed?.killed === true && failed.signal) {
+                if (!this.loggedProbeTimeout) {
+                    this.loggedProbeTimeout = true;
+                    this.logger.error("claude auth status did not answer within 5 s; the identity is not refreshed");
+                }
+                return this.currentAuthStatus;
+            }
+            // The logged-out case exits 1 while still printing valid JSON, so the
+            // stdout of a failed exec is parsed just like a successful one.
+            if (typeof failed?.stdout !== "string" || failed.stdout.trim().length === 0) {
+                this.logger.error("claude auth status failed:", error instanceof Error ? error.message : String(error));
+                return undefined;
+            }
+            stdout = failed.stdout;
+        }
+        const status = fromCliStatus(stdout);
+        if (!status) {
+            this.logger.error("claude auth status returned unparseable output");
+            return undefined;
+        }
+        if (epoch !== this.authEpoch) {
+            // An `authenticate` or `logout` landed while this probe was running; the
+            // newer state wins and this answer is discarded, never published.
+            this.logger.log("[authStatus] discarding a probe that predates the latest auth change");
+            return this.currentAuthStatus;
+        }
+        // The CLI probe can be poorer than the session `AccountInfo` for the very
+        // same login (no organization, say). Keep those extra fields rather than
+        // regressing the payload; a different identity replaces it wholesale.
+        const merged = mergeAuthStatus(this.currentAuthStatus, status);
+        this.setAuthStatus(merged);
+        this.markSessionsWhoseAccountKindChanged(status.kind);
+        return merged;
+    }
+    /**
+     * Feed the completed probe to the `--hide-claude-auth` guard.
+     *
+     * The account cached at `initialize` is the guard's fact, and the CLI can
+     * swap the credential behind it between two turns (a Console key removed and
+     * a claude.ai login put in its place) without any turn failing. A read that
+     * reports a different kind of identity than the session was created on
+     * proves that fact stale.
+     *
+     * The probe decides nothing, and it interrupts nothing. Since the read is
+     * fired at the start of every user prompt, it usually lands in the middle of
+     * the turn it belongs to; all it may do there is set a flag. The turn runs to
+     * its end on the query it started on, the NEXT prompt consumes the flag and
+     * recreates the query, the new `initialize` reports the real account, and the
+     * creation guard judges it. So a probe can never refuse or abort a turn, and
+     * a wrong read costs one query recreation, not a false refusal.
+     */
+    markSessionsWhoseAccountKindChanged(kind) {
+        if (!this.claudeSubscriptionGuardActive()) {
+            return;
+        }
+        for (const [sessionId, session] of Object.entries(this.sessions)) {
+            // No kind: the account said nothing about the identity, so there is
+            // nothing this read can contradict.
+            if (!session.accountKind || session.queryClosed || session.needsSignOutRespawn) {
+                continue;
+            }
+            if (kind !== session.accountKind) {
+                // `endQuery: false` is the whole turn-boundary contract: the flag is
+                // set now, the query dies at the recreation the next prompt runs.
+                this.markSessionForSignOutRespawn(sessionId, session, { endQuery: false });
+            }
+        }
+    }
     async unstable_listProviders(_params) {
         const config = this.providerConfig ?? this.defaultProviderConfig();
         this.logger.log(`[providers/list] apiType=${config.apiType} baseUrl=${config.baseUrl} overridden=${this.providerConfig !== undefined}`);
@@ -1052,6 +1334,9 @@ export class ClaudeAcpAgent {
         // those paths.
         this.gatewayAuthRequest = undefined;
         this.providerConfig = undefined;
+        // Any probe already running read the pre-logout world; the bump makes its
+        // answer unpublishable so it cannot resurrect the identity being cleared.
+        this.authEpoch += 1;
         // Learned context windows are per-account state too: 1M-context
         // entitlement is gated per org/tier, and an OAuth re-login is invisible to
         // the env-derived provider cache key, so windows learned under the old
@@ -1071,6 +1356,14 @@ export class ClaudeAcpAgent {
                 : undefined;
             throw RequestError.internalError({ stderr: stderr || undefined }, `claude auth logout failed: ${error instanceof Error ? error.message : String(error)}`);
         }
+        // Re-read the store rather than assuming "none": an API key from the env
+        // or a key helper survives `auth logout`. The read must start after the
+        // credentials were cleared, so it never joins a probe that is already in
+        // flight. If it can't be read, the logout still happened — drop the
+        // now-stale identity instead of reporting it further.
+        if (!(await this.probeCliAuthStatus({ fresh: true }))) {
+            this.setAuthStatus(notLoggedInAuthStatus());
+        }
     }
     async prompt(params) {
         if (this.providerUpdate)
@@ -1079,6 +1372,15 @@ export class ClaudeAcpAgent {
         if (!session) {
             throw new Error("Session not found");
         }
+        // The one re-read per user prompt, fired here and never awaited: a prompt
+        // must not wait on a CLI process, and its result is pushed on change
+        // whenever it lands, mid-turn included. It runs BEFORE the guard on
+        // purpose — a refused prompt is exactly the one whose retry follows a
+        // sign-in in the terminal, and that retry is a new prompt, so the read
+        // that finds the new credential must not be the one the refusal skipped.
+        // The guard itself consumes the result only at the next turn boundary (see
+        // `markSessionsWhoseAccountKindChanged`).
+        void this.probeCliAuthStatus();
         const signOutRespawn = this.respawnSignedOutSession(params.sessionId, session);
         if (signOutRespawn)
             session = await signOutRespawn;
@@ -1113,6 +1415,10 @@ export class ClaudeAcpAgent {
             session.fileChangeReportRequestIds.add(fileChangeReportRequestId);
             fileChangeAudit = createFileChangeAuditTurnState(fileChangeReportRequestId);
         }
+        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 whose deferred the persistent consumer settles once
         // the turn's outcome is known. `prompt()` owns no loop: it enqueues the
@@ -1121,6 +1427,8 @@ export class ClaudeAcpAgent {
         const turn = {
             promptUuid,
             isLocalOnlyCommand,
+            ...(isUsageCommand ? { isUsageCommand: true } : {}),
+            ...(usageMarkdownAbort ? { usageMarkdownAbort } : {}),
             ...(fileChangeAudit ? { fileChangeAudit } : {}),
             settled: false,
             resolve: () => { },
@@ -1153,29 +1461,41 @@ export class ClaudeAcpAgent {
     claudeSubscriptionGuardActive() {
         return shouldHideClaudeAuth() && this.resolveProviderConfig() === null;
     }
-    /** Record that the CLI signed out during this session, and end the query.
+    /** Record that the account cached at `initialize` is wrong, and — unless the
+     *  caller defers it — end the query.
      *
-     *  Only under `--hide-claude-auth`. The account cached at `initialize` is
-     *  this integration's source of truth, and a sign-out proves that account
-     *  wrong: the credential behind it is gone, and whatever replaces it is
-     *  invisible until a new `initialize` runs. Closing the query here makes the
-     *  next turn recreate it, so the creation guard decides on the real account.
+     *  Only under `--hide-claude-auth`. That cached account is this
+     *  integration's source of truth, and two things prove it wrong: a sign-out
+     *  during the session, and a CLI probe that finds a different identity. In
+     *  both cases the credential behind the cached account is gone, and whatever
+     *  replaces it is invisible until a new `initialize` runs. The flag makes
+     *  the next prompt recreate the query, so the creation guard decides on the
+     *  real account.
+     *
+     *  `endQuery` says whether the query dies now. A sign-out has already killed
+     *  the turn, so its stream is closed at once. A probe has killed nothing: it
+     *  runs beside a turn that is still producing output, and closing there would
+     *  abort a turn the user is watching. It therefore leaves the stream alone
+     *  and lets the recreation at the next prompt close it (`recreateSignedOutQuery`
+     *  closes it too, and both are idempotent).
      *
      *  Idempotent: one sign-out reaches this twice (the synthetic login message
      *  and the turn's error-shaped result), and the second call must not close
      *  a stream the first one already closed. Closing settles the queued turns
      *  through the consumer's end-of-stream path, which rejects each one. */
-    markSessionForSignOutRespawn(sessionId, session) {
+    markSessionForSignOutRespawn(sessionId, session, options) {
         if (!shouldHideClaudeAuth() || session.needsSignOutRespawn) {
             return;
         }
         if (!session.creationParams) {
-            this.logger.error(`Session ${sessionId}: signed out, but the creation params are missing; cannot recreate the query`);
+            this.logger.error(`Session ${sessionId}: the identity behind the cached account changed, but the creation params are missing; cannot recreate the query`);
             return;
         }
         session.needsSignOutRespawn = true;
-        this.logger.log(`Session ${sessionId}: signed out; the query is recreated on the next turn`);
-        this.closeQueryStream(session);
+        this.logger.log(`Session ${sessionId}: the identity behind the cached account changed (sign-out, or a probe that found a different login); the query is recreated on the next turn`);
+        if (options?.endQuery !== false) {
+            this.closeQueryStream(session);
+        }
     }
     /** Recreate the query of a signed-out session, keeping the ACP session id and
      *  resuming the Claude session so the history survives. Returns the session
@@ -1194,11 +1514,21 @@ export class ClaudeAcpAgent {
      *
      *  Returns `undefined`, not a resolved promise, when no recreation is due:
      *  the callers enqueue their turn in one synchronous section, and an extra
-     *  microtask there would let the caller observe a half-built turn. */
+     *  microtask there would let the caller observe a half-built turn.
+     *
+     *  A live turn also postpones it. A probe marks the session without ending
+     *  the query, so a turn can still be running when the mark is read — by a
+     *  `steer` injecting into it, say. Recreating there would close the stream
+     *  under the turn and kill output the user is watching, so the flag waits for
+     *  the next turn boundary. A sign-out is not affected: it closed the stream
+     *  when it marked the session, and a closed stream recreates immediately. */
     respawnSignedOutSession(sessionId, session) {
         if (!session.needsSignOutRespawn) {
             return undefined;
         }
+        if (!session.queryClosed && (session.turnQueue ?? []).some((turn) => !turn.settled)) {
+            return undefined;
+        }
         return this.awaitSignOutRespawn(sessionId, session);
     }
     async awaitSignOutRespawn(sessionId, session) {
@@ -1270,6 +1600,9 @@ export class ClaudeAcpAgent {
             query: session.query,
             guardState: (session.claudeSubscriptionGuard ??= {}),
             logger: this.logger,
+            // The guard reads the account anyway; reuse that read to keep the
+            // reported identity current, refusal or not.
+            onAccount: (account) => this.publishSessionAccountIdentity(account),
             sessionFailures: () => new SessionFailureController({
                 sessionId,
                 state: session.sessionFailureState,
@@ -1505,11 +1838,6 @@ export class ClaudeAcpAgent {
         // stop_reason "refusal" and structured stop_details. We capture the
         // human-readable explanation so the terminal `result` can surface it.
         let lastRefusalExplanation = null;
-        // Tracks whether we're inside a compaction. The SDK emits the terminal
-        // `status` (compact_result success/failed) twice for a single failed
-        // compaction, and the two messages are indistinguishable — so we report the
-        // outcome only while a compaction is in progress, then clear this.
-        let compactionInProgress = false;
         // Anthropic API message id of the assistant message currently being
         // streamed, captured from `message_start` so the streamed chunks that follow
         // (whose delta events don't carry it) can all be tagged with the same,
@@ -1546,6 +1874,7 @@ export class ClaudeAcpAgent {
          *  as the turn's answer. */
         const subagents = (session.nativeSubagentRuntime ??= new NativeSubagentRuntime(clientSupportsSubagents(this.clientCapabilities), params.sessionId, session, async (notification) => this.client.sessionUpdate(asSdkSessionNotification(notification)), this.logger));
         const asyncTasks = (session.asyncTaskRuntime ??= new AsyncTaskRuntime(clientSupportsAsyncTasks(this.clientCapabilities), params.sessionId, async (notification) => this.client.sessionUpdate(asSdkSessionNotification(notification))));
+        const compaction = new ContextCompactionLifecycle((notification) => sendUpdate(notification));
         const sendUpdate = async (notification) => {
             const { update } = notification;
             const claudeMeta = update._meta?.claudeCode;
@@ -1574,6 +1903,11 @@ export class ClaudeAcpAgent {
                 return;
             }
             if (update.sessionUpdate === "agent_message_chunk") {
+                if (!claudeMeta?.parentToolUseId &&
+                    update.content.type === "text" &&
+                    compaction.consumeDuplicateErrorOutput(update.content.text)) {
+                    return;
+                }
                 if (!claudeMeta?.parentToolUseId) {
                     session.emittedAssistantText = true;
                     session.titles.onAssistantText(update.content);
@@ -1638,6 +1972,12 @@ export class ClaudeAcpAgent {
             await sessionFailures.clear((failure) => failure.recoveryPolicy === "next_attempt" && failure.turnId !== activeTurnId);
         };
         const internalErrorForClient = (data, rawDetail) => RequestError.internalError(data, supportsAirSessionFailures(this.clientCapabilities) ? undefined : rawDetail);
+        const ensureUsageMarkdown = (turn) => {
+            if (!turn.isUsageCommand || !turn.usageMarkdownAbort)
+                return undefined;
+            turn.usageMarkdown ??= structuredUsageMarkdown(session.query, turn.usageMarkdownAbort.signal, this.logger);
+            return turn.usageMarkdown;
+        };
         const resetTurnScratch = () => {
             lastAssistantTotalUsage = null;
             lastAssistantUsage = null;
@@ -1646,7 +1986,6 @@ export class ClaudeAcpAgent {
             lastAssistantWasUsageLimit = false;
             lastAssistantFailureTitle = undefined;
             lastRefusalExplanation = null;
-            compactionInProgress = false;
             // Do NOT reset currentStreamMessageId or streamedBlocks here. Turn
             // activation can fire mid-message (the replayed user echo with
             // --replay-user-messages lands between a message's blocks); clearing the
@@ -1679,6 +2018,7 @@ export class ClaudeAcpAgent {
         const activateTurn = (turn) => {
             session.activeTurn = turn;
             session.cancelled = false;
+            ensureUsageMarkdown(turn);
             session.pendingOrphanResults = 0;
             session.orphanCommands?.clear();
             // Two-phase sweep of registry entries the level signal ended (see
@@ -1864,6 +2204,30 @@ export class ClaudeAcpAgent {
          *  spelling of "a prompt is pending" shared by the head promotion and
          *  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 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 usageMarkdown = ensureUsageMarkdown(turn);
+            if (!usageMarkdown)
+                return undefined;
+            const markdown = await usageMarkdown;
+            if (markdown === null)
+                return undefined;
+            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.usageOriginalOutput === originalOutput ? null : undefined;
+            }
+            turn.usageMarkdownDelivered = true;
+            turn.usageOriginalOutput = originalOutput;
+            return markdown;
+        };
         /** Whether any background subagent this turn spawned is still live —
          *  while true, the turn's settlement stays deferred so the subagent's
          *  output and permission requests land inside it (see
@@ -1932,6 +2296,7 @@ export class ClaudeAcpAgent {
             // Captured before the settled flip below (isHeldOpen tests !settled).
             const wasHeld = isHeldOpen(turn);
             turn.settled = true;
+            turn.usageMarkdownAbort?.abort();
             disarmForceCancel(session);
             session.turnQueue = (session.turnQueue ?? []).filter((t) => t !== turn);
             session.activeTurn = null;
@@ -2343,42 +2708,15 @@ export class ClaudeAcpAgent {
                                 }
                                 break;
                             case "status": {
-                                // These banners count as delivered text (via sendUpdate), so
-                                // an echo-less turn that only ever emits them (e.g. `/compact`,
-                                // promoted at its own result) doesn't have its result text
-                                // re-emitted by the issue-#453 fallback.
                                 if (message.status === "compacting") {
-                                    compactionInProgress = true;
-                                    await sendUpdate({
-                                        sessionId: message.session_id,
-                                        update: {
-                                            sessionUpdate: "agent_message_chunk",
-                                            content: { type: "text", text: "Compacting..." },
-                                        },
-                                    });
+                                    await compaction.start(message.session_id, message.uuid);
                                 }
-                                else if (message.compact_result === "success" && compactionInProgress) {
-                                    // The SDK signals manual `/compact` completion with a status
-                                    // message carrying `compact_result`, not the `compact_boundary`
-                                    // message (which only fires when there's content to compact).
-                                    compactionInProgress = false;
-                                    await sendUpdate({
-                                        sessionId: message.session_id,
-                                        update: {
-                                            sessionUpdate: "agent_message_chunk",
-                                            content: { type: "text", text: "\n\nCompacting completed." },
-                                        },
-                                    });
+                                else if (message.compact_result === "success") {
+                                    await compaction.finish(message.session_id, message.uuid, "completed");
                                 }
-                                else if (message.compact_result === "failed" && compactionInProgress) {
-                                    compactionInProgress = false;
-                                    const reason = message.compact_error ? `: ${message.compact_error}` : ".";
-                                    await sendUpdate({
-                                        sessionId: message.session_id,
-                                        update: {
-                                            sessionUpdate: "agent_message_chunk",
-                                            content: { type: "text", text: `\n\nCompacting failed${reason}` },
-                                        },
+                                else if (message.compact_result === "failed") {
+                                    await compaction.finish(message.session_id, message.uuid, "failed", {
+                                        ...(message.compact_error ? { error: message.compact_error } : {}),
                                     });
                                 }
                                 break;
@@ -2389,26 +2727,22 @@ export class ClaudeAcpAgent {
                                 // right after the user sees "Compacting completed", which is
                                 // confusing and wrong.
                                 //
-                                // Prefer the SDK's authoritative post-compaction `used` via
-                                // getContextUsage — it reflects the real retained context
-                                // (system prompt + tools + surviving messages), which the
-                                // per-message API usage numbers can't give us until the next
-                                // turn's result. If the control request fails, fall back to the
-                                // used:0 approximation: directionally correct (context just
-                                // dropped dramatically) and replaced within seconds by the next
-                                // result message.
+                                // The compact boundary already carries the retained token
+                                // count. Prefer it over a getContextUsage control request,
+                                // which can block the live query for tens of seconds. Older
+                                // SDK frames without post_tokens fall back to used:0 and are
+                                // corrected by the next result message.
                                 //
                                 // `size` keeps coming from session.contextWindowSize —
                                 // compaction frees occupancy, it doesn't change the model's
                                 // window.
                                 //
-                                // The "Compacting completed." text is emitted from the `status`
-                                // handler (keyed on `compact_result`), not here, so the failure
-                                // path gets a message too.
-                                const usedTokens = await fetchContextUsedTokens(session.query, this.logger);
+                                const compactMetadata = message.compact_metadata;
+                                await compaction.finish(message.session_id, message.uuid, "completed", compactMetadata ? contextCompactionMetadataFromBoundary(compactMetadata) : {}, true);
+                                const usedTokens = compactMetadata?.post_tokens ?? 0;
                                 lastAssistantUsage = null;
-                                lastAssistantTotalUsage = usedTokens ?? 0;
-                                session.contextUsedTokens = usedTokens ?? 0;
+                                lastAssistantTotalUsage = usedTokens;
+                                session.contextUsedTokens = usedTokens;
                                 await sendUpdate({
                                     sessionId: message.session_id,
                                     update: {
@@ -2420,11 +2754,20 @@ export class ClaudeAcpAgent {
                                 break;
                             }
                             case "local_command_output": {
+                                if (compaction.consumeDuplicateErrorOutput(message.content)) {
+                                    break;
+                                }
+                                const usageTurn = session.activeTurn ?? firstUnsettledQueuedTurn();
+                                const usageMarkdown = await takeUsageMarkdown(message.content);
+                                if (usageTurn?.isUsageCommand && session.cancelled)
+                                    break;
+                                if (usageMarkdown === null)
+                                    break;
                                 await sendUpdate({
                                     sessionId: message.session_id,
                                     update: {
                                         sessionUpdate: "agent_message_chunk",
-                                        content: { type: "text", text: message.content },
+                                        content: { type: "text", text: usageMarkdown ?? message.content },
                                     },
                                 });
                                 break;
@@ -2462,6 +2805,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) {
+                                        compaction.reset();
                                         settleActive(turnOutcome(session, "cancelled"));
                                         // An interrupt can pre-empt the turn's result entirely
                                         // (nothing ran the result-case `finally`), so close the
@@ -2524,6 +2868,7 @@ export class ClaudeAcpAgent {
                                     else if (!session.cancelled &&
                                         session.activeTurn &&
                                         !session.activeTurn.settled) {
+                                        compaction.reset();
                                         // Deliberately only the ACTIVE turn: a queued turn that
                                         // was never echoed is NOT failed here, because an idle
                                         // can legitimately precede the SDK picking up freshly
@@ -3023,6 +3368,7 @@ export class ClaudeAcpAgent {
                             // through the early break below, which the gated `finally`
                             // leaves alone).
                             const deliveredAssistantText = session.emittedAssistantText;
+                            const deliveredCompactionOutput = compaction.hasDeliveredOutput;
                             // Every user-turn result terminates a turn (settle, reject, or
                             // orphan skip) and the SDK follows it with a trailing
                             // `session_state_changed: idle` — record the debt so the idle
@@ -3329,9 +3675,15 @@ export class ClaudeAcpAgent {
                                     // the fallback there. (Autonomous results never get here —
                                     // they exit at the early break above — so no background
                                     // prose can be injected into the feed.)
-                                    if (session.activeTurn?.isLocalOnlyCommand ||
-                                        (!deliveredAssistantText && (message.usage.output_tokens ?? 0) === 0)) {
-                                        for (const notification of toAcpNotifications(message.result, "assistant", params.sessionId, session.toolUseCache, routedNotificationClient, this.logger)) {
+                                    const shouldForwardResult = session.activeTurn?.isLocalOnlyCommand ||
+                                        (!deliveredAssistantText &&
+                                            !deliveredCompactionOutput &&
+                                            (message.usage.output_tokens ?? 0) === 0);
+                                    if (shouldForwardResult) {
+                                        const usageMarkdown = await takeUsageMarkdown(message.result);
+                                        if (usageMarkdown === null)
+                                            break;
+                                        for (const notification of toAcpNotifications(usageMarkdown ?? message.result, "assistant", params.sessionId, session.toolUseCache, routedNotificationClient, this.logger)) {
                                             await sendUpdate(notification);
                                         }
                                     }
@@ -3406,11 +3758,23 @@ export class ClaudeAcpAgent {
                         finally {
                             if (!isAutonomousResult) {
                                 session.emittedAssistantText = false;
+                                // A result closes this compaction lifecycle. Reset here rather
+                                // than at idle: an owed idle from this turn can arrive after
+                                // the next turn has already started and must not erase that
+                                // turn's compaction state.
+                                compaction.reset();
                             }
                         }
                         break;
                     }
                     case "stream_event": {
+                        const isCompactionProgress = (message.event.type === "content_block_start" &&
+                            message.event.content_block.type === "compaction") ||
+                            (message.event.type === "content_block_delta" &&
+                                message.event.delta.type === "compaction_delta");
+                        if (isCompactionProgress) {
+                            await compaction.heartbeat(message.session_id, message.uuid);
+                        }
                         // `message_start` carries the Anthropic API message id; capture it
                         // so the streamed chunks that follow (whose delta events don't carry
                         // it) can all be tagged with the same, replay-stable id.
@@ -3633,6 +3997,18 @@ export class ClaudeAcpAgent {
                         if (session.cancelled) {
                             break;
                         }
+                        // Synthetic assistant frames carry the CLI's local-command output.
+                        // On resume the SDK can replay a stale frame from an earlier compact
+                        // attempt after a later compaction completed. Scope suppression to
+                        // the compaction lifecycle and the synthetic frame itself rather
+                        // than to the owning turn: one model turn may compact more than once,
+                        // and its real assistant response must still be delivered.
+                        if (message.type === "assistant" &&
+                            message.parent_tool_use_id === null &&
+                            message.message.model === "<synthetic>" &&
+                            compaction.hasDeliveredOutput) {
+                            break;
+                        }
                         // Snapshot the latest top-level assistant usage and model so the
                         // next `result` can emit a usage_update tied to the right context
                         // window. Subagent messages are excluded to keep the snapshot
@@ -3661,15 +4037,29 @@ export class ClaudeAcpAgent {
                                     message.message.stop_details?.explanation ?? lastRefusalExplanation;
                             }
                         }
-                        // Strip <command-*>/<local-command-stdout> markers and render any
-                        // remaining prose. Skill bodies and built-in slash commands (e.g.
-                        // /usage, /status, /model) arrive wrapped in these tags; pure-marker
-                        // payloads (e.g. /compact's malformed output) strip to null and are
-                        // skipped. Mirrors the replay path at replaySessionHistory.
+                        // 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 turn; no content signatures or text parsing are involved.
+                        if (message.type === "assistant" &&
+                            message.parent_tool_use_id === null &&
+                            message.message.model === "<synthetic>") {
+                            const usageMarkdown = await takeUsageMarkdown(assistantMessageText(message.message) ?? "");
+                            if (session.cancelled)
+                                break;
+                            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);
+                                    }
+                                }
+                                break;
+                            }
+                        }
+                        const stringContent = typeof message.message.content === "string" ? message.message.content : undefined;
                         if (message.message.role !== "system" &&
-                            typeof message.message.content === "string" &&
-                            message.message.content.includes("<local-command-stdout>")) {
-                            const stripped = stripLocalCommandMetadata(message.message.content);
+                            stringContent?.includes("<local-command-stdout>")) {
+                            const stripped = stripLocalCommandMetadata(stringContent);
                             if (typeof stripped === "string") {
                                 for (const notification of toAcpNotifications(stripped, message.message.role, params.sessionId, session.toolUseCache, routedNotificationClient, this.logger, {
                                     clientCapabilities: this.clientCapabilities,
@@ -4004,6 +4394,8 @@ export class ClaudeAcpAgent {
             return;
         }
         session.cancelled = true;
+        for (const turn of session.turnQueue ?? [])
+            turn.usageMarkdownAbort?.abort();
         session.pendingExitPlanModeInterruption = undefined;
         session.pendingExitPlanContextReset = undefined;
         // The stream already ended (see closeQueryStream): every in-flight turn was
@@ -4432,9 +4824,12 @@ export class ClaudeAcpAgent {
         await this.applyConfigOptionValue(params.sessionId, session, params.configId, effectiveValue);
         return { configOptions: session.configOptions };
     }
-    async replaySessionHistory(sessionId) {
+    async replaySessionHistory(sessionId, resumedMessages) {
+        const replayStartedAt = performance.now();
         const toolUseCache = {};
-        const messages = await getSessionMessages(sessionId);
+        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}`);
         const session = this.sessions[sessionId];
         const forwardSubagentText = session?.forwardSubagentText ?? supportsSubagentTranscript(this.clientCapabilities);
         const supportsTypedFailures = supportsAirSessionFailures(this.clientCapabilities);
@@ -4703,6 +5098,8 @@ export class ClaudeAcpAgent {
                 }));
             }
         }
+        const replayFinishedAt = performance.now();
+        this.logger.log(`[session/replay] sessionId=${sessionId} phase=publish durationMs=${Math.round(replayFinishedAt - historyLoadedAt)} totalMs=${Math.round(replayFinishedAt - replayStartedAt)} messages=${messages.length}`);
     }
     async readTextFile(params) {
         const response = await this.client.readTextFile(params);
@@ -5308,7 +5705,7 @@ export class ClaudeAcpAgent {
             },
         });
     }
-    async getOrCreateSession(params) {
+    async getOrCreateSession(params, resumedSession) {
         const existingSession = this.sessions[params.sessionId];
         if (existingSession) {
             const fingerprint = computeSessionFingerprint(params);
@@ -5324,6 +5721,9 @@ export class ClaudeAcpAgent {
             // recreate it so the underlying Query process picks up the new values.
             await this.teardownSession(params.sessionId);
         }
+        const resumedModelHint = resumedSession
+            ? resumedSession.model
+            : (await readResumedSession(params.sessionId, this.logger)).model;
         const response = await this.createSession({
             cwd: params.cwd,
             mcpServers: params.mcpServers ?? [],
@@ -5331,6 +5731,7 @@ export class ClaudeAcpAgent {
             _meta: params._meta,
         }, {
             resume: params.sessionId,
+            resumedModelHint,
         });
         return {
             sessionId: response.sessionId,
@@ -5360,6 +5761,7 @@ export class ClaudeAcpAgent {
         }
     }
     async createSession(params, creationOpts = {}) {
+        const createStartedAt = performance.now();
         // Validate `cwd` up front. The ACP spec requires an absolute path, and the
         // directory must actually exist on the machine running the agent. Without
         // this check a session is created against a missing directory and the
@@ -5387,11 +5789,26 @@ export class ClaudeAcpAgent {
         else {
             sessionId = randomUUID();
         }
+        const timing = new SessionTiming(this.logger, "create", sessionId, createStartedAt);
+        timing.phase("validate-cwd");
+        // Most session/load calls already carry a transcript snapshot so history
+        // replay and model restoration share one local read. A few resume paths
+        // intentionally call createSession directly (legacy session/new metadata,
+        // 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.
+        let resumedModelHint = creationOpts.resumedModelHint;
+        if (creationOpts.resume !== undefined &&
+            !Object.prototype.hasOwnProperty.call(creationOpts, "resumedModelHint")) {
+            resumedModelHint = (await readResumedSession(creationOpts.resume, this.logger)).model;
+            timing.phase("resume-transcript");
+        }
         const input = new Pushable();
         const settingsManager = new SettingsManager(params.cwd, {
             logger: this.logger,
         });
         await settingsManager.initialize();
+        timing.phase("settings");
         const mcpServers = {};
         if (Array.isArray(params.mcpServers)) {
             for (const server of params.mcpServers) {
@@ -5619,7 +6036,7 @@ export class ClaudeAcpAgent {
                 // switches the session's model with no refusal-fallback frame, and
                 // the client's picker silently drifts. `source: 'sdk'` is the
                 // adapter's own setModel (applyConfigOptionValue already synced it),
-                // and 'resume' restores are read back via readResumedLiveModel, so
+                // and 'resume' restores are read from the transcript before startup, so
                 // only the remaining sources sync here (CLI 2.1.251+; older CLIs
                 // never fire the hook and keep the pre-hook behavior).
                 PostModelSwitch: [
@@ -5701,6 +6118,7 @@ export class ClaudeAcpAgent {
             prompt: input,
             options,
         });
+        timing.phase("prepare-query");
         // `query()` spawns the CLI at once. Any throw between here and the
         // registration in `this.sessions` would leave that child process running
         // with nobody holding the query, so discard it before propagating.
@@ -5718,6 +6136,11 @@ export class ClaudeAcpAgent {
                 }
                 throw error;
             }
+            timing.phase("sdk-initialize");
+            // Publish the identity BEFORE the guard can refuse this session. A
+            // refusal is exactly when the client most needs to know which account it
+            // was refused for.
+            this.publishSessionAccountIdentity(initializationResult.account);
             // Shared with the per-turn guard, so "warn once" spans the whole session.
             const claudeSubscriptionGuard = {};
             if (this.claudeSubscriptionGuardActive()) {
@@ -5751,7 +6174,8 @@ export class ClaudeAcpAgent {
             const allowedModels = Array.isArray(settingsAvailableModels)
                 ? applyAvailableModelsAllowlist(initializationResult.models, settingsAvailableModels, settingsModelOverrides)
                 : initializationResult.models;
-            const { modelState: models, resumedContextWindow } = await getAvailableModels(q, allowedModels, initializationResult.models, settingsManager, this.logger, creationOpts.resume !== undefined);
+            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.
             // A resumed session can be running a model outside the `availableModels`
@@ -5793,7 +6217,9 @@ export class ClaudeAcpAgent {
                 currentModelInfo,
                 currentModelId: models.currentModelId,
             });
+            timing.phase("modes");
             const agents = await discoverCustomAgents(q);
+            timing.phase("agents");
             // Only adopt the requested agent as the selected value if it's one we
             // actually surface in the picker. A built-in (filtered out above) or
             // otherwise-unknown name would leave the config option's `currentValue`
@@ -5831,18 +6257,13 @@ export class ClaudeAcpAgent {
             // model switch. Only a user's explicit ACP picker choice pins the flag
             // (see applyConfigOptionValue / Session.effortPinnedByUser).
             const configOptions = buildConfigOptions(modes, models, modelInfos, settingsEffortForModel(settingsManager.getSettings(), currentModelInfo), agents, currentAgent, fastMode);
-            // Seed the context window WITHOUT any extra IPC on the session/new path.
-            // On session/load, the resumed session's own `getContextUsage` report — a
-            // response `getAvailableModels` already awaited to learn the live model
-            // (resumed sessions ARE serviced pre-turn, unlike fresh ones) — is
-            // authoritative and wins. Otherwise: the cached authoritative window if a
-            // prior turn has learned it for this model (`result.modelUsage`,
-            // cross-session), else the text heuristic, else the default. We
-            // deliberately do NOT issue a getContextUsage call here: on a fresh
-            // session that control request is not serviced until the first prompt
-            // turn runs, so awaiting it — as 0.59.0 did — made session/new take ~15s
-            // (issues #886/#880). The authoritative window arrives on the first
-            // `result.modelUsage` and is cached from there.
+            // Seed the context window without extra IPC. The cached authoritative
+            // window from a prior turn wins (`result.modelUsage`, cross-session),
+            // then the text heuristic, then the default. We deliberately do NOT issue
+            // a getContextUsage call here: before the first prompt turn that control
+            // request can take tens of seconds, on resumed as well as fresh sessions.
+            // The authoritative window arrives on the first `result.modelUsage` and
+            // is cached from there.
             //
             // Text inference alone misses aliases that resolve to extended-context
             // models with no "1m" token anywhere in their id or description (e.g.
@@ -5850,17 +6271,14 @@ export class ClaudeAcpAgent {
             // `usage_update.size: 200000` until the first result's modelUsage corrects
             // it — but the cache means only the FIRST session to ever run a turn on such
             // a model eats that window, not every fresh session after a process
-            // restart (issue #596; a post-restart session/load is covered by the
-            // resumed report above).
+            // restart (issue #596).
             //
             // The inference fallback is deliberately keyed to the allowlisted entry: a
             // fallback-resolved sibling's resolvedModel/displayName/description can
             // describe a different context lane than the verbatim live id (e.g. an
             // "opus[1m]" row matched for a bare 200k id), so on the fallback path only
             // the id itself is a trustworthy window signal.
-            const seededWindow = resumedContextWindow !== null
-                ? { size: resumedContextWindow, authoritative: true }
-                : immediateContextWindow(providerCacheKey, models.currentModelId, allowlistedModelInfo);
+            const seededWindow = immediateContextWindow(providerCacheKey, models.currentModelId, allowlistedModelInfo);
             this.sessions[sessionId] = {
                 query: q,
                 input: input,
@@ -5907,9 +6325,11 @@ export class ClaudeAcpAgent {
                 messageIdToUuid: new Map(),
                 sessionFailureState: createSessionFailureState(),
                 claudeSubscriptionGuard,
+                accountKind: fromAccountInfo(initializationResult.account)?.kind,
                 fileChangeReportRequestIds: new Set(),
                 fileChangeAuditSupport,
             };
+            timing.phase("register");
             return {
                 sessionId,
                 modes,
@@ -6786,17 +7206,6 @@ export function applyAvailableModelsAllowlist(sdkModels, allowlist, settingsMode
     }
     return result;
 }
-/** Read the model a resumed session is actually running (via the
- *  `getContextUsage` control request — the same source `/context` prints) and
- *  map it onto the picker, along with the report's authoritative context
- *  window (`rawMaxTokens`). Resumed sessions get this request serviced before
- *  any turn runs in the new process — unlike fresh sessions, where it stalls
- *  until the first prompt turn (issues #886/#880) — so the same response that
- *  restores the live model (issue #845) also seeds the window for free,
- *  covering post-restart reloads of models the text heuristic misses (issue
- *  #596). Best-effort: a control-request failure is logged and returns nulls
- *  so callers keep their current choice; failing the whole session/load over
- *  an unreadable report would be worse. */
 /** Whether a rejected `setModel` was vetoed by a user-configured
  *  PreModelSwitch hook. The CLI's rejection message is the stable,
  *  distinguishable marker ("Model switch blocked by a PreModelSwitch hook:
@@ -6805,28 +7214,10 @@ export function applyAvailableModelsAllowlist(sdkModels, allowlist, settingsMode
 function isPreModelSwitchHookBlock(error) {
     return error instanceof Error && error.message.includes("blocked by a PreModelSwitch hook");
 }
-async function readResumedLiveModel(query, models, logger) {
-    try {
-        const usage = await query.getContextUsage();
-        return {
-            model: usage.model ? matchResumedModel(models, usage.model) : null,
-            contextWindow: usage.rawMaxTokens > 0 ? usage.rawMaxTokens : null,
-        };
-    }
-    catch (error) {
-        logger.error("Failed to read the resumed session's live model:", error);
-        return { model: null, contextWindow: null };
-    }
-}
-async function getAvailableModels(query, models, sdkModels, settingsManager, logger, isResumedSession) {
+async function getAvailableModels(query, models, sdkModels, settingsManager, logger, isResumedSession, sessionId, resumedModelHint) {
     const settings = settingsManager.getSettings();
     let currentModel = models[0];
     let resolvedFromInput;
-    // The context window reported alongside a resumed session's live model.
-    // Only ever non-null on the paths where `currentModel` IS the live model
-    // (no override, or a failed override re-assert), so the window always
-    // describes the model the session actually runs.
-    let resumedContextWindow = null;
     // Model priority (highest to lowest):
     // 1. ANTHROPIC_MODEL environment variable
     // 2. settings.model (user configuration)
@@ -6846,17 +7237,14 @@ async function getAvailableModels(query, models, sdkModels, settingsManager, log
             resolvedFromInput = settings.model;
         }
     }
-    // A resumed session restores the model it was previously running (the CLI
-    // re-reads it from the transcript), so without an env/settings override the
-    // freshly-computed default above can disagree with what the session actually
-    // runs — session/load then reports a model the session isn't using (issue
-    // #845). Ask the CLI for the live model and reflect it. No `setModel` here:
-    // the SDK is already running this model, and pushing a picker alias back
-    // (e.g. "opus[1m]") could change the live model rather than describe it.
+    // A resumed session restores the model from its last real assistant
+    // transcript record. Use that same local record instead of getContextUsage:
+    // the latter is a control request to the live CLI process and can add tens
+    // of seconds to session/load before its first turn. No `setModel` here: the
+    // SDK is already running this model, and pushing a picker alias back (e.g.
+    // "opus[1m]") could change the live model rather than describe it.
     if (resolvedFromInput === undefined && isResumedSession) {
-        const live = await readResumedLiveModel(query, models, logger);
-        currentModel = live.model ?? currentModel;
-        resumedContextWindow = live.contextWindow;
+        currentModel = resumedModelHint ? matchResumedModel(models, resumedModelHint) : currentModel;
     }
     // Skip the setModel round-trip when we can prove the SDK has already landed
     // on the same model. Two cases qualify:
@@ -6875,10 +7263,13 @@ async function getAvailableModels(query, models, sdkModels, settingsManager, log
     const skipSetModel = resolvedFromInput === undefined ||
         (!isResumedSession && currentModel.value === resolvedFromInput && sdkSawSameValue);
     if (!skipSetModel) {
+        const setModelStartedAt = performance.now();
         try {
             await query.setModel(currentModel.value);
+            logger.log(`[session/models] sessionId=${sessionId} phase=set-model durationMs=${Math.round(performance.now() - setModelStartedAt)} model=${currentModel.value} outcome=success`);
         }
         catch (error) {
+            logger.log(`[session/models] sessionId=${sessionId} phase=set-model durationMs=${Math.round(performance.now() - setModelStartedAt)} model=${currentModel.value} outcome=error`);
             // On a fresh session the pin is a defining option — fail loudly. A
             // resumed session already runs fine on the transcript's model, so
             // failing the whole session/load over the re-assert would be worse
@@ -6905,22 +7296,17 @@ async function getAvailableModels(query, models, sdkModels, settingsManager, log
             }
             else {
                 logger.error(`Failed to re-assert model "${currentModel.value}" on resume:`, error);
-                const live = await readResumedLiveModel(query, models, logger);
-                currentModel = live.model ?? currentModel;
-                resumedContextWindow = live.contextWindow;
+                currentModel = resumedModelHint ? matchResumedModel(models, resumedModelHint) : models[0];
             }
         }
     }
     return {
-        modelState: {
-            availableModels: models.map((model) => ({
-                modelId: model.value,
-                name: model.displayName,
-                description: model.description,
-            })),
-            currentModelId: currentModel.value,
-        },
-        resumedContextWindow,
+        availableModels: models.map((model) => ({
+            modelId: model.value,
+            name: model.displayName,
+            description: model.description,
+        })),
+        currentModelId: currentModel.value,
     };
 }
 function getAvailableSlashCommands(commands, 
@@ -7850,30 +8236,13 @@ function commonPrefixLength(a, b) {
  *  models with no "1m" anywhere (e.g. `sonnet` → claude-sonnet-5, natively
  *  ~1M). Such a miss falls back to the default window and is corrected by
  *  `result.modelUsage` (and cached) within one turn. We do NOT consult the
- *  SDK's `getContextUsage` to close that gap: on a fresh session it is not
- *  serviced before the first prompt turn (issues #886/#880, see
- *  `contextWindowCache`; resumed sessions do get it, via
- *  `readResumedLiveModel`). */
+ *  SDK's `getContextUsage` to close that gap: before the first prompt turn it
+ *  can take tens of seconds (issues #886/#880, see `contextWindowCache`). */
 function inferContextWindowFromModel(...texts) {
     if (texts.some((text) => text != null && /\b1m\b/i.test(text)))
         return 1_000_000;
     return null;
 }
-/** Fetch the SDK's authoritative context-window occupancy via the
- *  `getContextUsage` control request. Unlike the per-message API usage numbers
- *  (which only count message tokens), this `totalTokens` includes the system
- *  prompt, tool schemas, MCP tools, and memory-file overhead — the real
- *  occupancy the user sees. Returns `null` on any control-request failure. */
-async function fetchContextUsedTokens(query, logger) {
-    try {
-        const usage = await query.getContextUsage();
-        return usage.totalTokens;
-    }
-    catch (error) {
-        logger.error("Failed to fetch context usage from SDK:", error);
-        return null;
-    }
-}
 /** Cross-session cache of authoritative context windows, keyed by
  *  `${providerCacheKey}\0${modelId}` (see {@link contextWindowCacheKey}).
  *  The window is a property of (model id, backend): the same resolved model id
@@ -7894,9 +8263,6 @@ async function fetchContextUsedTokens(query, logger) {
  *  has run the control request is not serviced (it stalls ~15s, and serializes
  *  ahead of an awaited `setModel` — issues #886/#880, regressed in 0.59.0), so
  *  it can neither beat the first `result` nor be issued cheaply before one.
- *  Resumed sessions are the exception — their report IS serviced pre-turn, and
- *  the session/load path seeds (but does not cache) the window from the same
- *  response that restores the live model, see `readResumedLiveModel`.
  *  Cleared on `logout`: 1M-context entitlement can differ per account/tier, so
  *  windows learned under one login must not seed sessions under the next. */
 const contextWindowCache = new Map();