claude-code-rust 0.5.1 → 0.7.0

package/README.md

@@ -2,13 +2,15 @@
 
 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
 
-Claude Code Rust replaces the stock Claude Code terminal interface with a native Rust binary built on [Ratatui](https://ratatui.rs/). It connects to the same Claude API through a local Agent SDK bridge (`agent-sdk/dist/bridge.js`). Core Claude Code functionality - tool calls, file editing, terminal commands, and permissions - works unchanged.
+Claude Code Rust replaces the stock Claude Code terminal interface with a native Rust binary built on [Ratatui](https://ratatui.rs/). It connects to the same Claude API through a local Agent SDK bridge. Core Claude Code functionality - tool calls, file editing, terminal commands, and permissions - works unchanged.
 
 ## Requisites
 
@@ -17,13 +19,13 @@ Claude Code Rust replaces the stock Claude Code terminal interface with a native
 
 ## Install
 
-### npm (global, recommended)
+### pnpm (global, recommended)
 
 ```bash
-npm install -g claude-code-rust
+pnpm add -g claude-code-rust
 ```
 
-The npm package installs a `claude-rs` command and downloads the matching
+The published package installs a `claude-rs` command and downloads the matching
 prebuilt release binary for your platform during `postinstall`.
 
 ## Usage
@@ -56,9 +58,7 @@ 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.
+- The config view includes the Settings tab but the Status, Usage, and MCP tabs are not yet implemented.
 
 ## Status
 

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

@@ -0,0 +1,75 @@
+import { emitSessionUpdate } from "./events.js";
+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));
+}
+export 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));
+}
+export function emitAvailableAgentsIfChanged(session, agents) {
+    const signature = availableAgentsSignature(agents);
+    if (session.lastAvailableAgentsSignature === signature) {
+        return;
+    }
+    session.lastAvailableAgentsSignature = signature;
+    emitSessionUpdate(session.sessionId, { type: "available_agents_update", agents });
+}
+export function refreshAvailableAgents(session) {
+    if (typeof session.query.supportedAgents !== "function") {
+        return;
+    }
+    void session.query
+        .supportedAgents()
+        .then((agents) => {
+        emitAvailableAgentsIfChanged(session, mapAvailableAgents(agents));
+    })
+        .catch(() => {
+        // Best-effort only.
+    });
+}

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

@@ -25,13 +25,6 @@ function expectString(record, key, context) {
     }
     return value;
 }
