claude-code-rust 0.5.0 → 0.6.0

package/README.md

@@ -2,9 +2,11 @@
 
 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)
 [![CI](https://github.com/srothgan/claude-code-rust/actions/workflows/ci.yml/badge.svg)](https://github.com/srothgan/claude-code-rust/actions/workflows/ci.yml)
 [![License: AGPL-3.0-or-later](https://img.shields.io/badge/License-AGPL--3.0--or--later-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
-[![MSRV](https://img.shields.io/badge/MSRV-1.88.0-blue.svg)](https://blog.rust-lang.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-%3E%3D18-green.svg)](https://nodejs.org/)
 
 ## About
 
@@ -56,8 +58,6 @@ Three-layer design:
 
 ## Known Limitations
 
-- Token usage and cost tracking can be partial when upstream runtime events do not include full usage data.
-- Session resume via `--resume` depends on runtime support and account/session availability.
 - `/login` and `/logout` are intentionally not offered in command discovery for this release.
 
 ## Status

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

@@ -81,10 +81,10 @@ export function parseCommandEnvelope(line) {
                     resume: optionalString(raw, "resume", "create_session"),
                     metadata: optionalMetadata(raw, "metadata"),
                 };
-            case "load_session":
+            case "resume_session":
                 return {
-                    command: "load_session",
-                    session_id: expectString(raw, "session_id", "load_session"),
+                    command: "resume_session",
+                    session_id: expectString(raw, "session_id", "resume_session"),
                     metadata: optionalMetadata(raw, "metadata"),
                 };
             case "new_session":

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

@@ -1,224 +1,22 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { TOOL_RESULT_TYPES, buildToolResultFields, createToolCall, isToolUseBlockType } from "./tooling.js";
 import { asRecordOrNull } from "./shared.js";
+import { TOOL_RESULT_TYPES, buildToolResultFields, createToolCall, isToolUseBlockType } from "./tooling.js";
 import { buildUsageUpdateFromResult } from "./usage.js";
-function normalizeUserPromptText(raw) {
-    let text = raw.replace(/<context[\s\S]*/gi, " ");
-    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
-    text = text.replace(/\s+/g, " ").trim();
-    return text;
-}
-function truncateTextByChars(text, maxChars) {
-    const chars = Array.from(text);
-    if (chars.length <= maxChars) {
-        return text;
-    }
-    return chars.slice(0, maxChars).join("");
-}
-function firstUserMessageTitleFromRecord(record) {
-    if (record.type !== "user") {
-        return undefined;
-    }
-    const message = asRecordOrNull(record.message);
-    if (!message || message.role !== "user" || !Array.isArray(message.content)) {
-        return undefined;
-    }
-    const parts = [];
-    for (const item of message.content) {
-        const block = asRecordOrNull(item);
-        if (!block || block.type !== "text" || typeof block.text !== "string") {
-            continue;
-        }
-        const cleaned = normalizeUserPromptText(block.text);
-        if (!cleaned) {
-            continue;
-        }
-        parts.push(cleaned);
-        const combined = parts.join(" ");
-        if (Array.from(combined).length >= 180) {
-            return truncateTextByChars(combined, 180);
-        }
-    }
-    if (parts.length === 0) {
+function nonEmptyTrimmed(value) {
+    if (typeof value !== "string") {
         return undefined;
     }
-    return truncateTextByChars(parts.join(" "), 180);
-}
-function extractSessionPreviewFromJsonl(filePath) {
-    let text;
-    try {
-        text = fs.readFileSync(filePath, "utf8");
-    }
-    catch {
-        return {};
-    }
-    let cwd;
-    let title;
-    const lines = text.split(/\r?\n/);
-    for (const rawLine of lines) {
-        const line = rawLine.trim();
-        if (line.length === 0) {
-            continue;
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        const record = asRecordOrNull(parsed);
-        if (!record) {
-            continue;
-        }
-        if (!cwd && typeof record.cwd === "string" && record.cwd.trim().length > 0) {
-            cwd = record.cwd;
-        }
-        if (!title) {
-            title = firstUserMessageTitleFromRecord(record);
-        }
-        if (cwd && title) {
-            break;
-        }
-    }
-    return {
-        ...(cwd ? { cwd } : {}),
-        ...(title ? { title } : {}),
-    };
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
 }
-export function listRecentPersistedSessions(limit = 8) {
-    const root = path.join(os.homedir(), ".claude", "projects");
-    if (!fs.existsSync(root)) {
-        return [];
-    }
+function messageCandidates(raw) {
     const candidates = [];
-    let projectDirs;
-    try {
-        projectDirs = fs.readdirSync(root, { withFileTypes: true }).filter((dirent) => dirent.isDirectory());
-    }
-    catch {
-        return [];
-    }
-    for (const dirent of projectDirs) {
-        const projectDir = path.join(root, dirent.name);
-        let sessionFiles;
-        try {
-            sessionFiles = fs
-                .readdirSync(projectDir, { withFileTypes: true })
-                .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"));
-        }
-        catch {
-            sessionFiles = [];
-        }
-        for (const sessionFile of sessionFiles) {
-            const sessionId = sessionFile.name.slice(0, -".jsonl".length);
-            if (!sessionId) {
-                continue;
-            }
-            let mtimeMs = 0;
-            try {
-                mtimeMs = fs.statSync(path.join(projectDir, sessionFile.name)).mtimeMs;
-            }
-            catch {
-                continue;
-            }
-            if (!Number.isFinite(mtimeMs) || mtimeMs <= 0) {
-                continue;
-            }
-            candidates.push({
-                session_id: sessionId,
-                cwd: "",
-                file_path: path.join(projectDir, sessionFile.name),
-                updated_at: new Date(mtimeMs).toISOString(),
-                sort_ms: mtimeMs,
-            });
-        }
-    }
-    candidates.sort((a, b) => b.sort_ms - a.sort_ms);
-    const deduped = [];
-    const seen = new Set();
-    for (const candidate of candidates) {
-        if (seen.has(candidate.session_id)) {
-            continue;
-        }
-        seen.add(candidate.session_id);
-        const preview = extractSessionPreviewFromJsonl(candidate.file_path);
-        const cwd = preview.cwd?.trim();
-        if (!cwd) {
-            continue;
-        }
-        deduped.push({
-            session_id: candidate.session_id,
-            cwd,
-            file_path: candidate.file_path,
-            ...(preview.title ? { title: preview.title } : {}),
-            ...(candidate.updated_at ? { updated_at: candidate.updated_at } : {}),
-            sort_ms: candidate.sort_ms,
-        });
-        if (deduped.length >= limit) {
-            break;
-        }
-    }
-    return deduped;
-}
-export function resolvePersistedSessionEntry(sessionId) {
-    if (sessionId.trim().length === 0 ||
-        sessionId.includes("/") ||
-        sessionId.includes("\\") ||
-        sessionId.includes("..")) {
-        return null;
-    }
-    const root = path.join(os.homedir(), ".claude", "projects");
-    if (!fs.existsSync(root)) {
-        return null;
-    }
-    let projectDirs;
-    try {
-        projectDirs = fs.readdirSync(root, { withFileTypes: true }).filter((dirent) => dirent.isDirectory());
-    }
-    catch {
-        return null;
-    }
-    let best = null;
-    for (const dirent of projectDirs) {
-        const filePath = path.join(root, dirent.name, `${sessionId}.jsonl`);
-        if (!fs.existsSync(filePath)) {
-            continue;
-        }
-        const preview = extractSessionPreviewFromJsonl(filePath);
-        const cwd = preview.cwd?.trim();
-        if (!cwd) {
-            continue;
-        }
-        let mtimeMs = 0;
-        try {
-            mtimeMs = fs.statSync(filePath).mtimeMs;
-        }
-        catch {
-            mtimeMs = 0;
-        }
-        if (!best || mtimeMs >= best.sort_ms) {
-            best = {
-                session_id: sessionId,
-                cwd,
-                file_path: filePath,
-                sort_ms: mtimeMs,
-            };
-        }
-    }
-    return best;
-}
-function persistedMessageCandidates(record) {
-    const candidates = [];
-    const topLevel = asRecordOrNull(record.message);
+    const topLevel = asRecordOrNull(raw);
     if (topLevel) {
         candidates.push(topLevel);
-    }
-    const nested = asRecordOrNull(asRecordOrNull(asRecordOrNull(record.data)?.message)?.message);
-    if (nested) {
-        candidates.push(nested);
+        const nested = asRecordOrNull(topLevel.message);
+        if (nested) {
+            candidates.push(nested);
+        }
     }
     return candidates;
 }
@@ -278,39 +76,49 @@ function pushResumeUsageUpdate(updates, message, emittedUsageMessageIds) {
         emittedUsageMessageIds.add(messageId);
     }
 }
-export function extractSessionHistoryUpdatesFromJsonl(filePath) {
-    let text;
-    try {
-        text = fs.readFileSync(filePath, "utf8");
-    }
-    catch {
-        return [];
+function summaryFromSession(info) {
+    return (nonEmptyTrimmed(info.summary) ??
+        nonEmptyTrimmed(info.customTitle) ??
+        nonEmptyTrimmed(info.firstPrompt) ??
+        info.sessionId);
+}
+export function mapSdkSessionInfo(info) {
+    return {
+        session_id: info.sessionId,
+        summary: summaryFromSession(info),
+        last_modified_ms: info.lastModified,
+        file_size_bytes: info.fileSize,
+        ...(nonEmptyTrimmed(info.cwd) ? { cwd: info.cwd?.trim() } : {}),
+        ...(nonEmptyTrimmed(info.gitBranch) ? { git_branch: info.gitBranch?.trim() } : {}),
+        ...(nonEmptyTrimmed(info.customTitle) ? { custom_title: info.customTitle?.trim() } : {}),
+        ...(nonEmptyTrimmed(info.firstPrompt) ? { first_prompt: info.firstPrompt?.trim() } : {}),
+    };
+}
+export function mapSdkSessions(infos, limit = 50) {
+    const sorted = [...infos].sort((a, b) => b.lastModified - a.lastModified);
+    const entries = [];
+    const seen = new Set();
+    for (const info of sorted) {
+        if (!info.sessionId || seen.has(info.sessionId)) {
+            continue;
+        }
+        seen.add(info.sessionId);
+        entries.push(mapSdkSessionInfo(info));
+        if (entries.length >= limit) {
+            break;
+        }
     }
+    return entries;
+}
+export function mapSessionMessagesToUpdates(messages) {
     const updates = [];
     const toolCalls = new Map();
     const emittedUsageMessageIds = new Set();
-    const lines = text.split(/\r?\n/);
-    for (const rawLine of lines) {
-        const line = rawLine.trim();
-        if (line.length === 0) {
-            continue;
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        const record = asRecordOrNull(parsed);
-        if (!record) {
-            continue;
-        }
-        for (const message of persistedMessageCandidates(record)) {
-            const role = message.role;
-            if (role !== "user" && role !== "assistant") {
-                continue;
-            }
+    for (const entry of messages) {
+        const fallbackRole = entry.type === "assistant" ? "assistant" : "user";
+        for (const message of messageCandidates(entry.message)) {
+            const roleCandidate = message.role;
+            const role = roleCandidate === "assistant" || roleCandidate === "user" ? roleCandidate : fallbackRole;
             const content = Array.isArray(message.content) ? message.content : [];
             for (const item of content) {
                 const block = asRecordOrNull(item);

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

@@ -34,6 +34,7 @@ export function normalizeToolKind(name) {
         case "TodoWrite":
             return "other";
         case "Task":
+        case "Agent":
             return "think";
         case "ExitPlanMode":
             return "switch_mode";
@@ -169,16 +170,37 @@ function persistedOutputFirstLine(text) {
     }
     return null;
 }
-export function normalizeToolResultText(value) {
+/**
+ * Replace verbose SDK-internal tool rejection messages with short user-facing text.
+ * The SDK sends these as tool result content meant for Claude, not for the user.
+ */
+const USER_REJECTED_TOOL_USE_EXACT = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+const USER_REJECTED_TOOL_USE_PREFIX = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). To tell you how to proceed, the user said:";
+const PERMISSION_DENIED_TOOL_USE_EXACT = "Permission for this tool use was denied. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). Try a different approach or report the limitation to complete your task.";
+const PERMISSION_DENIED_TOOL_USE_PREFIX = "Permission for this tool use was denied. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). The user said:";
+function sanitizeSdkRejectionText(text) {
+    const normalized = text.trim();
+    if (normalized === USER_REJECTED_TOOL_USE_EXACT ||
+        normalized.startsWith(USER_REJECTED_TOOL_USE_PREFIX)) {
+        return "Cancelled by user.";
+    }
+    if (normalized === PERMISSION_DENIED_TOOL_USE_EXACT ||
+        normalized.startsWith(PERMISSION_DENIED_TOOL_USE_PREFIX)) {
+        return "Permission denied.";
+    }
+    return text;
+}
+export function normalizeToolResultText(value, isError = false) {
     const text = extractText(value);
     if (!text) {
         return "";
     }
     const persistedLine = persistedOutputFirstLine(text);
-    if (persistedLine) {
-        return persistedLine;
+    const normalized = persistedLine || text;
+    if (!isError) {
+        return normalized;
     }
-    return text;
+    return sanitizeSdkRejectionText(normalized);
 }
 function resolveToolName(toolCall) {
     const meta = asRecordOrNull(toolCall?.meta);
@@ -242,7 +264,7 @@ function writeDiffFromResult(rawContent) {
     return [];
 }
 export function buildToolResultFields(isError, rawContent, base) {
-    const rawOutput = normalizeToolResultText(rawContent);
+    const rawOutput = normalizeToolResultText(rawContent, isError);
     const toolName = resolveToolName(base);
     const fields = {
         status: isError ? "failed" : "completed",

package/agent-sdk/dist/bridge.js

@@ -4,7 +4,7 @@ import fs from "node:fs";
 import { createRequire } from "node:module";
 import readline from "node:readline";
 import { pathToFileURL } from "node:url";
-import { query, } from "@anthropic-ai/claude-agent-sdk";
+import { getSessionMessages, listSessions, query, } from "@anthropic-ai/claude-agent-sdk";
 import { parseCommandEnvelope, toPermissionMode, buildModeState } from "./bridge/commands.js";
 import { asRecordOrNull } from "./bridge/shared.js";
 import { looksLikeAuthRequired } from "./bridge/auth.js";
@@ -12,10 +12,11 @@ import { TOOL_RESULT_TYPES, buildToolResultFields, createToolCall, normalizeTool
 import { CACHE_SPLIT_POLICY, previewKilobyteLabel } from "./bridge/cache_policy.js";
 import { buildUsageUpdateFromResult, buildUsageUpdateFromResultForSession } from "./bridge/usage.js";
 import { formatPermissionUpdates, permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./bridge/permissions.js";
-import { extractSessionHistoryUpdatesFromJsonl, listRecentPersistedSessions, resolvePersistedSessionEntry, } from "./bridge/history.js";
-export { CACHE_SPLIT_POLICY, buildToolResultFields, buildUsageUpdateFromResult, createToolCall, extractSessionHistoryUpdatesFromJsonl, looksLikeAuthRequired, normalizeToolKind, normalizeToolResultText, parseCommandEnvelope, permissionOptionsFromSuggestions, permissionResultFromOutcome, previewKilobyteLabel, unwrapToolUseResult, };
+import { mapSdkSessions, mapSessionMessagesToUpdates, } from "./bridge/history.js";
+export { CACHE_SPLIT_POLICY, buildToolResultFields, buildUsageUpdateFromResult, createToolCall, mapSessionMessagesToUpdates, mapSdkSessions, looksLikeAuthRequired, normalizeToolKind, normalizeToolResultText, parseCommandEnvelope, permissionOptionsFromSuggestions, permissionResultFromOutcome, previewKilobyteLabel, unwrapToolUseResult, };
 const sessions = new Map();
-const EXPECTED_AGENT_SDK_VERSION = "0.2.52";
+const EXPECTED_AGENT_SDK_VERSION = "0.2.63";
+const SESSION_LIST_LIMIT = 50;
 const require = createRequire(import.meta.url);
 const permissionDebugEnabled = process.env.CLAUDE_RS_SDK_PERMISSION_DEBUG === "1" || process.env.CLAUDE_RS_SDK_DEBUG === "1";
 export function resolveInstalledAgentSdkVersion() {
@@ -130,6 +131,7 @@ function emitConnectEvent(session) {
     const staleSessions = session.sessionsToCloseAfterConnect;
     session.sessionsToCloseAfterConnect = undefined;
     if (!staleSessions || staleSessions.length === 0) {
+        refreshSessionsList();
         return;
     }
     void (async () => {
@@ -142,8 +144,25 @@ function emitConnectEvent(session) {
             }
             await closeSession(stale);
         }
+        refreshSessionsList();
     })();
 }
+async function emitSessionsList(requestId) {
+    try {
+        const sdkSessions = await listSessions({ limit: SESSION_LIST_LIMIT });
+        writeEvent({ event: "sessions_listed", sessions: mapSdkSessions(sdkSessions, SESSION_LIST_LIMIT) }, requestId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[sdk warn] listSessions failed: ${message}`);
+        writeEvent({ event: "sessions_listed", sessions: [] }, requestId);
+    }
+}
+function refreshSessionsList() {
+    void emitSessionsList().catch(() => {
+        // Defensive no-op.
+    });
+}
 function textFromPrompt(command) {
     const chunks = command.chunks ?? [];
     return chunks
@@ -346,7 +365,7 @@ function handleTaskSystemMessage(session, subtype, msg) {
     if (!toolUseId) {
         return;
     }
-    const toolCall = ensureToolCallVisible(session, toolUseId, "Task", {});
+    const toolCall = ensureToolCallVisible(session, toolUseId, "Agent", {});
     if (toolCall.status === "pending") {
         toolCall.status = "in_progress";
         emitSessionUpdate(session.sessionId, {
@@ -568,11 +587,150 @@ function numberField(record, ...keys) {
     }
     return undefined;
 }
+export function parseFastModeState(value) {
+    if (value === "off" || value === "cooldown" || value === "on") {
+        return value;
+    }
+    return null;
+}
+export function parseRateLimitStatus(value) {
+    if (value === "allowed" || value === "allowed_warning" || value === "rejected") {
+        return value;
+    }
+    return null;
+}
+export function buildRateLimitUpdate(rateLimitInfo) {
+    const info = asRecordOrNull(rateLimitInfo);
+    if (!info) {
+        return null;
+    }
+    const status = parseRateLimitStatus(info.status);
+    if (!status) {
+        return null;
+    }
+    const update = {
+        type: "rate_limit_update",
+        status,
+    };
+    const resetsAt = numberField(info, "resetsAt");
+    if (resetsAt !== undefined) {
+        update.resets_at = resetsAt;
+    }
+    const utilization = numberField(info, "utilization");
+    if (utilization !== undefined) {
+        update.utilization = utilization;
+    }
+    if (typeof info.rateLimitType === "string" && info.rateLimitType.length > 0) {
+        update.rate_limit_type = info.rateLimitType;
+    }
+    const overageStatus = parseRateLimitStatus(info.overageStatus);
+    if (overageStatus) {
+        update.overage_status = overageStatus;
+    }
+    const overageResetsAt = numberField(info, "overageResetsAt");
+    if (overageResetsAt !== undefined) {
+        update.overage_resets_at = overageResetsAt;
+    }
+    if (typeof info.overageDisabledReason === "string" && info.overageDisabledReason.length > 0) {
+        update.overage_disabled_reason = info.overageDisabledReason;
+    }
+    if (typeof info.isUsingOverage === "boolean") {
+        update.is_using_overage = info.isUsingOverage;
+    }
+    const surpassedThreshold = numberField(info, "surpassedThreshold");
+    if (surpassedThreshold !== undefined) {
+        update.surpassed_threshold = surpassedThreshold;
+    }
+    return update;
+}
+function availableAgentsSignature(agents) {
+    return JSON.stringify(agents);
+}
+function normalizeAvailableAgentName(value) {
+    if (typeof value !== "string") {
+        return "";
+    }
+    return value.trim();
+}
+export function mapAvailableAgents(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const byName = new Map();
+    for (const entry of value) {
+        if (!entry || typeof entry !== "object") {
+            continue;
+        }
+        const record = entry;
+        const name = normalizeAvailableAgentName(record.name);
+        if (!name) {
+            continue;
+        }
+        const description = typeof record.description === "string" ? record.description : "";
+        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) {
+            existing.description = description;
+        }
+        if (!existing.model && model) {
+            existing.model = model;
+        }
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function mapAvailableAgentsFromNames(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const byName = new Map();
+    for (const entry of value) {
+        const name = normalizeAvailableAgentName(entry);
+        if (!name || byName.has(name)) {
+            continue;
+        }
+        byName.set(name, { name, description: "" });
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function emitAvailableAgentsIfChanged(session, agents) {
+    const signature = availableAgentsSignature(agents);
+    if (session.lastAvailableAgentsSignature === signature) {
+        return;
+    }
+    session.lastAvailableAgentsSignature = signature;
+    emitSessionUpdate(session.sessionId, { type: "available_agents_update", agents });
+}
+function refreshAvailableAgents(session) {
+    if (typeof session.query.supportedAgents !== "function") {
+        return;
+    }
+    void session.query
+        .supportedAgents()
+        .then((agents) => {
+        emitAvailableAgentsIfChanged(session, mapAvailableAgents(agents));
+    })
+        .catch(() => {
+        // Best-effort only.
+    });
+}
+function emitFastModeUpdateIfChanged(session, value) {
+    const next = parseFastModeState(value);
+    if (!next || next === session.fastModeState) {
+        return;
+    }
+    session.fastModeState = next;
+    emitSessionUpdate(session.sessionId, { type: "fast_mode_update", fast_mode_state: next });
+}
 function handleResultMessage(session, message) {
     const usageUpdate = buildUsageUpdateFromResultForSession(session, message);
     if (usageUpdate) {
         emitSessionUpdate(session.sessionId, usageUpdate);
     }
+    emitFastModeUpdateIfChanged(session, message.fast_mode_state);
     const subtype = typeof message.subtype === "string" ? message.subtype : "";
     if (subtype === "success") {
         session.lastAssistantError = undefined;
@@ -619,6 +777,7 @@ function handleSdkMessage(session, message) {
             if (incomingMode) {
                 session.mode = incomingMode;
             }
+            emitFastModeUpdateIfChanged(session, msg.fast_mode_state);
             if (!session.connected) {
                 emitConnectEvent(session);
             }
@@ -635,6 +794,7 @@ function handleSdkMessage(session, message) {
                         : {}),
                 });
                 session.resumeUpdates = undefined;
+                refreshSessionsList();
             }
             if (Array.isArray(msg.slash_commands)) {
                 const commands = msg.slash_commands
@@ -644,6 +804,9 @@ function handleSdkMessage(session, message) {
                     emitSessionUpdate(session.sessionId, { type: "available_commands_update", commands });
                 }
             }
+            if (session.lastAvailableAgentsSignature === undefined && Array.isArray(msg.agents)) {
+                emitAvailableAgentsIfChanged(session, mapAvailableAgentsFromNames(msg.agents));
+            }
             void session.query
                 .supportedCommands()
                 .then((commands) => {
@@ -657,6 +820,7 @@ function handleSdkMessage(session, message) {
                 .catch(() => {
                 // Best-effort only; slash commands from init were already emitted.
             });
+            refreshAvailableAgents(session);
             return;
         }
         if (subtype === "status") {
@@ -671,6 +835,7 @@ function handleSdkMessage(session, message) {
             else if (msg.status === null) {
                 emitSessionUpdate(session.sessionId, { type: "session_status_update", status: "idle" });
             }
+            emitFastModeUpdateIfChanged(session, msg.fast_mode_state);
             return;
         }
         if (subtype === "compact_boundary") {
@@ -689,6 +854,20 @@ function handleSdkMessage(session, message) {
             }
             return;
         }
+        if (subtype === "local_command_output") {
+            const content = typeof msg.content === "string" ? msg.content : "";
+            if (content.trim().length > 0) {
+                emitSessionUpdate(session.sessionId, {
+                    type: "agent_message_chunk",
+                    content: { type: "text", text: content },
+                });
+            }
+            return;
+        }
+        if (subtype === "elicitation_complete") {
+            // No-op: elicitation flow is auto-canceled in the onElicitation callback.
+            return;
+        }
         handleTaskSystemMessage(session, subtype, msg);
         return;
     }
@@ -729,6 +908,13 @@ function handleSdkMessage(session, message) {
         }
         return;
     }
+    if (type === "rate_limit_event") {
+        const update = buildRateLimitUpdate(msg.rate_limit_info);
+        if (update) {
+            emitSessionUpdate(session.sessionId, update);
+        }
+        return;
+    }
     if (type === "user") {
         handleUserToolResultBlocks(session, msg);
         const toolUseId = typeof msg.parent_tool_use_id === "string" ? msg.parent_tool_use_id : "";
@@ -751,6 +937,42 @@ function handleSdkMessage(session, message) {
 }
 const ASK_USER_QUESTION_TOOL_NAME = "AskUserQuestion";
 const QUESTION_CHOICE_KIND = "question_choice";
+const EXIT_PLAN_MODE_TOOL_NAME = "ExitPlanMode";
+const PLAN_APPROVE_KIND = "plan_approve";
+const PLAN_REJECT_KIND = "plan_reject";
+async function requestExitPlanModeApproval(session, toolUseId, inputData, baseToolCall) {
+    const options = [
+        {
+            option_id: "approve",
+            name: "Approve",
+            description: "Approve the plan and continue",
+            kind: PLAN_APPROVE_KIND,
+        },
+        {
+            option_id: "reject",
+            name: "Reject",
+            description: "Reject the plan",
+            kind: PLAN_REJECT_KIND,
+        },
+    ];
+    const request = {
+        tool_call: baseToolCall,
+        options,
+    };
+    const outcome = await new Promise((resolve) => {
+        session.pendingPermissions.set(toolUseId, {
+            onOutcome: resolve,
+            toolName: EXIT_PLAN_MODE_TOOL_NAME,
+            inputData,
+        });
+        writeEvent({ event: "permission_request", session_id: session.sessionId, request });
+    });
+    if (outcome.outcome !== "selected" || outcome.option_id === "reject") {
+        setToolCallStatus(session, toolUseId, "failed", "Plan rejected");
+        return { behavior: "deny", message: "Plan rejected", toolUseID: toolUseId };
+    }
+    return { behavior: "allow", updatedInput: inputData, toolUseID: toolUseId };
+}
 function parseAskUserQuestionPrompts(inputData) {
     const rawQuestions = Array.isArray(inputData.questions) ? inputData.questions : [];
     const prompts = [];
@@ -906,8 +1128,9 @@ async function createSession(params) {
     let session;
     const canUseTool = async (toolName, inputData, options) => {
         const toolUseId = options.toolUseID;
-        if (toolName === "ExitPlanMode") {
-            return { behavior: "allow", toolUseID: toolUseId };
+        if (toolName === EXIT_PLAN_MODE_TOOL_NAME) {
+            const existing = ensureToolCallVisible(session, toolUseId, toolName, inputData);
+            return await requestExitPlanModeApproval(session, toolUseId, inputData, existing);
         }
         logPermissionDebug(`request tool_use_id=${toolUseId} tool=${toolName} blocked_path=${options.blockedPath ?? "<none>"} ` +
             `decision_reason=${options.decisionReason ?? "<none>"} suggestions=${formatPermissionUpdates(options.suggestions)}`);
@@ -981,6 +1204,19 @@ async function createSession(params) {
                 resume: params.resume,
                 model: params.model,
                 canUseTool,
+                onElicitation: async (request) => {
+                    const requestMode = typeof request.mode === "string" ? request.mode : "unknown";
+                    const requestServer = typeof request.serverName === "string" && request.serverName.trim().length > 0
+                        ? request.serverName
+                        : "unknown";
+                    const requestMessage = typeof request.message === "string" && request.message.trim().length > 0
+                        ? request.message
+                        : "<no message>";
+                    console.error(`[sdk warn] elicitation unsupported without MCP settings UI; ` +
+                        `auto-canceling session_id=${session.sessionId} server=${requestServer} ` +
+                        `mode=${requestMode} message=${JSON.stringify(requestMessage)}`);
+                    return { action: "cancel" };
+                },
             },
         });
     }
@@ -995,6 +1231,7 @@ async function createSession(params) {
         cwd: params.cwd,
         model: params.model ?? "default",
         mode: startMode,
+        fastModeState: "off",
         yolo: params.yolo,
         query: queryHandle,
         input,
@@ -1022,6 +1259,7 @@ async function createSession(params) {
         if (!session.connected) {
             emitConnectEvent(session);
         }
+        emitFastModeUpdateIfChanged(session, result.fast_mode_state);
         const commands = Array.isArray(result.commands)
             ? result.commands.map((command) => ({
                 name: command.name,
@@ -1032,6 +1270,8 @@ async function createSession(params) {
         if (commands.length > 0) {
             emitSessionUpdate(session.sessionId, { type: "available_commands_update", commands });
         }
+        emitAvailableAgentsIfChanged(session, mapAvailableAgents(result.agents));
+        refreshAvailableAgents(session);
     })
         .catch((error) => {
         if (session.connected) {
@@ -1129,21 +1369,12 @@ async function handleCommand(command, requestId) {
                     capabilities: {
                         prompt_image: false,
                         prompt_embedded_context: true,
-                        load_session: true,
-                        supports_list_sessions: true,
-                        supports_resume: true,
+                        supports_session_listing: true,
+                        supports_resume_session: true,
                     },
                 },
             }, requestId);
-            writeEvent({
-                event: "sessions_listed",
-                sessions: listRecentPersistedSessions().map((entry) => ({
-                    session_id: entry.session_id,
-                    cwd: entry.cwd,
-                    ...(entry.title ? { title: entry.title } : {}),
-                    ...(entry.updated_at ? { updated_at: entry.updated_at } : {}),
-                })),
-            });
+            await emitSessionsList(requestId);
             return;
         case "create_session":
             await createSession({
@@ -1155,18 +1386,20 @@ async function handleCommand(command, requestId) {
                 requestId,
             });
             return;
-        case "load_session": {
-            const persisted = resolvePersistedSessionEntry(command.session_id);
-            if (!persisted) {
-                slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
-                return;
-            }
-            const resumeUpdates = extractSessionHistoryUpdatesFromJsonl(persisted.file_path);
-            const staleSessions = Array.from(sessions.values());
-            const hadActiveSession = staleSessions.length > 0;
+        case "resume_session": {
             try {
+                const sdkSessions = await listSessions();
+                const matched = sdkSessions.find((entry) => entry.sessionId === command.session_id);
+                if (!matched) {
+                    slashError(command.session_id, `unknown session: ${command.session_id}`, requestId);
+                    return;
+                }
+                const historyMessages = await getSessionMessages(command.session_id, matched.cwd ? { dir: matched.cwd } : undefined);
+                const resumeUpdates = mapSessionMessagesToUpdates(historyMessages);
+                const staleSessions = Array.from(sessions.values());
+                const hadActiveSession = staleSessions.length > 0;
                 await createSession({
-                    cwd: persisted.cwd,
+                    cwd: matched.cwd ?? process.cwd(),
                     yolo: false,
                     resume: command.session_id,
                     ...(resumeUpdates.length > 0 ? { resumeUpdates } : {}),

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

@@ -1,9 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { CACHE_SPLIT_POLICY, buildToolResultFields, buildUsageUpdateFromResult, createToolCall, extractSessionHistoryUpdatesFromJsonl, agentSdkVersionCompatibilityError, looksLikeAuthRequired, normalizeToolResultText, normalizeToolKind, parseCommandEnvelope, permissionOptionsFromSuggestions, permissionResultFromOutcome, previewKilobyteLabel, resolveInstalledAgentSdkVersion, unwrapToolUseResult, } from "./bridge.js";
+import { CACHE_SPLIT_POLICY, buildRateLimitUpdate, buildToolResultFields, buildUsageUpdateFromResult, createToolCall, mapAvailableAgents, mapSessionMessagesToUpdates, mapSdkSessions, agentSdkVersionCompatibilityError, looksLikeAuthRequired, normalizeToolResultText, parseFastModeState, parseRateLimitStatus, normalizeToolKind, parseCommandEnvelope, permissionOptionsFromSuggestions, permissionResultFromOutcome, previewKilobyteLabel, resolveInstalledAgentSdkVersion, unwrapToolUseResult, } from "./bridge.js";
 test("parseCommandEnvelope validates initialize command", () => {
     const parsed = parseCommandEnvelope(JSON.stringify({
         request_id: "req-1",
@@ -17,15 +14,15 @@ test("parseCommandEnvelope validates initialize command", () => {
     }
     assert.equal(parsed.command.cwd, "C:/work");
 });
-test("parseCommandEnvelope validates load_session command without cwd", () => {
+test("parseCommandEnvelope validates resume_session command without cwd", () => {
     const parsed = parseCommandEnvelope(JSON.stringify({
         request_id: "req-2",
-        command: "load_session",
+        command: "resume_session",
         session_id: "session-123",
     }));
     assert.equal(parsed.requestId, "req-2");
-    assert.equal(parsed.command.command, "load_session");
-    if (parsed.command.command !== "load_session") {
+    assert.equal(parsed.command.command, "resume_session");
+    if (parsed.command.command !== "resume_session") {
         throw new Error("unexpected command variant");
     }
     assert.equal(parsed.command.session_id, "session-123");
@@ -37,9 +34,76 @@ test("normalizeToolKind maps known tool names", () => {
     assert.equal(normalizeToolKind("Bash"), "execute");
     assert.equal(normalizeToolKind("Delete"), "delete");
     assert.equal(normalizeToolKind("Move"), "move");
+    assert.equal(normalizeToolKind("Task"), "think");
+    assert.equal(normalizeToolKind("Agent"), "think");
     assert.equal(normalizeToolKind("ExitPlanMode"), "switch_mode");
     assert.equal(normalizeToolKind("TodoWrite"), "other");
 });
+test("parseFastModeState accepts known values and rejects unknown values", () => {
+    assert.equal(parseFastModeState("off"), "off");
+    assert.equal(parseFastModeState("cooldown"), "cooldown");
+    assert.equal(parseFastModeState("on"), "on");
+    assert.equal(parseFastModeState("CD"), null);
+    assert.equal(parseFastModeState(undefined), null);
+});
+test("parseRateLimitStatus accepts known values and rejects unknown values", () => {
+    assert.equal(parseRateLimitStatus("allowed"), "allowed");
+    assert.equal(parseRateLimitStatus("allowed_warning"), "allowed_warning");
+    assert.equal(parseRateLimitStatus("rejected"), "rejected");
+    assert.equal(parseRateLimitStatus("warn"), null);
+    assert.equal(parseRateLimitStatus(undefined), null);
+});
+test("buildRateLimitUpdate maps SDK fields to wire shape", () => {
+    const update = buildRateLimitUpdate({
+        status: "allowed_warning",
+        resetsAt: 1_741_280_000,
+        utilization: 0.92,
+        rateLimitType: "five_hour",
+        overageStatus: "rejected",
+        overageResetsAt: 1_741_280_600,
+        overageDisabledReason: "out_of_credits",
+        isUsingOverage: false,
+        surpassedThreshold: 0.9,
+    });
+    assert.deepEqual(update, {
+        type: "rate_limit_update",
+        status: "allowed_warning",
+        resets_at: 1_741_280_000,
+        utilization: 0.92,
+        rate_limit_type: "five_hour",
+        overage_status: "rejected",
+        overage_resets_at: 1_741_280_600,
+        overage_disabled_reason: "out_of_credits",
+        is_using_overage: false,
+        surpassed_threshold: 0.9,
+    });
+});
+test("buildRateLimitUpdate rejects invalid payloads", () => {
+    assert.equal(buildRateLimitUpdate(null), null);
+    assert.equal(buildRateLimitUpdate({}), null);
+    assert.equal(buildRateLimitUpdate({ status: "warning" }), null);
+    assert.deepEqual(buildRateLimitUpdate({
+        status: "rejected",
+        overageStatus: "bad_status",
+    }), { type: "rate_limit_update", status: "rejected" });
+});
+test("mapAvailableAgents normalizes and deduplicates agents", () => {
+    const agents = mapAvailableAgents([
+        { name: "reviewer", description: "", model: "" },
+        { name: "reviewer", description: "Reviews code", model: "haiku" },
+        { name: "explore", description: "Explore codebase", model: "sonnet" },
+        { name: "  ", description: "ignored" },
+        {},
+    ]);
+    assert.deepEqual(agents, [
+        { name: "explore", description: "Explore codebase", model: "sonnet" },
+        { name: "reviewer", description: "Reviews code", model: "haiku" },
+    ]);
+});
+test("mapAvailableAgents rejects non-array payload", () => {
+    assert.deepEqual(mapAvailableAgents(null), []);
+    assert.deepEqual(mapAvailableAgents({}), []);
+});
 test("createToolCall builds edit diff content", () => {
     const toolCall = createToolCall("tc-1", "Edit", {
         file_path: "src/main.rs",
@@ -100,6 +164,26 @@ test("normalizeToolResultText collapses persisted-output payload to first meanin
 `);
     assert.equal(normalized, "Output too large (132.5KB). Full output saved to: C:\\tmp\\tool-results\\bbf63b9.txt");
 });
+test("normalizeToolResultText does not sanitize non-error output", () => {
+    const text = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+    assert.equal(normalizeToolResultText(text), text);
+});
+test("normalizeToolResultText sanitizes exact SDK rejection payloads for errors", () => {
+    const cancelledText = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+    assert.equal(normalizeToolResultText(cancelledText, true), "Cancelled by user.");
+    const deniedText = "Permission for this tool use was denied. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). Try a different approach or report the limitation to complete your task.";
+    assert.equal(normalizeToolResultText(deniedText, true), "Permission denied.");
+});
+test("normalizeToolResultText sanitizes SDK rejection prefixes with user follow-up", () => {
+    const cancelledWithUserMessage = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). To tell you how to proceed, the user said:\nPlease skip this";
+    assert.equal(normalizeToolResultText(cancelledWithUserMessage, true), "Cancelled by user.");
+    const deniedWithUserMessage = "Permission for this tool use was denied. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). The user said:\nNot now";
+    assert.equal(normalizeToolResultText(deniedWithUserMessage, true), "Permission denied.");
+});
+test("normalizeToolResultText does not sanitize substring matches in error output", () => {
+    const bashOutput = "grep output: doesn't want to proceed with this tool use";
+    assert.equal(normalizeToolResultText(bashOutput, true), bashOutput);
+});
 test("cache split policy defaults stay aligned with UI thresholds", () => {
     assert.equal(CACHE_SPLIT_POLICY.softLimitBytes, 1536);
     assert.equal(CACHE_SPLIT_POLICY.hardLimitBytes, 4096);
@@ -124,6 +208,13 @@ test("buildToolResultFields uses normalized persisted-output text", () => {
         },
     ]);
 });
+test("buildToolResultFields sanitizes SDK rejection text only for failed results", () => {
+    const sdkRejectionText = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+    const successFields = buildToolResultFields(false, sdkRejectionText);
+    assert.equal(successFields.raw_output, sdkRejectionText);
+    const errorFields = buildToolResultFields(true, sdkRejectionText);
+    assert.equal(errorFields.raw_output, "Cancelled by user.");
+});
 test("buildToolResultFields maps structured Write output to diff content", () => {
     const base = createToolCall("tc-w", "Write", {
         file_path: "src/main.ts",
@@ -334,122 +425,127 @@ test("looksLikeAuthRequired detects login hints", () => {
     assert.equal(looksLikeAuthRequired("normal tool output"), false);
 });
 test("agent sdk version compatibility check matches pinned version", () => {
-    assert.equal(resolveInstalledAgentSdkVersion(), "0.2.52");
+    assert.equal(resolveInstalledAgentSdkVersion(), "0.2.63");
     assert.equal(agentSdkVersionCompatibilityError(), undefined);
 });
-function withTempJsonl(lines, run) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-rs-resume-test-"));
-    const filePath = path.join(dir, "session.jsonl");
-    fs.writeFileSync(filePath, `${lines.map((line) => JSON.stringify(line)).join("\n")}\n`, "utf8");
-    try {
-        run(filePath);
-    }
-    finally {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-}
-test("extractSessionHistoryUpdatesFromJsonl parses nested progress message records", () => {
-    const lines = [
+test("mapSessionMessagesToUpdates maps message content blocks", () => {
+    const updates = mapSessionMessagesToUpdates([
         {
             type: "user",
+            uuid: "u1",
+            session_id: "s1",
+            parent_tool_use_id: null,
             message: {
                 role: "user",
                 content: [{ type: "text", text: "Top-level user prompt" }],
             },
         },
         {
-            type: "progress",
-            data: {
-                message: {
-                    type: "assistant",
-                    message: {
-                        id: "msg-nested-1",
-                        role: "assistant",
-                        content: [
-                            {
-                                type: "tool_use",
-                                id: "tool-nested-1",
-                                name: "Bash",
-                                input: { command: "echo hello" },
-                            },
-                        ],
-                        usage: {
-                            input_tokens: 11,
-                            output_tokens: 7,
-                            cache_read_input_tokens: 5,
-                            cache_creation_input_tokens: 3,
-                        },
-                    },
+            type: "assistant",
+            uuid: "a1",
+            session_id: "s1",
+            parent_tool_use_id: null,
+            message: {
+                id: "msg-1",
+                role: "assistant",
+                content: [
+                    { type: "tool_use", id: "tool-1", name: "Bash", input: { command: "echo hello" } },
+                    { type: "text", text: "Nested assistant final" },
+                ],
+                usage: {
+                    input_tokens: 11,
+                    output_tokens: 7,
+                    cache_read_input_tokens: 5,
+                    cache_creation_input_tokens: 3,
                 },
             },
         },
         {
-            type: "progress",
-            data: {
-                message: {
-                    type: "user",
-                    message: {
-                        role: "user",
-                        content: [
-                            {
-                                type: "tool_result",
-                                tool_use_id: "tool-nested-1",
-                                content: "ok",
-                                is_error: false,
-                            },
-                        ],
+            type: "user",
+            uuid: "u2",
+            session_id: "s1",
+            parent_tool_use_id: null,
+            message: {
+                role: "user",
+                content: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: "tool-1",
+                        content: "ok",
+                        is_error: false,
                     },
-                },
+                ],
             },
         },
+    ]);
+    const variantCounts = new Map();
+    for (const update of updates) {
+        variantCounts.set(update.type, (variantCounts.get(update.type) ?? 0) + 1);
+    }
+    assert.equal(variantCounts.get("user_message_chunk"), 1);
+    assert.equal(variantCounts.get("agent_message_chunk"), 1);
+    assert.equal(variantCounts.get("tool_call"), 1);
+    assert.equal(variantCounts.get("tool_call_update"), 1);
+    assert.equal(variantCounts.get("usage_update"), 1);
+    const usage = updates.find((update) => update.type === "usage_update");
+    assert.ok(usage && usage.type === "usage_update");
+    assert.deepEqual(usage.usage, {
+        input_tokens: 11,
+        output_tokens: 7,
+        cache_read_tokens: 5,
+        cache_write_tokens: 3,
+    });
+});
+test("mapSessionMessagesToUpdates ignores unsupported records", () => {
+    const updates = mapSessionMessagesToUpdates([
         {
-            type: "progress",
-            data: {
-                message: {
-                    type: "assistant",
-                    message: {
-                        id: "msg-nested-1",
-                        role: "assistant",
-                        content: [{ type: "text", text: "Nested assistant final" }],
-                        usage: {
-                            input_tokens: 11,
-                            output_tokens: 7,
-                            cache_read_input_tokens: 5,
-                            cache_creation_input_tokens: 3,
-                        },
-                    },
-                },
+            type: "user",
+            uuid: "u1",
+            session_id: "s1",
+            parent_tool_use_id: null,
+            message: {
+                role: "assistant",
+                content: [{ type: "thinking", thinking: "h" }],
             },
         },
-    ];
-    withTempJsonl(lines, (filePath) => {
-        const updates = extractSessionHistoryUpdatesFromJsonl(filePath);
-        const variantCounts = new Map();
-        for (const update of updates) {
-            variantCounts.set(update.type, (variantCounts.get(update.type) ?? 0) + 1);
-        }
-        assert.equal(variantCounts.get("user_message_chunk"), 1);
-        assert.equal(variantCounts.get("agent_message_chunk"), 1);
-        assert.equal(variantCounts.get("tool_call"), 1);
-        assert.equal(variantCounts.get("tool_call_update"), 1);
-        assert.equal(variantCounts.get("usage_update"), 1);
-        const usage = updates.find((update) => update.type === "usage_update");
-        assert.ok(usage && usage.type === "usage_update");
-        assert.deepEqual(usage.usage, {
-            input_tokens: 11,
-            output_tokens: 7,
-            cache_read_tokens: 5,
-            cache_write_tokens: 3,
-        });
-    });
+    ]);
+    assert.equal(updates.length, 0);
 });
-test("extractSessionHistoryUpdatesFromJsonl ignores invalid records", () => {
-    withTempJsonl([
-        { type: "queue-operation", operation: "enqueue" },
-        { type: "progress", data: { not_message: true } },
-        { type: "user", message: { role: "assistant", content: [{ type: "thinking", thinking: "h" }] } },
-    ], (filePath) => {
-        const updates = extractSessionHistoryUpdatesFromJsonl(filePath);
-        assert.equal(updates.length, 0);
-    });
+test("mapSdkSessions normalizes and sorts sessions", () => {
+    const mapped = mapSdkSessions([
+        {
+            sessionId: "older",
+            summary: " Older summary ",
+            lastModified: 100,
+            fileSize: 10,
+            cwd: "C:/work",
+        },
+        {
+            sessionId: "latest",
+            summary: "",
+            lastModified: 200,
+            fileSize: 20,
+            customTitle: "Custom title",
+            gitBranch: "main",
+            firstPrompt: "hello",
+        },
+    ]);
+    assert.deepEqual(mapped, [
+        {
+            session_id: "latest",
+            summary: "Custom title",
+            last_modified_ms: 200,
+            file_size_bytes: 20,
+            git_branch: "main",
+            custom_title: "Custom title",
+            first_prompt: "hello",
+        },
+        {
+            session_id: "older",
+            summary: "Older summary",
+            last_modified_ms: 100,
+            file_size_bytes: 10,
+            cwd: "C:/work",
+        },
+    ]);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-rust",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Claude Code Rust - native Rust terminal interface for Claude Code",
   "keywords": [
     "cli",
@@ -29,11 +29,11 @@
     "README.md"
   ],
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.2.52"
+    "@anthropic-ai/claude-agent-sdk": "0.2.63"
   },
   "scripts": {
     "postinstall": "node ./scripts/postinstall.js",
-    "prepack": "npm --prefix agent-sdk run build"
+    "prepack": "pnpm -C agent-sdk run build"
   },
   "engines": {
     "node": ">=18"