claude-code-rust 0.12.0 → 0.12.2

package/README.md

@@ -5,6 +5,7 @@ A native Rust terminal interface for Claude Code. Drop-in replacement for Anthro
 [![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)
+[![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)
 [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D18-green.svg)](https://nodejs.org/)
 
@@ -35,6 +36,8 @@ If `claude-rs` resolves to an older global shim, ensure your npm global bin dire
 claude-rs
 ```
 
+Full documentation is available at [srothgan.github.io/claude-code-rust](https://srothgan.github.io/claude-code-rust/).
+
 > [!WARNING]
 > **Agent SDK billing changes on June 15, 2026.** Anthropic says Agent SDK usage, `claude -p`, Claude Code GitHub Actions, and third-party Agent SDK apps will use a separate monthly Agent SDK credit instead of normal interactive Claude or Claude Code subscription limits. Because Claude Code Rust wraps the Agent SDK, treat usage through this project as Agent SDK usage. If that credit is exhausted, continued use may require enabling extra usage billed at standard API rates, or requests may pause until the credit refreshes.
 >
@@ -54,14 +57,15 @@ The stock Claude Code TUI runs on Node.js with React Ink. This causes real probl
 
 Claude Code Rust fixes all of these by compiling to a single native binary with direct terminal control via Crossterm.
 
-## Custom Commands
+## Documentation
 
-Claude Code Rust adds project-local slash commands that set environment variables via `.claude/settings.local.json` without leaving the TUI. Changes apply on the next session.
+The manual covers installation from npm and source, help, slash commands, keyboard shortcuts, settings, diagnostics, architecture, and the changelog:
 
-| Command | Usage | Description |
-|---------|-------|-------------|
-| `/1m-context` | `/1m-context <enable\|disable\|status>` | Disable the 1 million token context window to improve model performance and prevent quality degradation on large context windows. |
-| `/opus-version` | `/opus-version <4.5\|4.6\|4.7\|default\|status>` | Pin the Opus model version for the current folder. Useful for switching to 4.6 or 4.5 to avoid 4.7's tokenization issues. Use `default` to clear the pin. |
+- [Installation](https://srothgan.github.io/claude-code-rust/installation.html)
+- [Usage](https://srothgan.github.io/claude-code-rust/usage.html)
+- [Help](https://srothgan.github.io/claude-code-rust/help.html)
+- [Slash commands](https://srothgan.github.io/claude-code-rust/commands.html)
+- [Settings](https://srothgan.github.io/claude-code-rust/settings.html)
 
 ## Status
 

package/agent-sdk/README.md

@@ -9,7 +9,7 @@ npm install
 npm run build
 ```
 
-Build output is written to `dist/bridge.mjs`.
+Build output is written to `dist/bridge.js`.
 
 ## License
 

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

@@ -0,0 +1,44 @@
+const KNOWN_API_PROVIDERS = new Set([
+    "firstParty",
+    "bedrock",
+    "vertex",
+    "foundry",
+    "anthropicAws",
+    "mantle",
+    "gateway",
+]);
+function trimmedString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+export function isKnownApiProvider(provider) {
+    return provider !== undefined && KNOWN_API_PROVIDERS.has(provider);
+}
+export function apiProviderIsExternal(provider) {
+    return provider !== undefined && provider !== "firstParty";
+}
+export function mapSdkAccountInfo(account) {
+    const apiProvider = trimmedString(account.apiProvider);
+    return {
+        ...(trimmedString(account.email) ? { email: trimmedString(account.email) } : {}),
+        ...(trimmedString(account.organization)
+            ? { organization: trimmedString(account.organization) }
+            : {}),
+        ...(trimmedString(account.subscriptionType)
+            ? { subscription_type: trimmedString(account.subscriptionType) }
+            : {}),
+        ...(trimmedString(account.tokenSource)
+            ? { token_source: trimmedString(account.tokenSource) }
+            : {}),
+        ...(trimmedString(account.apiKeySource)
+            ? { api_key_source: trimmedString(account.apiKeySource) }
+            : {}),
+        ...(apiProvider ? { api_provider: apiProvider } : {}),
+    };
+}
+export function shouldEmitStartupAuthRequiredForAccount(account) {
+    const provider = trimmedString(account.apiProvider);
+    if (apiProviderIsExternal(provider)) {
+        return false;
+    }
+    return !trimmedString(account.email) && !trimmedString(account.apiKeySource);
+}

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

@@ -0,0 +1,129 @@
+import { emitSessionUpdate } from "./events.js";
+import { bridgeLogger, LOG_TARGETS } from "./logger.js";
+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 ?? ""]));
+}
+function logAvailableCommandsDecision(session, source, commands, outcome, reason, generation) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: outcome === "accepted"
+            ? "available_commands_snapshot_accepted"
+            : "available_commands_snapshot_ignored",
+        message: outcome === "accepted"
+            ? "available commands snapshot accepted"
+            : "available commands snapshot ignored",
+        outcome,
+        sessionId: session.sessionId,
+        count: commands.length,
+        fields: {
+            source,
+            previous_source: session.availableCommands?.source,
+            generation,
+            command_count: commands.length,
+            command_names: commands.map((command) => command.name),
+            reason,
+        },
+    });
+}
+function shouldAcceptAvailableCommandsSnapshot(session, source, commands) {
+    const current = session.availableCommands;
+    if (isDynamicSource(source)) {
+        return { accept: true, reason: "dynamic source is authoritative" };
+    }
+    if (!current) {
+        if (commands.length === 0) {
+            return { accept: false, reason: "empty bootstrap snapshot ignored before first command list" };
+        }
+        return { accept: true, reason: "initial command snapshot" };
+    }
+    if (current.dynamicSeen) {
+        return {
+            accept: false,
+            reason: "bootstrap source cannot replace dynamic command snapshot",
+        };
+    }
+    if (source === "supportedCommands" && current.commands.length > 0) {
+        return {
+            accept: false,
+            reason: "supportedCommands is an initialize-time fallback and current snapshot already exists",
+        };
+    }
+    if (commands.length === 0) {
+        return { accept: false, reason: "empty bootstrap snapshot ignored" };
+    }
+    return { accept: true, reason: "bootstrap refresh before dynamic command source" };
+}
+export function updateAvailableCommands(session, source, commands) {
+    const decision = shouldAcceptAvailableCommandsSnapshot(session, source, commands);
+    const currentGeneration = session.availableCommands?.generation ?? 0;
+    const nextGeneration = currentGeneration + 1;
+    if (!decision.accept) {
+        logAvailableCommandsDecision(session, source, commands, "ignored", decision.reason, currentGeneration);
+        return false;
+    }
+    const dynamicSeen = session.availableCommands?.dynamicSeen === true || isDynamicSource(source);
+    session.availableCommands = {
+        generation: nextGeneration,
+        source,
+        signature: commandSignature(commands),
+        dynamicSeen,
+        commands,
+    };
+    logAvailableCommandsDecision(session, source, commands, "accepted", decision.reason, nextGeneration);
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "available_commands_update_emitted",
+        message: "available commands update emitted",
+        outcome: "success",
+        sessionId: session.sessionId,
+        count: commands.length,
+        fields: {
+            source,
+            generation: nextGeneration,
+            command_count: commands.length,
+            command_names: commands.map((command) => command.name),
+        },
+    });
+    emitSessionUpdate(session.sessionId, {
+        type: "available_commands_update",
+        commands,
+        source,
+        generation: nextGeneration,
+    });
+    return true;
+}
+export function mapSdkSlashCommand(command) {
+    if (!command || typeof command !== "object") {
+        return null;
+    }
+    const record = command;
+    const name = typeof record.name === "string" ? record.name : "";
+    if (!name) {
+        return null;
+    }
+    return {
+        name,
+        description: typeof record.description === "string" ? record.description : "",
+        input_hint: typeof record.argumentHint === "string" ? record.argumentHint : undefined,
+    };
+}
+export function mapSdkSlashCommands(commands) {
+    if (!Array.isArray(commands)) {
+        return [];
+    }
+    return commands.flatMap((command) => {
+        const mapped = mapSdkSlashCommand(command);
+        return mapped ? [mapped] : [];
+    });
+}
+export function mapInitSlashCommands(commands) {
+    if (!Array.isArray(commands)) {
+        return [];
+    }
+    return commands
+        .filter((entry) => typeof entry === "string")
+        .map((name) => ({ name, description: "", input_hint: undefined }));
+}

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