-function expectBoolean(record, key, context) {
-    const value = record[key];
-    if (typeof value !== "boolean") {
-        throw new Error(`${context}.${key} must be a boolean`);
-    }
-    return value;
-}
 function optionalString(record, key, context) {
     const value = record[key];
     if (value === undefined || value === null) {
@@ -49,6 +42,45 @@ function optionalMetadata(record, key) {
     }
     return asRecord(value, `${key} metadata`);
 }
+function optionalLaunchSettings(record, key, context) {
+    const value = record[key];
+    if (value === undefined || value === null) {
+        return {};
+    }
+    const parsed = asRecord(value, `${context}.${key}`);
+    const model = optionalString(parsed, "model", `${context}.${key}`);
+    const language = optionalString(parsed, "language", `${context}.${key}`);
+    const permissionMode = optionalString(parsed, "permission_mode", `${context}.${key}`);
+    const thinkingMode = optionalThinkingMode(parsed, "thinking_mode", `${context}.${key}`);
+    const effortLevel = optionalEffortLevel(parsed, "effort_level", `${context}.${key}`);
+    return {
+        ...(model ? { model } : {}),
+        ...(language ? { language } : {}),
+        ...(permissionMode ? { permission_mode: permissionMode } : {}),
+        ...(thinkingMode ? { thinking_mode: thinkingMode } : {}),
+        ...(effortLevel ? { effort_level: effortLevel } : {}),
+    };
+}
+function optionalThinkingMode(record, key, context) {
+    const value = optionalString(record, key, context);
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "adaptive" || value === "disabled") {
+        return value;
+    }
+    throw new Error(`${context}.${key} must be "adaptive" or "disabled" when provided`);
+}
+function optionalEffortLevel(record, key, context) {
+    const value = optionalString(record, key, context);
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "low" || value === "medium" || value === "high") {
+        return value;
+    }
+    throw new Error(`${context}.${key} must be "low", "medium", or "high" when provided`);
+}
 function parsePromptChunks(record, context) {
     const rawChunks = record.chunks;
     if (!Array.isArray(rawChunks)) {
@@ -76,23 +108,22 @@ export function parseCommandEnvelope(line) {
                 return {
                     command: "create_session",
                     cwd: expectString(raw, "cwd", "create_session"),
-                    yolo: expectBoolean(raw, "yolo", "create_session"),
-                    model: optionalString(raw, "model", "create_session"),
                     resume: optionalString(raw, "resume", "create_session"),
+                    launch_settings: optionalLaunchSettings(raw, "launch_settings", "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"),
+                    launch_settings: optionalLaunchSettings(raw, "launch_settings", "resume_session"),
                     metadata: optionalMetadata(raw, "metadata"),
                 };
             case "new_session":
                 return {
                     command: "new_session",
                     cwd: expectString(raw, "cwd", "new_session"),
-                    yolo: expectBoolean(raw, "yolo", "new_session"),
-                    model: optionalString(raw, "model", "new_session"),
+                    launch_settings: optionalLaunchSettings(raw, "launch_settings", "new_session"),
                 };
             case "prompt":
                 return {

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

@@ -0,0 +1,55 @@
+import { looksLikeAuthRequired } from "./auth.js";
+import { writeEvent } from "./events.js";
+import { emitSessionUpdate } from "./events.js";
+import { parseFastModeState } from "./state_parsing.js";
+export function emitAuthRequired(session, detail) {
+    if (session.authHintSent) {
+        return;
+    }
+    session.authHintSent = true;
+    writeEvent({
+        event: "auth_required",
+        method_name: "Claude Login",
+        method_description: detail && detail.trim().length > 0
+            ? detail
+            : "Type /login to authenticate.",
+    });
+}
+export function looksLikePlanLimitError(input) {
+    const normalized = input.toLowerCase();
+    return (normalized.includes("rate limit") ||
+        normalized.includes("rate-limit") ||
+        normalized.includes("max turns") ||
+        normalized.includes("max budget") ||
+        normalized.includes("quota") ||
+        normalized.includes("plan limit") ||
+        normalized.includes("too many requests") ||
+        normalized.includes("insufficient quota") ||
+        normalized.includes("429"));
+}
+export function classifyTurnErrorKind(subtype, errors, assistantError) {
+    const combined = errors.join("\n");
+    if (subtype === "error_max_turns" ||
+        subtype === "error_max_budget_usd" ||
+        assistantError === "billing_error" ||
+        assistantError === "rate_limit" ||
+        (combined.length > 0 && looksLikePlanLimitError(combined))) {
+        return "plan_limit";
+    }
+    if (assistantError === "authentication_failed" ||
+        errors.some((entry) => looksLikeAuthRequired(entry))) {
+        return "auth_required";
+    }
+    if (assistantError === "server_error") {
+        return "internal";
+    }
+    return "other";
+}
+export 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 });
+}

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

@@ -0,0 +1,83 @@
+import { listSessions } from "@anthropic-ai/claude-agent-sdk";
+import { buildModeState } from "./commands.js";
+import { mapSdkSessions } from "./history.js";
+const SESSION_LIST_LIMIT = 50;
+export function writeEvent(event, requestId) {
+    const envelope = {
+        ...(requestId ? { request_id: requestId } : {}),
+        ...event,
+    };
+    process.stdout.write(`${JSON.stringify(envelope)}\n`);
+}
+export function failConnection(message, requestId) {
+    writeEvent({ event: "connection_failed", message }, requestId);
+}
+export function slashError(sessionId, message, requestId) {
+    writeEvent({ event: "slash_error", session_id: sessionId, message }, requestId);
+}
+export function emitSessionUpdate(sessionId, update) {
+    writeEvent({ event: "session_update", session_id: sessionId, update });
+}
+export function emitConnectEvent(session) {
+    const historyUpdates = session.resumeUpdates;
+    const connectEvent = session.connectEvent === "session_replaced"
+        ? {
+            event: "session_replaced",
+            session_id: session.sessionId,
+            cwd: session.cwd,
+            model_name: session.model,
+            available_models: session.availableModels,
+            mode: session.mode ? buildModeState(session.mode) : null,
+            ...(historyUpdates && historyUpdates.length > 0 ? { history_updates: historyUpdates } : {}),
+        }
+        : {
+            event: "connected",
+            session_id: session.sessionId,
+            cwd: session.cwd,
+            model_name: session.model,
+            available_models: session.availableModels,
+            mode: session.mode ? buildModeState(session.mode) : null,
+            ...(historyUpdates && historyUpdates.length > 0 ? { history_updates: historyUpdates } : {}),
+        };
+    writeEvent(connectEvent, session.connectRequestId);
+    session.connectRequestId = undefined;
+    session.connected = true;
+    session.authHintSent = false;
+    session.resumeUpdates = undefined;
+    const staleSessions = session.sessionsToCloseAfterConnect;
+    session.sessionsToCloseAfterConnect = undefined;
+    if (!staleSessions || staleSessions.length === 0) {
+        refreshSessionsList();
+        return;
+    }
+    void (async () => {
+        // Lazy import to break circular dependency at module-evaluation time.
+        const { sessions, closeSession } = await import("./session_lifecycle.js");
+        for (const stale of staleSessions) {
+            if (stale === session) {
+                continue;
+            }
+            if (sessions.get(stale.sessionId) === stale) {
+                sessions.delete(stale.sessionId);
+            }
+            await closeSession(stale);
+        }
+        refreshSessionsList();
+    })();
+}
+export 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);
+    }
+}
+export function refreshSessionsList() {
+    void emitSessionsList().catch(() => {
+        // Defensive no-op.
+    });
+}

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

