claude-code-rust 0.12.1 → 0.12.3

package/README.md

@@ -38,12 +38,8 @@ 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.
->
-> Sources:
-> - [Anthropic support: Use the Claude Agent SDK with your Claude plan](https://support.claude.com/en/articles/15036540-use-the-claude-agent-sdk-with-your-claude-plan)
-> - [ClaudeDevs announcement](https://x.com/ClaudeDevs/status/2054610152817619388)
+> [!NOTE]
+> **Agent SDK billing unchanged.** Anthropic has paused the previously announced Agent SDK credit change. For now nothing changes: Claude Agent SDK usage — including `claude -p` and third-party apps like this one — still draws from your normal Claude subscription limits. See [Use the Claude Agent SDK with your Claude plan](https://support.claude.com/en/articles/15036540-use-the-claude-agent-sdk-with-your-claude-plan).
 
 ## Why
 
@@ -85,7 +81,7 @@ This project is not affiliated with, endorsed by, or supported by Anthropic.
 
 A quick note on where this project stands, since I know people worry about this kind of thing: claude-code-rust is a terminal UI that I wrote from scratch in Rust. It is not a fork, copy or port of the latest Claude Code source leak -- it talks to Anthropic's official [Agent SDK](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/agent-sdk) as a runtime dependency instead, the same way any other third-party tool would. No Anthropic source code was read or used as reference at any point during development.
 
-The project authenticates through your existing Claude Code account via the Agent SDK, and the Agent SDK's terms allow building on top of it. Billing, credits, limits, and overage behavior are controlled by Anthropic, including the Agent SDK credit change noted above. Other community projects do the same. As far as I can tell, using this project is fine -- but I am a single maintainer, not a lawyer. If anything changes on Anthropic's end, I will update this section and adjust the project accordingly.
+The project authenticates through your existing Claude Code account via the Agent SDK, and the Agent SDK's terms allow building on top of it. Billing, credits, limits, and overage behavior are controlled by Anthropic, including any future changes Anthropic may make to how Agent SDK usage is metered. Other community projects do the same. As far as I can tell, using this project is fine -- but I am a single maintainer, not a lawyer. If anything changes on Anthropic's end, I will update this section and adjust the project accordingly.
 
 This project's source code is licensed under [Apache-2.0](LICENSE). The Agent SDK itself is proprietary and governed by [Anthropic's Commercial Terms of Service](https://www.anthropic.com/legal/commercial-terms).
 

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);
                 }
             }
         }