@@ -1,3 +1,4 @@
+import { parseMcpServersRecord } from "./mcp_metadata.js";
 import { resolveCurrentModel } from "./session_lifecycle.js";
 const MODE_NAMES = {
     default: "Default",
@@ -83,6 +84,27 @@ function expectString(record, key, context) {
     }
     return value;
 }
+function expectEffortLevel(record, key, context) {
+    const value = expectString(record, key, context);
+    if (value !== "low" &&
+        value !== "medium" &&
+        value !== "high" &&
+        value !== "xhigh" &&
+        value !== "max") {
+        throw new Error(`${context}.${key} must be one of low, medium, high, xhigh, max`);
+    }
+    return value;
+}
+function expectNonEmptyStringOrNull(record, key, context) {
+    const value = record[key];
+    if (value === null) {
+        return null;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${context}.${key} must be a non-empty string or null`);
+    }
+    return value;
+}
 function optionalString(record, key, context) {
     const value = record[key];
     if (value === undefined || value === null) {
@@ -162,33 +184,12 @@ function expectBoolean(record, key, context) {
     }
     return value;
 }
-function parseMcpServerConfig(value, context) {
-    const record = asRecord(value, context);
-    const type = expectString(record, "type", context);
-    switch (type) {
-        case "stdio":
-            return {
-                type,
-                command: expectString(record, "command", context),
-                ...(record.args === undefined ? {} : { args: expectStringArray(record, "args", context) }),
-                ...(record.env === undefined ? {} : { env: expectStringMap(record, "env", context) }),
-            };
-        case "sse":
-        case "http":
-            return {
-                type,
-                url: expectString(record, "url", context),
-                ...(record.headers === undefined
-                    ? {}
-                    : { headers: expectStringMap(record, "headers", context) }),
-            };
-        default:
-            throw new Error(`${context}.type must be one of stdio, sse, http`);
+function expectRefusalFallbackPromptChoice(record, key, context) {
+    const value = expectString(record, key, context);
+    if (value !== "retry_fallback" && value !== "edit_prompt") {
+        throw new Error(`${context}.${key} must be 'retry_fallback' or 'edit_prompt'`);
     }
-}
-function parseMcpServersRecord(value, context) {
-    const record = asRecord(value, context);
-    return Object.fromEntries(Object.entries(record).map(([key, entry]) => [key, parseMcpServerConfig(entry, `${context}.${key}`)]));
+    return value;
 }
 export function parseCommandEnvelope(line) {
     const raw = asRecord(JSON.parse(line), "command envelope");
@@ -246,6 +247,18 @@ export function parseCommandEnvelope(line) {
                     session_id: expectString(raw, "session_id", "set_mode"),
                     mode: expectString(raw, "mode", "set_mode"),
                 };
+            case "set_effort":
+                return {
+                    command: "set_effort",
+                    session_id: expectString(raw, "session_id", "set_effort"),
+                    effort: expectEffortLevel(raw, "effort", "set_effort"),
+                };
+            case "set_agent":
+                return {
+                    command: "set_agent",
+                    session_id: expectString(raw, "session_id", "set_agent"),
+                    agent: expectNonEmptyStringOrNull(raw, "agent", "set_agent"),
+                };
             case "generate_session_title":
                 return {
                     command: "generate_session_title",
@@ -339,6 +352,25 @@ export function parseCommandEnvelope(line) {
                     outcome: parsedOutcome,
                 };
             }
+            case "user_dialog_response": {
+                const outcome = asRecord(raw.outcome, "user_dialog_response.outcome");
+                const outcomeType = expectString(outcome, "outcome", "user_dialog_response.outcome");
+                if (outcomeType !== "selected" && outcomeType !== "cancelled") {
+                    throw new Error("user_dialog_response.outcome.outcome must be 'selected' or 'cancelled'");
+                }
+                const parsedOutcome = outcomeType === "selected"
+                    ? {
+                        outcome: "selected",
+                        option_id: expectRefusalFallbackPromptChoice(outcome, "option_id", "user_dialog_response.outcome"),
+                    }
+                    : { outcome: "cancelled" };
+                return {
+                    command: "user_dialog_response",
+                    session_id: expectString(raw, "session_id", "user_dialog_response"),
+                    request_id: expectString(raw, "request_id", "user_dialog_response"),
+                    outcome: parsedOutcome,
+                };
+            }
             case "elicitation_response":
                 return {
                     command: "elicitation_response",
@@ -388,16 +420,6 @@ function expectStringArray(record, key, context) {
         return entry;
     });
 }
-function expectStringMap(record, key, context) {
-    const value = record[key];
-    const parsed = asRecord(value, `${context}.${key}`);
-    return Object.fromEntries(Object.entries(parsed).map(([entryKey, entryValue]) => {
-        if (typeof entryValue !== "string") {
-            throw new Error(`${context}.${key}.${entryKey} must be a string`);
-        }
-        return [entryKey, entryValue];
-    }));
-}
 function parseQuestionAnnotation(value) {
     const record = asRecord(value, "question_response.outcome.annotation");
     const preview = optionalString(record, "preview", "question_response.outcome.annotation");

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

@@ -29,20 +29,33 @@ export function looksLikePlanLimitError(input) {
 }
 export function classifyTurnErrorKind(subtype, errors, assistantError) {
     const combined = errors.join("\n");
+    switch (assistantError) {
+        case "billing_error":
+        case "rate_limit":
+            return "plan_limit";
+        case "authentication_failed":
+            return "auth_required";
+        case "oauth_org_not_allowed":
+            return "account_access";
+        case "model_not_found":
+            return "model_unavailable";
+        case "overloaded":
+        case "server_error":
+            return "transient_service";
+        case "invalid_request":
+        case "max_output_tokens":
+        case "unknown":
+        case undefined:
+            break;
+    }
     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))) {
+    if (errors.some((entry) => looksLikeAuthRequired(entry))) {
         return "auth_required";
     }
-    if (assistantError === "server_error") {
-        return "internal";
-    }
     return "other";
 }
 export function emitFastModeUpdateIfChanged(session, value) {

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

@@ -75,6 +75,24 @@ export function emitQuestionRequestEvent(sessionId, request) {
     });
     writeEvent({ event: "question_request", session_id: sessionId, request });
 }
+export function emitUserDialogRequestEvent(sessionId, request) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "user_dialog_request_emitted",
+        message: "user dialog request emitted",
+        outcome: "success",
+        sessionId,
+        requestId: request.request_id,
+        count: request.options.length,
+        fields: {
+            dialog_kind: request.dialog_kind,
+            option_count: request.options.length,
+            original_model: request.payload.original_model,
+            fallback_model: request.payload.fallback_model,
+        },
+    });
+    writeEvent({ event: "user_dialog_request", session_id: sessionId, request });
+}
 export function emitElicitationRequestEvent(sessionId, request) {
     bridgeLogger.info({
         target: LOG_TARGETS.BRIDGE_PERMISSION,

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

@@ -19,17 +19,166 @@ function messageCandidates(raw) {
     }
     return candidates;
 }
-function pushResumeTextChunk(updates, role, text) {
+function jsonValue(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    try {
+        const text = JSON.stringify(value);
+        if (text === undefined) {
+            return undefined;
+        }
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function mergeTaskMetadata(existing, patch) {
+    if (!patch) {
+        return existing;
+    }
+    const existingRecord = existing && typeof existing === "object" && !Array.isArray(existing)
+        ? { ...existing }
+        : {};
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === null) {
+            delete existingRecord[key];
+        }
+        else {
+            existingRecord[key] = value;
+        }
+    }
+    return Object.keys(existingRecord).length > 0 ? existingRecord : null;
+}
+function normalizeLifecycleTaskStatus(value) {
+    switch (value) {
+        case "pending":
+            return "pending";
+        case "running":
+        case "in_progress":
+            return "in_progress";
+        case "completed":
+        case "failed":
+        case "killed":
+        case "stopped":
+            return "completed";
+        default:
+            return undefined;
+    }
+}
+function taskSystemMetadata(msg, patch) {
+    const metadata = {};
+    const copyValue = (from, key) => {
+        if (!from || !Object.hasOwn(from, key)) {
+            return;
+        }
+        const value = jsonValue(from[key]);
+        if (value !== undefined) {
+            metadata[key] = value;
+        }
+    };
+    for (const key of [
+        "error",
+        "is_backgrounded",
+        "request_id",
+        "subagent_type",
+        "task_description",
+        "task_type",
+        "workflow_name",
+        "prompt",
+        "output_file",
+        "summary",
+        "end_time",
+        "total_paused_ms",
+    ]) {
+        copyValue(msg, key);
+        copyValue(patch, key);
+    }
+    const terminalStatus = nonEmptyTrimmed(msg.status) ?? nonEmptyTrimmed(patch?.status);
+    if (terminalStatus === "completed" ||
+        terminalStatus === "failed" ||
+        terminalStatus === "killed" ||
+        terminalStatus === "stopped") {
+        metadata.terminal_status = terminalStatus;
+    }
+    return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+function pushResumeTaskSystemUpdate(updates, tasksById, taskToolUseIds, msg) {
+    const subtype = nonEmptyTrimmed(msg.subtype);
+    if (subtype !== "task_started" &&
+        subtype !== "task_progress" &&
+        subtype !== "task_updated" &&
+        subtype !== "task_notification") {
+        return false;
+    }
+    const taskId = nonEmptyTrimmed(msg.task_id);
+    if (!taskId) {
+        return true;
+    }
+    const explicitToolUseId = nonEmptyTrimmed(msg.tool_use_id);
+    if (explicitToolUseId) {
+        taskToolUseIds.set(taskId, explicitToolUseId);
+    }
+    const existing = tasksById.get(taskId);
+    const patch = asRecordOrNull(msg.patch) ?? undefined;
+    const status = normalizeLifecycleTaskStatus(msg.status) ??
+        normalizeLifecycleTaskStatus(patch?.status) ??
+        (subtype === "task_started" || subtype === "task_progress" ? "in_progress" : undefined);
+    const description = nonEmptyTrimmed(patch?.description) ??
+        nonEmptyTrimmed(msg.description) ??
+        nonEmptyTrimmed(msg.summary);
+    const activeForm = nonEmptyTrimmed(patch?.activeForm) ?? nonEmptyTrimmed(patch?.active_form);
+    const subject = nonEmptyTrimmed(patch?.subject) ??
+        nonEmptyTrimmed(msg.subject) ??
+        existing?.subject ??
+        nonEmptyTrimmed(msg.workflow_name) ??
+        nonEmptyTrimmed(msg.task_description) ??
+        description ??
+        taskId;
+    const metadata = mergeTaskMetadata(existing?.metadata, taskSystemMetadata(msg, patch));
+    const sourceToolCallId = taskToolUseIds.get(taskId) ?? existing?.source_tool_call_id;
+    const task = {
+        task_id: taskId,
+        subject,
+        ...(description !== undefined ? { description } : existing?.description !== undefined ? { description: existing.description } : {}),
+        ...(activeForm !== undefined ? { active_form: activeForm } : existing?.active_form !== undefined ? { active_form: existing.active_form } : {}),
+        status: status ?? existing?.status ?? "pending",
+        ...(existing?.owner !== undefined ? { owner: existing.owner } : {}),
+        blocks: existing ? [...existing.blocks] : [],
+        blocked_by: existing ? [...existing.blocked_by] : [],
+        ...(metadata !== undefined ? { metadata } : {}),
+        ...(sourceToolCallId !== undefined ? { source_tool_call_id: sourceToolCallId } : {}),
+    };
+    tasksById.set(taskId, task);
+    updates.push({
+        type: "task_state_update",
+        source: "task_lifecycle",
+        tasks: [task],
+        removed_task_ids: [],
+        is_complete_snapshot: false,
+    });
+    return true;
+}
+function pushResumeTextChunk(updates, role, text, sourceMessageUuid) {
     if (!text.trim()) {
         return;
     }
     if (role === "assistant") {
-        updates.push({ type: "agent_message_chunk", content: { type: "text", text } });
+        updates.push({
+            type: "agent_message_chunk",
+            content: { type: "text", text },
+            ...(sourceMessageUuid ? { source_message_uuid: sourceMessageUuid } : {}),
+        });
         return;
     }
-    updates.push({ type: "user_message_chunk", content: { type: "text", text } });
+    updates.push({
+        type: "user_message_chunk",
+        content: { type: "text", text },
+        ...(sourceMessageUuid ? { source_message_uuid: sourceMessageUuid } : {}),
+    });
 }
-function pushResumeToolUse(updates, toolCalls, hiddenToolUseIds, block, parentToolUseId) {
+function pushResumeToolUse(updates, toolCalls, hiddenToolUseIds, block, parentToolUseId, sourceMessageUuid) {
     const toolUseId = typeof block.id === "string" ? block.id : "";
     if (!toolUseId) {
         return;
@@ -42,10 +191,13 @@ function pushResumeToolUse(updates, toolCalls, hiddenToolUseIds, block, parentTo
     }
     const toolCall = createToolCall(toolUseId, name, input, parentToolUseId);
     toolCall.status = "in_progress";
+    if (sourceMessageUuid) {
+        toolCall.source_message_uuid = sourceMessageUuid;
+    }
     toolCalls.set(toolUseId, toolCall);
     updates.push({ type: "tool_call", tool_call: toolCall });
 }
-function pushResumeToolResult(updates, toolCalls, hiddenToolUseIds, block) {
+function pushResumeToolResult(updates, toolCalls, hiddenToolUseIds, block, sourceMessageUuid) {
     const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
     if (!toolUseId) {
         return;
@@ -58,7 +210,14 @@ function pushResumeToolResult(updates, toolCalls, hiddenToolUseIds, block) {
     const isError = Boolean(block.is_error);
     const base = toolCalls.get(toolUseId);
     const fields = buildToolResultFields(isError, block.content, base, block);
-    updates.push({ type: "tool_call_update", tool_call_update: { tool_call_id: toolUseId, fields } });
+    updates.push({
+        type: "tool_call_update",
+        tool_call_update: {
+            tool_call_id: toolUseId,
+            ...(sourceMessageUuid ? { source_message_uuid: sourceMessageUuid } : {}),
+            fields,
+        },
+    });
     if (!base) {
         return;
     }
@@ -111,9 +270,22 @@ export function mapSessionMessagesToUpdates(messages) {
     const updates = [];
     const toolCalls = new Map();
     const hiddenToolUseIds = new Set();
+    const tasksById = new Map();
+    const taskToolUseIds = new Map();
     for (const entry of messages) {
         const fallbackRole = entry.type === "assistant" ? "assistant" : "user";
-        for (const message of messageCandidates(entry.message)) {
+        const entrySourceMessageUuid = typeof entry.uuid === "string" ? entry.uuid : undefined;
+        const candidates = messageCandidates(entry.message);
+        if (entry.type === "system") {
+            for (const message of candidates) {
+                if (pushResumeTaskSystemUpdate(updates, tasksById, taskToolUseIds, message)) {
+                    break;
+                }
+            }
+            continue;
+        }
+        for (const message of candidates) {
+            const sourceMessageUuid = typeof message.uuid === "string" ? message.uuid : entrySourceMessageUuid;
             const roleCandidate = message.role;
             const role = roleCandidate === "assistant" || roleCandidate === "user" ? roleCandidate : fallbackRole;
             const parentToolUseId = typeof entry.parent_tool_use_id === "string"
@@ -132,19 +304,19 @@ export function mapSessionMessagesToUpdates(messages) {
                     continue;
                 }
                 if (blockType === "text" && typeof block.text === "string") {
-                    pushResumeTextChunk(updates, role, block.text);
+                    pushResumeTextChunk(updates, role, block.text, sourceMessageUuid);
                     continue;
                 }
                 if (isToolUseBlockType(blockType) && role === "assistant") {
-                    pushResumeToolUse(updates, toolCalls, hiddenToolUseIds, block, parentToolUseId);
+                    pushResumeToolUse(updates, toolCalls, hiddenToolUseIds, block, parentToolUseId, sourceMessageUuid);
                     continue;
                 }
                 if (TOOL_RESULT_TYPES.has(blockType)) {
-                    pushResumeToolResult(updates, toolCalls, hiddenToolUseIds, block);
+                    pushResumeToolResult(updates, toolCalls, hiddenToolUseIds, block, sourceMessageUuid);
                     continue;
                 }
                 if (blockType === "image") {
-                    pushResumeTextChunk(updates, role, "[image]");
+                    pushResumeTextChunk(updates, role, "[image]", sourceMessageUuid);
                 }
             }
         }