@@ -1,224 +1,21 @@
-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 { 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) {
+import { TOOL_RESULT_TYPES, buildToolResultFields, createToolCall, isToolUseBlockType } from "./tooling.js";
+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;
 }
@@ -264,53 +61,48 @@ function pushResumeToolResult(updates, toolCalls, block) {
         base.content = fields.content;
     }
 }
-function pushResumeUsageUpdate(updates, message, emittedUsageMessageIds) {
-    const messageId = typeof message.id === "string" ? message.id : "";
-    if (messageId && emittedUsageMessageIds.has(messageId)) {
-        return;
-    }
-    const usageUpdate = buildUsageUpdateFromResult(message);
-    if (!usageUpdate) {
-        return;
-    }
-    updates.push(usageUpdate);
-    if (messageId) {
-        emittedUsageMessageIds.add(messageId);
-    }
+function summaryFromSession(info) {
+    return (nonEmptyTrimmed(info.summary) ??
+        nonEmptyTrimmed(info.customTitle) ??
+        nonEmptyTrimmed(info.firstPrompt) ??
+        info.sessionId);
 }
-export function extractSessionHistoryUpdatesFromJsonl(filePath) {
-    let text;
-    try {
-        text = fs.readFileSync(filePath, "utf8");
-    }
-    catch {
-        return [];
-    }
-    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 {
+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;
         }
-        const record = asRecordOrNull(parsed);
-        if (!record) {
-            continue;
+        seen.add(info.sessionId);
+        entries.push(mapSdkSessionInfo(info));
+        if (entries.length >= limit) {
+            break;
         }
-        for (const message of persistedMessageCandidates(record)) {
-            const role = message.role;
-            if (role !== "user" && role !== "assistant") {
-                continue;
-            }
+    }
+    return entries;
+}
+export function mapSessionMessagesToUpdates(messages) {
+    const updates = [];
+    const toolCalls = new Map();
+    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);
@@ -337,7 +129,6 @@ export function extractSessionHistoryUpdatesFromJsonl(filePath) {
                     pushResumeTextChunk(updates, role, "[image]");
                 }
             }
-            pushResumeUsageUpdate(updates, message, emittedUsageMessageIds);
         }
     }
     return updates;