claude-code-rust 0.14.2 → 0.14.4

package/README.md

@@ -2,11 +2,10 @@
 
 A native Rust terminal interface for Claude Code. Drop-in replacement for Anthropic's stock Node.js/React Ink TUI, built for performance and a better user experience.
 
-[![npm version](https://img.shields.io/npm/v/claude-code-rust)](https://www.npmjs.com/package/claude-code-rust)
-[![npm downloads](https://img.shields.io/npm/dm/claude-code-rust)](https://www.npmjs.com/package/claude-code-rust)
+[![Version](https://img.shields.io/github/v/release/srothgan/claude-code-rust?label=version)](https://github.com/srothgan/claude-code-rust/releases/latest)
 [![CI](https://github.com/srothgan/claude-code-rust/actions/workflows/pr.yml/badge.svg)](https://github.com/srothgan/claude-code-rust/actions/workflows/pr.yml)
 [![Docs](https://img.shields.io/badge/docs-GitHub%20Pages-blue)](https://srothgan.github.io/claude-code-rust/)
-[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue)](https://www.apache.org/licenses/LICENSE-2.0)
 
 <p align="center">
   <img src="assets/banner.png" alt="Claude Code Rust running a Read tool call with syntax-highlighted output" width="900">

package/agent-sdk/dist/bridge/account_metadata.js

@@ -9,7 +9,9 @@ const KNOWN_API_PROVIDERS = new Set([
     "gateway",
 ]);
 function trimmedString(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : undefined;
 }
 export function isKnownApiProvider(provider) {
     return provider !== undefined && KNOWN_API_PROVIDERS.has(provider);
@@ -20,7 +22,9 @@ export function apiProviderIsExternal(provider) {
 export function mapSdkAccountInfo(account) {
     const apiProvider = trimmedString(account.apiProvider);
     return {
-        ...(trimmedString(account.email) ? { email: trimmedString(account.email) } : {}),
+        ...(trimmedString(account.email)
+            ? { email: trimmedString(account.email) }
+            : {}),
         ...(trimmedString(account.organization)
             ? { organization: trimmedString(account.organization) }
             : {}),

package/agent-sdk/dist/bridge/agents.js

@@ -23,13 +23,16 @@ export function mapAvailableAgents(value) {
             continue;
         }
         const description = typeof record.description === "string" ? record.description : "";
-        const model = typeof record.model === "string" && record.model.trim().length > 0 ? record.model : undefined;
+        const model = typeof record.model === "string" && record.model.trim().length > 0
+            ? record.model
+            : undefined;
         const existing = byName.get(name);
         if (!existing) {
             byName.set(name, { name, description, model });
             continue;
         }
-        if (existing.description.trim().length === 0 && description.trim().length > 0) {
+        if (existing.description.trim().length === 0 &&
+            description.trim().length > 0) {
             existing.description = description;
         }
         if (!existing.model && model) {
@@ -58,7 +61,10 @@ export function emitAvailableAgentsIfChanged(session, agents) {
         return;
     }
     session.lastAvailableAgentsSignature = signature;
-    emitSessionUpdate(session.sessionId, { type: "available_agents_update", agents });
+    emitSessionUpdate(session.sessionId, {
+        type: "available_agents_update",
+        agents,
+    });
 }
 export function refreshAvailableAgents(session) {
     if (typeof session.query.supportedAgents !== "function") {

package/agent-sdk/dist/bridge/available_commands.js

@@ -4,7 +4,11 @@ function isDynamicSource(source) {
     return source === "commands_changed" || source === "reload_plugins";
 }
 function commandSignature(commands) {
-    return JSON.stringify(commands.map((command) => [command.name, command.description, command.input_hint ?? ""]));
+    return JSON.stringify(commands.map((command) => [
+        command.name,
+        command.description,
+        command.input_hint ?? "",
+    ]));
 }
 function logAvailableCommandsDecision(session, source, commands, outcome, reason, generation) {
     bridgeLogger.info({
@@ -35,7 +39,10 @@ function shouldAcceptAvailableCommandsSnapshot(session, source, commands) {
     }
     if (!current) {
         if (commands.length === 0) {
-            return { accept: false, reason: "empty bootstrap snapshot ignored before first command list" };
+            return {
+                accept: false,
+                reason: "empty bootstrap snapshot ignored before first command list",
+            };
         }
         return { accept: true, reason: "initial command snapshot" };
     }
@@ -54,7 +61,10 @@ function shouldAcceptAvailableCommandsSnapshot(session, source, commands) {
     if (commands.length === 0) {
         return { accept: false, reason: "empty bootstrap snapshot ignored" };
     }
-    return { accept: true, reason: "bootstrap refresh before dynamic command source" };
+    return {
+        accept: true,
+        reason: "bootstrap refresh before dynamic command source",
+    };
 }
 export function updateAvailableCommands(session, source, commands) {
     const decision = shouldAcceptAvailableCommandsSnapshot(session, source, commands);

package/agent-sdk/dist/bridge/command_lifecycle.js

@@ -1,9 +1,9 @@
 import { getSessionMessages, listSessions, } from "@anthropic-ai/claude-agent-sdk";
-import { currentSessionListOptions, emitSessionsList, failConnection, setSessionListingDir, slashError, writeEvent, } from "./events.js";
+import { currentSessionListOptions, emitSessionResumeFailed, emitSessionsList, failConnection, setSessionListingDir, slashError, writeEvent, } from "./events.js";
 import { mapSessionMessagesToUpdates } from "./history.js";
 import { bridgeLogger, LOG_TARGETS } from "./logger.js";
-import { closeAllSessions, createSession, sessions, } from "./session_lifecycle.js";
-export async function handleLifecycleCommand(command, requestId, sdkVersionError) {
+import { awaitSessionInitialization, closeAllSessions, closeSessionWithLogging, commitDeferredSession, createSession, detachSessionForClose, sessions, } from "./session_lifecycle.js";
+export async function handleLifecycleCommand(command, requestId, sdkVersionError, deps) {
     switch (command.command) {
         case "initialize":
             await initialize(command, requestId, sdkVersionError);
@@ -14,6 +14,9 @@ export async function handleLifecycleCommand(command, requestId, sdkVersionError
         case "resume_session":
             await resume(command, requestId);
             return;
+        case "resume_session_at":
+            await resumeAt(command, requestId, deps.buildRewindConversationPlan);
+            return;
         case "new_session":
             await replace(command, requestId);
             return;
@@ -21,6 +24,76 @@ export async function handleLifecycleCommand(command, requestId, sdkVersionError
             await shutdown(requestId);
     }
 }
+async function resumeAt(command, requestId, buildPlan) {
+    if (!requestId) {
+        slashError(command.session_id, "resume before a selected message requires an operation id");
+        return;
+    }
+    const targetUserMessageId = command.target_user_message_id.trim();
+    if (!targetUserMessageId) {
+        emitSessionResumeFailed(command.session_id, requestId, "resume target cannot be empty");
+        return;
+    }
+    let candidate;
+    try {
+        const sdkSessions = await listSessions(currentSessionListOptions());
+        const matched = sdkSessions.find((entry) => entry.sessionId === command.session_id);
+        if (!matched) {
+            emitSessionResumeFailed(command.session_id, requestId, `unknown session: ${command.session_id}`);
+            return;
+        }
+        const cwd = matched.cwd ?? process.cwd();
+        setSessionListingDir(cwd);
+        const historyMessages = await getSessionMessages(command.session_id, {
+            dir: cwd,
+            includeSystemMessages: true,
+        });
+        const plan = buildPlan(historyMessages, targetUserMessageId);
+        if (!plan) {
+            throw new Error(`stale or inconsistent resume target: ${targetUserMessageId}`);
+        }
+        const staleSessions = Array.from(sessions.values());
+        const connectEvent = staleSessions.length > 0 ? "session_replaced" : "connected";
+        candidate = plan.resumeSessionAtUuid
+            ? await createSession({
+                cwd,
+                resume: command.session_id,
+                resumeSessionAt: plan.resumeSessionAtUuid,
+                resumeDropsTurn: plan.resumeDropsTurnId,
+                forkSession: true,
+                launchSettings: command.launch_settings,
+                connectEvent,
+                requestId,
+                deferConnect: true,
+                resumeUpdates: plan.resumeUpdates,
+                sessionsToCloseAfterConnect: staleSessions,
+            })
+            : await createSession({
+                cwd,
+                launchSettings: command.launch_settings,
+                connectEvent,
+                requestId,
+                deferConnect: true,
+                sessionsToCloseAfterConnect: staleSessions,
+            });
+        await awaitSessionInitialization(candidate);
+        commitDeferredSession(candidate);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (candidate) {
+            detachSessionForClose(candidate);
+            await closeSessionWithLogging(candidate, {
+                reason: "resume_at_candidate_rejected",
+                requestId,
+            });
+        }
+        const userMessage = message.startsWith("Resume rejected by --resume-drops-turn:")
+            ? "The session changed while you were selecting a message, so Claude Code refused to discard the newer turn. Reopen Resume and try again."
+            : `Failed to fork before selected message: ${message}`;
+        emitSessionResumeFailed(command.session_id, requestId, userMessage);
+    }
+}
 async function initialize(command, requestId, sdkVersionError) {
     if (sdkVersionError) {
         bridgeLogger.error({
@@ -129,7 +202,9 @@ async function resume(command, requestId) {
             ...(resumeUpdates.length > 0 ? { resumeUpdates } : {}),
             connectEvent: hadActiveSession ? "session_replaced" : "connected",
             requestId,
-            ...(hadActiveSession ? { sessionsToCloseAfterConnect: staleSessions } : {}),
+            ...(hadActiveSession
+                ? { sessionsToCloseAfterConnect: staleSessions }
+                : {}),
         });
     }
     catch (error) {

package/agent-sdk/dist/bridge/command_scheduler.js

@@ -2,6 +2,7 @@ const LIFECYCLE_COMMANDS = new Set([
     "initialize",
     "create_session",
     "resume_session",
+    "resume_session_at",
     "new_session",
     "rewind",
     "shutdown",
@@ -89,7 +90,9 @@ export class BridgeCommandScheduler {
         if (this.lifecycleTail) {
             dependencies.add(this.lifecycleTail);
         }
-        const operation = dependencies.size === 0 ? this.start(task) : Promise.all(dependencies).then(task);
+        const operation = dependencies.size === 0
+            ? this.start(task)
+            : Promise.all(dependencies).then(task);
         const tail = settle(operation);
         this.lifecycleTail = tail;
         void tail.then(() => {
@@ -108,7 +111,9 @@ export class BridgeCommandScheduler {
         if (previousSessionTask) {
             dependencies.push(previousSessionTask);
         }
-        const operation = dependencies.length === 0 ? this.start(task) : Promise.all(dependencies).then(task);
+        const operation = dependencies.length === 0
+            ? this.start(task)
+            : Promise.all(dependencies).then(task);
         const tail = settle(operation);
         this.sessionTails.set(sessionId, tail);
         void tail.then(() => {

package/agent-sdk/dist/bridge/command_session_control.js

@@ -10,7 +10,11 @@ export async function handleSessionControlCommand(command, requestId, deps) {
             handlePrompt(command, requestId, deps);
             return;
         case "cancel_turn":
-            await dispatchCancelTurnCommand(command, { requestId, sessionById, slashError });
+            await dispatchCancelTurnCommand(command, {
+                requestId,
+                sessionById,
+                slashError,
+            });
             return;
         case "set_model":
             await setModel(command, requestId);

package/agent-sdk/dist/bridge/command_session_data.js

@@ -1,6 +1,7 @@
-import { getSessionMessages, renameSession, } from "@anthropic-ai/claude-agent-sdk";
+import { getSessionMessages, listSessions, renameSession, } from "@anthropic-ai/claude-agent-sdk";
+import { asRecordOrNull } from "./shared.js";
 import { mapSdkAccountInfo } from "./account_metadata.js";
-import { emitSessionsList, setSessionListingDir, slashError, writeEvent, } from "./events.js";
+import { currentSessionListOptions, emitSessionsList, setSessionListingDir, slashError, writeEvent, } from "./events.js";
 import { bridgeLogger, LOG_TARGETS } from "./logger.js";
 import { refreshCurrentModel, sessionById, } from "./session_lifecycle.js";
 export async function handleSessionDataCommand(command, requestId, deps) {
@@ -17,6 +18,9 @@ export async function handleSessionDataCommand(command, requestId, deps) {
         case "get_context_usage":
             await getContextUsage(command, requestId);
             return;
+        case "get_usage":
+            await getUsage(command, requestId);
+            return;
         case "get_rewind_targets":
             await getRewindTargets(command, requestId, deps);
             return;
@@ -124,14 +128,18 @@ async function getContextUsage(command, requestId) {
                 normalized_percentage: normalizedPercentage,
                 total_tokens: typeof usage.totalTokens === "number" ? usage.totalTokens : undefined,
                 max_tokens: typeof usage.maxTokens === "number" ? usage.maxTokens : undefined,
-                raw_max_tokens: typeof usage.rawMaxTokens === "number" ? usage.rawMaxTokens : undefined,
+                raw_max_tokens: typeof usage.rawMaxTokens === "number"
+                    ? usage.rawMaxTokens
+                    : undefined,
                 model: typeof usage.model === "string" ? usage.model : undefined,
             },
         });
         writeEvent({
             event: "context_usage",
             session_id: session.sessionId,
-            ...(normalizedPercentage !== undefined ? { percentage: normalizedPercentage } : {}),
+            ...(normalizedPercentage !== undefined
+                ? { percentage: normalizedPercentage }
+                : {}),
         }, requestId);
     }
     catch (error) {
@@ -151,14 +159,216 @@ async function getContextUsage(command, requestId) {
         }, requestId);
     }
 }
-async function getRewindTargets(command, requestId, deps) {
+function finiteNumber(record, key) {
+    const value = record?.[key];
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function structuredUsageWindow(value) {
+    const record = asRecordOrNull(value);
+    const utilization = finiteNumber(record, "utilization");
+    if (utilization === undefined) {
+        return undefined;
+    }
+    const resetsAt = typeof record?.resets_at === "string" ? record.resets_at.trim() : "";
+    return {
+        utilization: Math.max(0, Math.min(100, utilization)),
+        ...(resetsAt ? { resets_at: resetsAt } : {}),
+    };
+}
+function structuredModelUsageWindows(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((entry) => {
+        const record = asRecordOrNull(entry);
+        const displayName = typeof record?.display_name === "string"
+            ? record.display_name.trim()
+            : "";
+        const window = structuredUsageWindow(record);
+        return displayName && window
+            ? [{ display_name: displayName, ...window }]
+            : [];
+    });
+}
+function structuredExtraUsage(value) {
+    const record = asRecordOrNull(value);
+    if (!record || record.is_enabled === false) {
+        return undefined;
+    }
+    const monthlyLimit = finiteNumber(record, "monthly_limit");
+    const usedCredits = finiteNumber(record, "used_credits");
+    const utilization = finiteNumber(record, "utilization");
+    const normalized = {
+        ...(monthlyLimit !== undefined ? { monthly_limit: monthlyLimit } : {}),
+        ...(usedCredits !== undefined ? { used_credits: usedCredits } : {}),
+        ...(utilization !== undefined
+            ? { utilization: Math.max(0, Math.min(100, utilization)) }
+            : {}),
+        ...(typeof record.currency === "string" && record.currency.trim()
+            ? { currency: record.currency.trim() }
+            : {}),
+    };
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+function structuredSessionUsage(value) {
+    const record = asRecordOrNull(value);
+    if (!record) {
+        return undefined;
+    }
+    const modelUsage = asRecordOrNull(record.model_usage);
+    const normalized = {
+        ...(finiteNumber(record, "total_cost_usd") !== undefined
+            ? { total_cost_usd: finiteNumber(record, "total_cost_usd") }
+            : {}),
+        ...(finiteNumber(record, "total_api_duration_ms") !== undefined
+            ? { total_api_duration_ms: finiteNumber(record, "total_api_duration_ms") }
+            : {}),
+        ...(finiteNumber(record, "total_duration_ms") !== undefined
+            ? { total_duration_ms: finiteNumber(record, "total_duration_ms") }
+            : {}),
+        ...(finiteNumber(record, "total_lines_added") !== undefined
+            ? { total_lines_added: finiteNumber(record, "total_lines_added") }
+            : {}),
+        ...(finiteNumber(record, "total_lines_removed") !== undefined
+            ? { total_lines_removed: finiteNumber(record, "total_lines_removed") }
+            : {}),
+        ...(modelUsage ? { model_count: Object.keys(modelUsage).length } : {}),
+    };
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+function structuredActivityWindow(value) {
+    const record = asRecordOrNull(value);
+    const requestCount = finiteNumber(record, "request_count");
+    const sessionCount = finiteNumber(record, "session_count");
+    if (requestCount === undefined ||
+        sessionCount === undefined ||
+        requestCount < 0 ||
+        sessionCount < 0) {
+        return undefined;
+    }
+    return {
+        request_count: Math.trunc(requestCount),
+        session_count: Math.trunc(sessionCount),
+        behaviors: structuredBehaviorAttributions(record?.behaviors),
+        agents: structuredNamedAttributions(record?.agents),
+        skills: structuredNamedAttributions(record?.skills),
+        plugins: structuredNamedAttributions(record?.plugins),
+        mcp_servers: structuredNamedAttributions(record?.mcp_servers),
+    };
+}
+function structuredBehaviorAttributions(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((entry) => {
+        const record = asRecordOrNull(entry);
+        const key = typeof record?.key === "string" ? record.key.trim() : "";
+        const pct = finiteNumber(record, "pct");
+        const count = finiteNumber(record, "count");
+        if (!key || pct === undefined || count === undefined || count < 0) {
+            return [];
+        }
+        return [
+            { key, pct: Math.max(0, Math.min(100, pct)), count: Math.trunc(count) },
+        ];
+    });
+}
+function structuredNamedAttributions(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((entry) => {
+        const record = asRecordOrNull(entry);
+        const name = typeof record?.name === "string" ? record.name.trim() : "";
+        const pct = finiteNumber(record, "pct");
+        return name && pct !== undefined
+            ? [{ name, pct: Math.max(0, Math.min(100, pct)) }]
+            : [];
+    });
+}
+export function normalizeStructuredUsage(value) {
+    const root = asRecordOrNull(value);
+    const limits = asRecordOrNull(root?.rate_limits);
+    const behaviors = asRecordOrNull(root?.behaviors);
+    const fiveHour = structuredUsageWindow(limits?.five_hour);
+    const sevenDay = structuredUsageWindow(limits?.seven_day);
+    const sevenDayOauthApps = structuredUsageWindow(limits?.seven_day_oauth_apps);
+    const sevenDayOpus = structuredUsageWindow(limits?.seven_day_opus);
+    const sevenDaySonnet = structuredUsageWindow(limits?.seven_day_sonnet);
+    const modelScoped = structuredModelUsageWindows(limits?.model_scoped);
+    const extraUsage = structuredExtraUsage(limits?.extra_usage);
+    const session = structuredSessionUsage(root?.session);
+    const activityDay = structuredActivityWindow(behaviors?.day);
+    const activityWeek = structuredActivityWindow(behaviors?.week);
+    return {
+        ...(typeof root?.subscription_type === "string" &&
+            root.subscription_type.trim()
+            ? { subscription_type: root.subscription_type.trim() }
+            : {}),
+        ...(typeof root?.rate_limits_available === "boolean"
+            ? { rate_limits_available: root.rate_limits_available }
+            : {}),
+        ...(fiveHour ? { five_hour: fiveHour } : {}),
+        ...(sevenDay ? { seven_day: sevenDay } : {}),
+        ...(sevenDayOauthApps ? { seven_day_oauth_apps: sevenDayOauthApps } : {}),
+        ...(sevenDayOpus ? { seven_day_opus: sevenDayOpus } : {}),
+        ...(sevenDaySonnet ? { seven_day_sonnet: sevenDaySonnet } : {}),
+        ...(modelScoped.length > 0 ? { model_scoped: modelScoped } : {}),
+        ...(extraUsage ? { extra_usage: extraUsage } : {}),
+        ...(session ? { session } : {}),
+        ...(activityDay ? { activity_day: activityDay } : {}),
+        ...(activityWeek ? { activity_week: activityWeek } : {}),
+    };
+}
+async function getUsage(command, requestId) {
     const session = requireSession(command.session_id, requestId);
     if (!session) {
         return;
     }
     try {
+        const usageMethod = session.query.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET;
+        if (typeof usageMethod !== "function") {
+            throw new Error("structured SDK usage is unavailable in this runtime");
+        }
+        const snapshot = normalizeStructuredUsage(await usageMethod.call(session.query));
+        if (Object.keys(snapshot).length === 0) {
+            throw new Error("structured SDK usage returned an incompatible empty payload");
+        }
+        writeEvent({ event: "usage_snapshot", session_id: session.sessionId, snapshot }, requestId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "structured_usage_failed",
+            message: "experimental structured SDK usage failed",
+            outcome: "fallback_required",
+            ...(requestId ? { requestId } : {}),
+            sessionId: session.sessionId,
+            fields: { error_message: message },
+        });
+        writeEvent({
+            event: "usage_snapshot",
+            session_id: session.sessionId,
+            error: message,
+        }, requestId);
+    }
+}
+async function getRewindTargets(command, requestId, deps) {
+    const activeSession = sessionById(command.session_id);
+    try {
+        let cwd = activeSession?.cwd;
+        if (!cwd) {
+            const listedSession = (await listSessions(currentSessionListOptions())).find((entry) => entry.sessionId === command.session_id);
+            if (!listedSession) {
+                throw new Error(`unknown session: ${command.session_id}`);
+            }
+            cwd = listedSession.cwd?.trim() || currentSessionListOptions().dir;
+        }
         const historyMessages = await getSessionMessages(command.session_id, {
-            dir: session.cwd,
+            ...(cwd ? { dir: cwd } : {}),
             includeSystemMessages: true,
         });
         const targets = deps.rewindTargetsFromSessionMessages(historyMessages);
@@ -168,7 +378,7 @@ async function getRewindTargets(command, requestId, deps) {
             message: "rewind targets loaded from session history",
             outcome: "success",
             ...(requestId ? { requestId } : {}),
-            sessionId: session.sessionId,
+            sessionId: command.session_id,
             fields: {
                 history_message_count: historyMessages.length,
                 target_count: targets.length,
@@ -176,7 +386,7 @@ async function getRewindTargets(command, requestId, deps) {
         });
         writeEvent({
             event: "rewind_targets",
-            session_id: session.sessionId,
+            session_id: command.session_id,
             targets,
         }, requestId);
     }
@@ -188,10 +398,15 @@ async function getRewindTargets(command, requestId, deps) {
             message: "failed to load rewind targets",
             outcome: "failure",
             ...(requestId ? { requestId } : {}),
-            sessionId: session.sessionId,
+            sessionId: command.session_id,
             fields: { error_message: message },
         });
-        slashError(command.session_id, `failed to load rewind targets: ${message}`, requestId);
+        writeEvent({
+            event: "rewind_targets",
+            session_id: command.session_id,
+            targets: [],
+            error: `failed to load rewind targets: ${message}`,
+        }, requestId);
     }
 }
 function requireSession(sessionId, requestId) {

package/agent-sdk/dist/bridge/commands.js

@@ -10,11 +10,27 @@ const MODE_NAMES = {
 };
 const MODE_OPTIONS = [
     { id: "default", name: "Default", description: "Standard permission flow" },
-    { id: "auto", name: "Auto", description: "Model-classified permission approvals" },
-    { id: "acceptEdits", name: "Accept Edits", description: "Auto-approve edit operations" },
+    {
+        id: "auto",
+        name: "Auto",
+        description: "Model-classified permission approvals",
+    },
+    {
+        id: "acceptEdits",
+        name: "Accept Edits",
+        description: "Auto-approve edit operations",
+    },
     { id: "plan", name: "Plan", description: "No tool execution" },
-    { id: "dontAsk", name: "Don't Ask", description: "Reject non-approved tools" },
-    { id: "bypassPermissions", name: "Bypass Permissions", description: "Auto-approve all tools" },
+    {
+        id: "dontAsk",
+        name: "Don't Ask",
+        description: "Reject non-approved tools",
+    },
+    {
+        id: "bypassPermissions",
+        name: "Bypass Permissions",
+        description: "Auto-approve all tools",
+    },
 ];
 const BASE_SUPPORTED_MODE_IDS = [
     "default",
@@ -27,10 +43,10 @@ function currentModelSupportsAutoMode(session) {
     return currentModel.supports_auto_mode === true;
 }
 function modeInfoForId(mode) {
-    return MODE_OPTIONS.find((entry) => entry.id === mode) ?? {
+    return (MODE_OPTIONS.find((entry) => entry.id === mode) ?? {
         id: mode,
         name: MODE_NAMES[mode],
-    };
+    });
 }
 function uniqueModeIds(modeIds) {
     const unique = new Set(modeIds);
@@ -53,13 +69,17 @@ function computedSupportedModeIds(session) {
 }
 export function refreshSupportedModesForSession(session) {
     const computed = computedSupportedModeIds(session);
-    session.supportedModeIds = computed.filter((mode) => mode === session.mode || !session.runtimeUnavailableModeIds.includes(mode));
+    session.supportedModeIds = computed.filter((mode) => mode === session.mode ||
+        !session.runtimeUnavailableModeIds.includes(mode));
 }
 export function markModeUnavailableForSession(session, mode) {
     if (session.runtimeUnavailableModeIds.includes(mode)) {
         return false;
     }
-    session.runtimeUnavailableModeIds = [...session.runtimeUnavailableModeIds, mode];
+    session.runtimeUnavailableModeIds = [
+        ...session.runtimeUnavailableModeIds,
+        mode,
+    ];
     refreshSupportedModesForSession(session);
     return true;
 }
@@ -225,6 +245,13 @@ export function parseCommandEnvelope(line) {
                     launch_settings: optionalLaunchSettings(raw, "launch_settings", "resume_session"),
                     metadata: optionalMetadata(raw, "metadata"),
                 };
+            case "resume_session_at":
+                return {
+                    command: "resume_session_at",
+                    session_id: expectString(raw, "session_id", "resume_session_at"),
+                    target_user_message_id: expectString(raw, "target_user_message_id", "resume_session_at"),
+                    launch_settings: optionalLaunchSettings(raw, "launch_settings", "resume_session_at"),
+                };
             case "new_session":
                 return {
                     command: "new_session",
@@ -294,6 +321,11 @@ export function parseCommandEnvelope(line) {
                     command: "get_context_usage",
                     session_id: expectString(raw, "session_id", "get_context_usage"),
                 };
+            case "get_usage":
+                return {
+                    command: "get_usage",
+                    session_id: expectString(raw, "session_id", "get_usage"),
+                };
             case "get_rewind_targets":
                 return {
                     command: "get_rewind_targets",
@@ -367,9 +399,12 @@ export function parseCommandEnvelope(line) {
                     ? {
                         outcome: "answered",
                         selected_option_ids: expectStringArray(outcome, "selected_option_ids", "question_response.outcome"),
-                        ...(outcome.annotation === undefined || outcome.annotation === null
+                        ...(outcome.annotation === undefined ||
+                            outcome.annotation === null
                             ? {}
-                            : { annotation: parseQuestionAnnotation(outcome.annotation) }),
+                            : {
+                                annotation: parseQuestionAnnotation(outcome.annotation),
+                            }),
                     }
                     : { outcome: "cancelled" };
                 return {
@@ -405,7 +440,9 @@ export function parseCommandEnvelope(line) {
                     elicitation_request_id: expectString(raw, "elicitation_request_id", "elicitation_response"),
                     action: expectElicitationAction(raw, "action", "elicitation_response"),
                     ...(optionalJsonObject(raw, "content", "elicitation_response")
-                        ? { content: optionalJsonObject(raw, "content", "elicitation_response") }
+                        ? {
+                            content: optionalJsonObject(raw, "content", "elicitation_response"),
+                        }
                         : {}),
                 };
             case "mcp_authenticate":