@best-agent/cli 0.0.2-beta.8 → 0.0.2-beta.9

package/dist/dimsdk/core/store/message-mutations.js

@@ -1,1528 +0,0 @@
-import { isRecord } from "@best-agent/foundation";
-import { createEnvReader, readProcessEnv } from "../env.js";
-import { splitMarkdownByFencedCodeBlocks } from "../markdown.js";
-import { isOneShotEnabled, isPerfEnabled, perfLog as perfLogLine, } from "../observability/perf-log.js";
-import { createChecklistPartId, createLocalInteractivePartId, createLocalThinkingPartId, } from "../transcript-part-id.js";
-import { isTerminalStatusText, t } from "../../i18n/index.js";
-import { computed } from "vue";
-function getRuntimeParts(message) {
-    return message.parts;
-}
-function isRuntimeMarkdownPart(part) {
-    return part?.type === "markdown";
-}
-function isApprovalForToolCall(part, toolCallId) {
-    return part?.type === "approve" && part.request.toolCallId === toolCallId;
-}
-function isToolOutputForCall(part, toolCallId) {
-    return part?.type === "tool_output" && part.toolCallId === toolCallId;
-}
-function isToolResultForCall(part, toolCallId) {
-    return part?.type === "tool_result" && part.result.toolCallId === toolCallId;
-}
-function findToolCallPartIndex(parts, callId) {
-    for (let i = parts.length - 1; i >= 0; i--) {
-        const part = parts[i];
-        if (part?.type === "tool_call" && part.call.id === callId)
-            return i;
-    }
-    return -1;
-}
-function findToolOutputPartIndex(parts, toolCallId) {
-    for (let i = parts.length - 1; i >= 0; i--) {
-        const part = parts[i];
-        if (part?.type === "tool_output" && part.toolCallId === toolCallId)
-            return i;
-    }
-    return -1;
-}
-function getScopedSubagentId(part) {
-    const value = part._subagentId ??
-        (part.type === "tool_call" ? part.call.subagentId : undefined) ??
-        (part.type === "tool_result" ? part.result.subagentId : undefined) ??
-        (part.type === "tool_output" ? part.subagentId : undefined) ??
-        (part.type === "approve" ? part.request.subagentId : undefined);
-    return String(value ?? "").trim();
-}
-function isChecklistPartOfKind(part, kind) {
-    return part.type === kind;
-}
-function createChecklistPart(kind, input) {
-    return kind === "plan" ? { type: "plan", ...input } : { type: "todo", ...input };
-}
-export function createMessageMutations(state, hooks = {}) {
-    const userHistoryIndexByMessageId = new Map();
-    const env = createEnvReader(readProcessEnv());
-    const perfEnabled = isPerfEnabled();
-    const perfStreamEnabled = perfEnabled && (isOneShotEnabled() || env.prefixedStr("PROFILE_STREAM_MUTATIONS") === "1");
-    let lastStreamSlowLogAt = 0;
-    function perfLogStream(line) {
-        if (!perfEnabled)
-            return;
-        perfLogLine(line);
-    }
-    const streamMarkdownTailLimit = (() => {
-        const raw = env.prefixedStr("STREAM_MARKDOWN_TAIL_CHARS");
-        const n = Number(raw);
-        if (Number.isFinite(n) && n > 0)
-            return Math.min(5_000_000, Math.max(2000, Math.floor(n)));
-        return 30_000;
-    })();
-    const streamMarkdownChunkThreshold = (() => {
-        const raw = env.prefixedStr("STREAM_MARKDOWN_CHUNK_THRESHOLD_CHARS");
-        const n = Number(raw);
-        if (Number.isFinite(n) && n > 0)
-            return Math.min(5_000_000, Math.max(2000, Math.floor(n)));
-        return 20_000;
-    })();
-    const streamToolOutputTailLimit = (() => {
-        const raw = env.prefixedStr("STREAM_TOOL_OUTPUT_TAIL_CHARS");
-        const n = Number(raw);
-        if (Number.isFinite(n) && n > 0)
-            return Math.min(5_000_000, Math.max(2000, Math.floor(n)));
-        return 30_000;
-    })();
-    const streamToolOutputTailLinesLimit = (() => {
-        const raw = env.prefixedStr("STREAM_TOOL_OUTPUT_TAIL_LINES");
-        const n = Number(raw);
-        if (Number.isFinite(n) && n > 0)
-            return Math.min(50_000, Math.max(20, Math.floor(n)));
-        return 2000;
-    })();
-    const streamToolArgsTailLimit = (() => {
-        const raw = env.prefixedStr("STREAM_TOOL_ARGS_TAIL_CHARS");
-        const n = Number(raw);
-        if (Number.isFinite(n) && n > 0)
-            return Math.min(5_000_000, Math.max(2000, Math.floor(n)));
-        return 30_000;
-    })();
-    let messageIndexById = null;
-    function rebuildMessageIndex() {
-        const next = new Map();
-        for (let i = 0; i < state.messages.length; i += 1) {
-            const id = String(state.messages[i]?.id ?? "").trim();
-            if (id)
-                next.set(id, i);
-        }
-        messageIndexById = next;
-        return next;
-    }
-    function messageIndex(messageId) {
-        const id = String(messageId ?? "").trim();
-        if (!id)
-            return -1;
-        let index = messageIndexById ?? rebuildMessageIndex();
-        const found = index.get(id);
-        if (found !== undefined &&
-            found >= 0 &&
-            found < state.messages.length &&
-            String(state.messages[found]?.id ?? "").trim() === id) {
-            return found;
-        }
-        index = rebuildMessageIndex();
-        return index.get(id) ?? -1;
-    }
-    function messageById(messageId) {
-        const idx = messageIndex(messageId);
-        return idx >= 0 ? state.messages[idx] : undefined;
-    }
-    function getMarkdownCodeBlockHash(language, code) {
-        const str = `${String(language ?? "").trim() || "text"}\0${String(code ?? "").replace(/\r/g, "")}`;
-        let hash = 0;
-        for (let i = 0; i < str.length; i++) {
-            const ch = str.charCodeAt(i);
-            hash = (hash << 5) - hash + ch;
-            hash = hash & hash;
-        }
-        return hash.toString(36);
-    }
-    function pruneMarkdownCodeBlockPreviews(markdown, existing) {
-        if (!Array.isArray(existing) || existing.length === 0)
-            return undefined;
-        const codeBlocks = splitMarkdownByFencedCodeBlocks(markdown).filter((block) => block.type === "code");
-        if (codeBlocks.length === 0)
-            return undefined;
-        const max = Math.min(existing.length, codeBlocks.length);
-        let keep = 0;
-        for (; keep < max; keep++) {
-            const preview = existing[keep];
-            const block = codeBlocks[keep];
-            if (!preview || !block)
-                break;
-            const language = String(block.language ?? "").trim() || "text";
-            const code = String(block.code ?? "").replace(/\r/g, "");
-            const totalLines = code.split("\n").length;
-            if (preview.hash !== getMarkdownCodeBlockHash(language, code) ||
-                preview.totalLines !== totalLines) {
-                break;
-            }
-        }
-        return keep > 0 ? existing.slice(0, keep) : undefined;
-    }
-    function countNewlines(text) {
-        const s = String(text ?? "");
-        if (!s)
-            return 0;
-        let n = 0;
-        for (let i = 0; i < s.length; i++) {
-            // '\n'
-            if (s.charCodeAt(i) === 10)
-                n++;
-        }
-        return n;
-    }
-    function computeTailLinesFromTailText(tail, maxLines) {
-        const cap = Math.max(1, Math.floor(maxLines) + 1);
-        const segs = String(tail ?? "")
-            .replace(/\r/g, "")
-            .split("\n");
-        if (segs.length > cap)
-            return segs.slice(-cap);
-        return segs;
-    }
-    function appendTailLines(prevLines, delta, maxLines, maxChars) {
-        const parts = String(delta ?? "")
-            .replace(/\r/g, "")
-            .split("\n");
-        let lines = prevLines.length > 0 ? prevLines.slice() : [""];
-        lines[lines.length - 1] = `${lines[lines.length - 1] ?? ""}${parts[0] ?? ""}`;
-        for (let i = 1; i < parts.length; i++)
-            lines.push(parts[i] ?? "");
-        const charCap = Math.max(0, Math.floor(maxChars));
-        let totalChars = Math.max(0, lines.length - 1);
-        for (const line of lines)
-            totalChars += line.length;
-        if (totalChars > charCap) {
-            let removeChars = totalChars - charCap;
-            let start = 0;
-            while (start < lines.length && removeChars > (lines[start]?.length ?? 0)) {
-                removeChars -= lines[start]?.length ?? 0;
-                start++;
-                if (start < lines.length)
-                    removeChars--;
-            }
-            lines = lines.slice(start);
-            if (lines.length === 0)
-                return [""];
-            if (removeChars > 0)
-                lines[0] = lines[0]?.slice(removeChars) ?? "";
-        }
-        const cap = Math.max(1, Math.floor(maxLines) + 1);
-        if (lines.length > cap)
-            return lines.slice(-cap);
-        return lines;
-    }
-    function normalizeUserHistoryText(v) {
-        const s = String(v ?? "");
-        // Match ChatPage behavior: normalize newlines + trim + ignore empty.
-        return s.replace(/\r\n?/g, "\n").trim();
-    }
-    function rebuildUserHistory() {
-        userHistoryIndexByMessageId.clear();
-        state.userHistory.length = 0;
-        for (const m of state.messages) {
-            if (!m || m.role !== "user")
-                continue;
-            const normalized = normalizeUserHistoryText(m.content);
-            if (!normalized)
-                continue;
-            const idx = state.userHistory.length;
-            state.userHistory.push(normalized);
-            userHistoryIndexByMessageId.set(m.id, idx);
-        }
-    }
-    function upsertUserHistoryForMessage(m) {
-        if (!m || m.role !== "user")
-            return;
-        const id = String(m.id ?? "").trim();
-        if (!id)
-            return;
-        const normalized = normalizeUserHistoryText(m.content);
-        const existing = userHistoryIndexByMessageId.get(id);
-        if (!normalized) {
-            if (existing == null)
-                return;
-            // Removing an entry shifts indices; rebuild to keep the map consistent.
-            rebuildUserHistory();
-            return;
-        }
-        if (existing == null) {
-            const idx = state.userHistory.length;
-            state.userHistory.push(normalized);
-            userHistoryIndexByMessageId.set(id, idx);
-            return;
-        }
-        if (state.userHistory[existing] !== normalized)
-            state.userHistory[existing] = normalized;
-    }
-    function markLayoutDirty(messageId) {
-        const id = String(messageId ?? "").trim();
-        if (!id)
-            return;
-        state.layoutDirtyMessageId = id;
-        state.layoutDirtySeq++;
-    }
-    function normalizeInteractivePartIds(message) {
-        if (message.role !== "assistant")
-            return message;
-        let thinkingOrdinal = 0;
-        let todoOrdinal = 0;
-        let planOrdinal = 0;
-        let changed = false;
-        const parts = message.parts.map((part) => {
-            if (part.type === "thinking") {
-                const existingPartId = String(part.partId ?? "").trim();
-                const partId = existingPartId || createLocalThinkingPartId(message.id, thinkingOrdinal);
-                thinkingOrdinal += 1;
-                if (existingPartId)
-                    return part;
-                changed = true;
-                return { ...part, partId };
-            }
-            if (part.type === "todo" || part.type === "plan") {
-                const existingPartId = String(part.partId ?? "").trim();
-                const ordinal = part.type === "todo" ? todoOrdinal++ : planOrdinal++;
-                const partId = existingPartId ||
-                    (part.toolCallId
-                        ? createChecklistPartId(part.type, part.toolCallId)
-                        : createLocalInteractivePartId(part.type, message.id, ordinal));
-                if (existingPartId)
-                    return part;
-                changed = true;
-                return { ...part, partId };
-            }
-            return part;
-        });
-        return changed ? { ...message, parts } : message;
-    }
-    function pushMessage(m) {
-        const next = normalizeInteractivePartIds(m);
-        state.messages.push(next);
-        const id = String(next.id ?? "").trim();
-        if (id && messageIndexById)
-            messageIndexById.set(id, state.messages.length - 1);
-        upsertUserHistoryForMessage(next);
-        hooks.onMessageAdded?.(next);
-    }
-    function setSessionHistoryDirty(value) {
-        if (typeof state.sessionHistoryDirty === "boolean")
-            state.sessionHistoryDirty = value;
-    }
-    function replaceMessageInternal(messageId, next, opts) {
-        const normalizedNext = normalizeInteractivePartIds(next);
-        const idx = messageIndex(messageId);
-        if (idx >= 0) {
-            const prev = state.messages[idx];
-            state.messages[idx] = normalizedNext;
-            if (messageIndexById) {
-                messageIndexById.delete(String(prev.id ?? "").trim());
-                const nextId = String(normalizedNext.id ?? "").trim();
-                if (nextId)
-                    messageIndexById.set(nextId, idx);
-            }
-            hooks.onMessageReplaced?.(prev, normalizedNext);
-        }
-        upsertUserHistoryForMessage(normalizedNext);
-        if (opts?.layoutDirty !== false)
-            markLayoutDirty(messageId);
-    }
-    function replaceMessage(messageId, next) {
-        replaceMessageInternal(messageId, next);
-    }
-    function updateAssistant(messageId, fn) {
-        const msg = messageById(messageId);
-        if (!msg || msg.role !== "assistant")
-            return;
-        const next = fn(msg);
-        if (next === msg)
-            return;
-        replaceMessage(messageId, next);
-    }
-    function updateAssistantHidden(messageId, fn) {
-        const msg = messageById(messageId);
-        if (!msg || msg.role !== "assistant")
-            return;
-        const next = fn(msg);
-        if (next === msg)
-            return;
-        replaceMessageInternal(messageId, next, { layoutDirty: false });
-    }
-    function setAssistantStatus(messageId, text) {
-        updateAssistant(messageId, (m) => {
-            const parts = m.parts.map((p) => p.type === "status" ? { type: "status", text } : p);
-            // If a large streaming markdown part used chunked storage, finalize it once the status
-            // becomes terminal. This ensures snapshots/persistence can capture the full output.
-            const isTerminal = isTerminalStatusText(text);
-            if (!isTerminal)
-                return { ...m, parts };
-            let changed = false;
-            const finalized = parts.map((p) => {
-                if (!isRuntimeMarkdownPart(p))
-                    return p;
-                const chunks = p.streamMeta?.chunks;
-                if (!Array.isArray(chunks) || chunks.length === 0)
-                    return p;
-                const joined = chunks.join("");
-                changed = true;
-                const { streamMeta: _streamMeta, ...next } = p;
-                return { ...next, markdown: joined };
-            });
-            return changed ? { ...m, parts: finalized } : { ...m, parts };
-        });
-    }
-    function setAssistantThinking(assistantId, content, partId) {
-        const nextContent = String(content ?? "");
-        const normalizedPartId = String(partId ?? "").trim();
-        if (!normalizedPartId)
-            return;
-        updateAssistant(assistantId, (m) => {
-            const parts = getRuntimeParts(m).slice();
-            const idx = parts.findIndex((p) => p.type === "thinking" && String(p.partId ?? "").trim() === normalizedPartId);
-            if (idx >= 0) {
-                const prev = parts[idx];
-                parts[idx] = {
-                    type: "thinking",
-                    partId: prev.partId,
-                    title: prev.title,
-                    collapsed: prev.collapsed,
-                    content: nextContent,
-                };
-                return { ...m, parts };
-            }
-            const insertAt = Math.max(0, parts.findIndex((p) => p.type === "status") + 1);
-            parts.splice(insertAt, 0, {
-                type: "thinking",
-                partId: normalizedPartId,
-                title: t("chatParts.thinking"),
-                collapsed: true,
-                content: nextContent,
-            });
-            return { ...m, parts };
-        });
-    }
-    /**
-     * Start a new thinking block. Creates a fresh thinking part with empty content.
-     * Used when a new thinking_start event is received.
-     *
-     * IMPORTANT: Always appends to the END of the parts array.
-     * This ensures that thinking blocks appear in the correct temporal order
-     * relative to other parts (like tool_calls) that are added during streaming.
-     *
-     * During streaming, events arrive in this order:
-     * - thinking_start -> thinking_delta -> thinking_end (first thinking block)
-     * - tool_call (tool call appears after first thinking)
-     * - thinking_start -> thinking_delta -> thinking_end (second thinking block)
-     *
-     * By appending to the end, we preserve this temporal order.
-     */
-    function startNewThinkingBlock(assistantId, partId) {
-        const normalizedPartId = String(partId ?? "").trim();
-        if (!normalizedPartId)
-            return;
-        updateAssistant(assistantId, (m) => {
-            const parts = m.parts.slice();
-            const existingIdx = parts.findIndex((part) => part.type === "thinking" && String(part.partId ?? "").trim() === normalizedPartId);
-            if (existingIdx >= 0)
-                return m;
-            // Always append to the end to preserve temporal order during streaming
-            // This ensures thinking blocks appear in the correct sequence relative
-            // to tool_calls and other parts that are added during streaming
-            // Default collapsed; user can toggle to expand.
-            parts.push({
-                type: "thinking",
-                partId: normalizedPartId,
-                title: t("chatParts.thinking"),
-                collapsed: true,
-                content: "",
-            });
-            return { ...m, parts };
-        });
-    }
-    /**
-     * End a thinking block by optionally updating content.
-     * Used when a thinking_end event is received.
-     *
-     * @param assistantId - The ID of the assistant message
-     * @param partId - The stable identity of the thinking block
-     * @param content - Optional final content to set on the thinking block
-     */
-    function endThinkingBlock(assistantId, partId, content) {
-        const normalizedPartId = String(partId ?? "").trim();
-        if (!normalizedPartId)
-            return;
-        updateAssistant(assistantId, (m) => {
-            const parts = m.parts.slice();
-            const idx = parts.findIndex((p) => p.type === "thinking" && String(p.partId ?? "").trim() === normalizedPartId);
-            if (idx >= 0) {
-                const prev = parts[idx];
-                parts[idx] = {
-                    type: "thinking",
-                    partId: prev.partId,
-                    title: prev.title,
-                    collapsed: prev.collapsed,
-                    content: content !== undefined ? content : prev.content,
-                };
-                return { ...m, parts };
-            }
-            return m;
-        });
-    }
-    function appendAssistantMarkdown(assistantId, delta) {
-        const d = String(delta ?? "");
-        if (!d)
-            return;
-        updateAssistant(assistantId, (m) => {
-            const last = m.parts[m.parts.length - 1];
-            if (isRuntimeMarkdownPart(last)) {
-                const prev = last;
-                const buildNextPart = (markdown, streamMeta) => {
-                    const nextCodeBlocks = pruneMarkdownCodeBlockPreviews(markdown, Array.isArray(prev.codeBlocks) ? prev.codeBlocks : undefined);
-                    const nextPart = {
-                        ...prev,
-                        type: "markdown",
-                        markdown,
-                        streamMeta,
-                    };
-                    if (nextCodeBlocks) {
-                        return { ...nextPart, codeBlocks: nextCodeBlocks };
-                    }
-                    delete nextPart.codeBlocks;
-                    return nextPart;
-                };
-                const prevChunks = prev.streamMeta?.chunks;
-                if (Array.isArray(prevChunks)) {
-                    // Chunked mode: keep full content as chunks, but only maintain a small tail string
-                    // to avoid O(n^2) string concatenation as the message grows.
-                    const chunks = [...prevChunks, d];
-                    const nextTail = `${String(prev.markdown ?? "")}${d}`;
-                    const markdown = nextTail.length > streamMarkdownTailLimit
-                        ? nextTail.slice(-streamMarkdownTailLimit)
-                        : nextTail;
-                    getRuntimeParts(m)[m.parts.length - 1] = buildNextPart(markdown, {
-                        chunks,
-                        fullLen: Number(prev.streamMeta?.fullLen ?? 0) + d.length,
-                        tailLimit: streamMarkdownTailLimit,
-                        appendSeq: Number(prev.streamMeta?.appendSeq ?? 0) + 1,
-                        lastAppendDelta: d,
-                    });
-                    return { ...m, parts: m.parts };
-                }
-                const prevText = String(prev.markdown ?? "");
-                const nextText = `${prevText}${d}`;
-                if (nextText.length >= streamMarkdownChunkThreshold) {
-                    const chunks = [prevText, d];
-                    const markdown = nextText.length > streamMarkdownTailLimit
-                        ? nextText.slice(-streamMarkdownTailLimit)
-                        : nextText;
-                    getRuntimeParts(m)[m.parts.length - 1] = buildNextPart(markdown, {
-                        chunks,
-                        fullLen: nextText.length,
-                        tailLimit: streamMarkdownTailLimit,
-                        appendSeq: Number(prev.streamMeta?.appendSeq ?? 0) + 1,
-                        lastAppendDelta: d,
-                    });
-                    return { ...m, parts: m.parts };
-                }
-                // Small markdown: keep as a single string.
-                // Streaming optimization: mutate in-place to avoid allocating a new parts array per chunk.
-                getRuntimeParts(m)[m.parts.length - 1] = buildNextPart(nextText, {
-                    appendSeq: Number(prev.streamMeta?.appendSeq ?? 0) + 1,
-                    lastAppendDelta: d,
-                });
-                return { ...m, parts: m.parts };
-            }
-            // Add new part (also in-place to avoid allocations during streaming).
-            getRuntimeParts(m).push({
-                type: "markdown",
-                markdown: d,
-                streamMeta: {
-                    appendSeq: 1,
-                    lastAppendDelta: d,
-                },
-            });
-            return { ...m, parts: m.parts };
-        });
-    }
-    function appendInfoPart(assistantId, text, meta) {
-        const t = String(text ?? "").trim();
-        const hasReasoningMeta = typeof meta?._reasoning === "string";
-        if (!t && !hasReasoningMeta)
-            return;
-        updateAssistant(assistantId, (m) => {
-            getRuntimeParts(m).push({ type: "info", text: t, ...meta });
-            return { ...m, parts: m.parts };
-        });
-    }
-    function applySubagentInfoToParts(parts, input) {
-        const subagentId = String(input.subagentId ?? "").trim();
-        const t = String(input.text ?? "").trim();
-        if (!subagentId || !t)
-            return false;
-        const metaTurnId = String(input.meta?.subagentTurnId ?? "").trim();
-        const metaStream = String(input.meta?.subagentStream ?? "").trim();
-        const sameInfo = (part, infoKind) => Boolean(part?.type === "info" &&
-            part.text === t &&
-            part._subagent === infoKind &&
-            part._subagentId === subagentId &&
-            String(part._subagentTurnId ?? "").trim() === metaTurnId &&
-            String(part._subagentStream ?? "").trim() === metaStream);
-        // Find the insertion point: right after the last part belonging to
-        // this subagentId. This keeps header + the single live activity line
-        // grouped together even when multiple subagents run concurrently.
-        const findInsertAfter = () => {
-            for (let i = parts.length - 1; i >= 0; i--) {
-                if (parts[i]?._subagentId === subagentId)
-                    return i + 1;
-            }
-            return parts.length;
-        };
-        const findHeaderIndex = () => {
-            for (let i = parts.length - 1; i >= 0; i--) {
-                if (parts[i]?.type === "info" &&
-                    parts[i]?._subagent === "header" &&
-                    parts[i]?._subagentId === subagentId) {
-                    return i;
-                }
-            }
-            return -1;
-        };
-        const removeInfoParts = (infoKind) => {
-            let removed = false;
-            for (let i = parts.length - 1; i >= 0; i--) {
-                if (parts[i]?.type === "info" &&
-                    parts[i]?._subagent === infoKind &&
-                    parts[i]?._subagentId === subagentId) {
-                    parts.splice(i, 1);
-                    removed = true;
-                }
-            }
-            return removed;
-        };
-        if (input.kind === "header") {
-            const headerIndex = findHeaderIndex();
-            const metaFields = {
-                ...(metaTurnId ? { _subagentTurnId: metaTurnId } : {}),
-                ...(metaStream ? { _subagentStream: metaStream } : {}),
-            };
-            if (headerIndex >= 0) {
-                if (sameInfo(parts[headerIndex], "header"))
-                    return false;
-                parts[headerIndex] = {
-                    ...parts[headerIndex],
-                    type: "info",
-                    text: t,
-                    _subagent: "header",
-                    _subagentId: subagentId,
-                    ...metaFields,
-                };
-            }
-            else {
-                parts.push({
-                    type: "info",
-                    text: t,
-                    _subagent: "header",
-                    _subagentId: subagentId,
-                    ...metaFields,
-                });
-            }
-            return true;
-        }
-        if (input.kind === "activity") {
-            // Replace this subagent's own activity part (scoped by _subagentId so
-            // multiple concurrent/sequential tasks don't overwrite each other).
-            for (let i = parts.length - 1; i >= 0; i--) {
-                if (parts[i].type === "info" &&
-                    parts[i]._subagent === "activity" &&
-                    parts[i]._subagentId === subagentId) {
-                    if (sameInfo(parts[i], "activity"))
-                        return false;
-                    parts[i] = {
-                        type: "info",
-                        text: t,
-                        _subagent: "activity",
-                        _subagentId: subagentId,
-                        ...(metaTurnId ? { _subagentTurnId: metaTurnId } : {}),
-                        ...(metaStream ? { _subagentStream: metaStream } : {}),
-                    };
-                    return true;
-                }
-            }
-            const idx = findInsertAfter();
-            parts.splice(idx, 0, {
-                type: "info",
-                text: t,
-                _subagent: "activity",
-                _subagentId: subagentId,
-                ...(metaTurnId ? { _subagentTurnId: metaTurnId } : {}),
-                ...(metaStream ? { _subagentStream: metaStream } : {}),
-            });
-            return true;
-        }
-        // Once the subagent completes, collapse the live detail back down to
-        // the header line and keep the terminal state on that header.
-        const removedActivity = removeInfoParts("activity");
-        const removedFinished = removeInfoParts("finished");
-        const headerIndex = findHeaderIndex();
-        if (headerIndex >= 0) {
-            const header = parts[headerIndex];
-            if (!removedActivity && !removedFinished && header?._subagentState === t)
-                return false;
-            parts[headerIndex] = {
-                ...header,
-                _subagentState: t,
-            };
-            return true;
-        }
-        parts.push({
-            type: "info",
-            text: subagentId,
-            _subagent: "header",
-            _subagentId: subagentId,
-            _subagentState: t,
-        });
-        return true;
-    }
-    /**
-     * Upsert subagent activity info parts.
-     * - `header`: appends a new header line for the task
-     * - `activity`: replaces the last subagent activity line (ticker during run)
-     * - `finished`: appends/replaces a finished line WITHOUT removing the last activity
-     *   so the final display shows: ⎿ last_tool  →  ⎿ done
-     */
-    function upsertSubagentInfo(assistantId, subagentId, kind, text, meta) {
-        upsertSubagentInfoBatch(assistantId, [{ subagentId, kind, text, meta }]);
-    }
-    function upsertSubagentInfoBatch(assistantId, items) {
-        if (!items.length)
-            return;
-        updateAssistant(assistantId, (m) => {
-            const parts = getRuntimeParts(m);
-            let changed = false;
-            for (const item of items) {
-                if (applySubagentInfoToParts(parts, item))
-                    changed = true;
-            }
-            return changed ? { ...m, parts: m.parts } : m;
-        });
-    }
-    function compactSettledSubagentTranscript(assistantId) {
-        updateAssistant(assistantId, (m) => {
-            const terminalSubagentIds = new Set();
-            for (const part of getRuntimeParts(m)) {
-                if (part?.type === "info" &&
-                    part?._subagent === "header" &&
-                    String(part?._subagentId ?? "").trim() &&
-                    String(part?._subagentState ?? "").trim()) {
-                    terminalSubagentIds.add(String(part._subagentId).trim());
-                }
-            }
-            if (terminalSubagentIds.size === 0)
-                return m;
-            const nextParts = getRuntimeParts(m).filter((part) => {
-                const scopedSubagentId = getScopedSubagentId(part);
-                if (!scopedSubagentId || !terminalSubagentIds.has(scopedSubagentId))
-                    return true;
-                return part?.type === "info" && part?._subagent === "header";
-            });
-            return nextParts.length === m.parts.length ? m : { ...m, parts: nextParts };
-        });
-    }
-    function findSubagentInsertAfter(parts, subagentId) {
-        for (let i = parts.length - 1; i >= 0; i--) {
-            const part = parts[i];
-            if (part?._subagentId === subagentId)
-                return i + 1;
-            if (part?.type === "tool_call" && part.call.subagentId === subagentId)
-                return i + 1;
-            if (part?.type === "tool_output" && part.subagentId === subagentId)
-                return i + 1;
-            if (part?.type === "tool_result" && part.result.subagentId === subagentId)
-                return i + 1;
-        }
-        return parts.length;
-    }
-    function tickSubagentFrame(assistantId) {
-        void assistantId;
-        const frame = Number(state.ui?.subagentSpinnerFrame ?? 0);
-        if (state.ui)
-            state.ui.subagentSpinnerFrame = Number.isFinite(frame) ? Math.floor(frame) + 1 : 1;
-    }
-    function appendAssistantLlmMeta(assistantId, info) {
-        const durationMs = Number(info?.durationMs);
-        if (!Number.isFinite(durationMs) || durationMs < 0)
-            return;
-        const modelId = String(info?.modelId ?? "").trim() || undefined;
-        const toolCalls = Number(info?.toolCalls);
-        const tokensUsed = Number(info?.tokensUsed);
-        const changedFileDetails = (() => {
-            const raw = Array.isArray(info?.changedFileDetails) ? info.changedFileDetails : [];
-            if (raw.length === 0)
-                return [];
-            const out = [];
-            const seen = new Set();
-            for (const item of raw) {
-                const path = String(item?.path ?? "").trim();
-                if (!path || seen.has(path))
-                    continue;
-                seen.add(path);
-                const added = Number(item?.added);
-                const removed = Number(item?.removed);
-                out.push({
-                    path,
-                    ...(Number.isFinite(added) && added >= 0 ? { added: Math.floor(added) } : {}),
-                    ...(Number.isFinite(removed) && removed >= 0 ? { removed: Math.floor(removed) } : {}),
-                });
-            }
-            return out;
-        })();
-        const changedFiles = (() => {
-            const raw = Array.isArray(info?.changedFiles) ? info.changedFiles : [];
-            const source = raw.length > 0 ? raw : changedFileDetails.map((item) => item.path);
-            if (source.length === 0)
-                return [];
-            const out = [];
-            const seen = new Set();
-            for (const item of source) {
-                const file = String(item ?? "").trim();
-                if (!file)
-                    continue;
-                if (seen.has(file))
-                    continue;
-                seen.add(file);
-                out.push(file);
-            }
-            return out;
-        })();
-        const hasToolCalls = Number.isFinite(toolCalls) && toolCalls >= 0;
-        const hasTokensUsed = Number.isFinite(tokensUsed) && tokensUsed >= 0;
-        const hasChangedFiles = changedFiles.length > 0;
-        const hasChangedFileDetails = changedFileDetails.length > 0;
-        updateAssistant(assistantId, (m) => {
-            if (!info?.isFinalRound) {
-                // Suppress meta on tool-only rounds to avoid confusing mid-run summaries.
-                let lastToolCallIndex = -1;
-                for (let i = 0; i < m.parts.length; i++) {
-                    if (m.parts[i]?.type === "tool_call")
-                        lastToolCallIndex = i;
-                }
-                if (lastToolCallIndex >= 0) {
-                    let hasUserFacingAfterToolCall = false;
-                    for (let i = lastToolCallIndex + 1; i < m.parts.length; i++) {
-                        const part = m.parts[i];
-                        if (!part)
-                            continue;
-                        if (part.type === "markdown" && String(part.markdown ?? "").trim()) {
-                            hasUserFacingAfterToolCall = true;
-                            break;
-                        }
-                        if (part.type === "todo" || part.type === "plan" || part.type === "approve") {
-                            hasUserFacingAfterToolCall = true;
-                            break;
-                        }
-                    }
-                    if (!hasUserFacingAfterToolCall)
-                        return m;
-                }
-            }
-            const parts = m.parts.slice();
-            parts.push({
-                type: "llm_meta",
-                durationMs,
-                ...(modelId ? { modelId } : {}),
-                ...(hasToolCalls ? { toolCalls: Math.floor(toolCalls) } : {}),
-                ...(hasTokensUsed ? { tokensUsed: Math.floor(tokensUsed) } : {}),
-                ...(hasChangedFiles ? { changedFiles } : {}),
-                ...(hasChangedFileDetails ? { changedFileDetails } : {}),
-            });
-            return { ...m, parts };
-        });
-    }
-    function updateAssistantLlmMeta(assistantId, info) {
-        const durationMs = Number(info?.durationMs);
-        const modelId = String(info?.modelId ?? "").trim() || undefined;
-        const toolCalls = Number(info?.toolCalls);
-        const tokensUsed = Number(info?.tokensUsed);
-        const changedFileDetails = (() => {
-            const raw = Array.isArray(info?.changedFileDetails) ? info.changedFileDetails : null;
-            if (!raw)
-                return null;
-            const out = [];
-            const seen = new Set();
-            for (const item of raw) {
-                const path = String(item?.path ?? "").trim();
-                if (!path || seen.has(path))
-                    continue;
-                seen.add(path);
-                const added = Number(item?.added);
-                const removed = Number(item?.removed);
-                out.push({
-                    path,
-                    ...(Number.isFinite(added) && added >= 0 ? { added: Math.floor(added) } : {}),
-                    ...(Number.isFinite(removed) && removed >= 0 ? { removed: Math.floor(removed) } : {}),
-                });
-            }
-            return out;
-        })();
-        const changedFiles = (() => {
-            const raw = Array.isArray(info?.changedFiles) ? info.changedFiles : null;
-            if (!raw) {
-                if (!Array.isArray(changedFileDetails))
-                    return null;
-                return changedFileDetails.map((item) => item.path);
-            }
-            if (!raw)
-                return null;
-            const out = [];
-            const seen = new Set();
-            for (const item of raw) {
-                const file = String(item ?? "").trim();
-                if (!file)
-                    continue;
-                if (seen.has(file))
-                    continue;
-                seen.add(file);
-                out.push(file);
-            }
-            return out;
-        })();
-        updateAssistant(assistantId, (m) => {
-            const parts = m.parts.slice();
-            for (let i = parts.length - 1; i >= 0; i--) {
-                const p = parts[i];
-                if (p.type !== "llm_meta")
-                    continue;
-                const next = { ...p };
-                let changed = false;
-                if (Number.isFinite(durationMs) && durationMs >= 0) {
-                    next.durationMs = durationMs;
-                    changed = true;
-                }
-                if (modelId) {
-                    next.modelId = modelId;
-                    changed = true;
-                }
-                if (Number.isFinite(toolCalls) && toolCalls >= 0) {
-                    next.toolCalls = Math.floor(toolCalls);
-                    changed = true;
-                }
-                if (Number.isFinite(tokensUsed) && tokensUsed >= 0) {
-                    next.tokensUsed = Math.floor(tokensUsed);
-                    changed = true;
-                }
-                if (Array.isArray(changedFiles)) {
-                    if (changedFiles.length > 0)
-                        next.changedFiles = changedFiles;
-                    else
-                        delete next.changedFiles;
-                    changed = true;
-                }
-                if (Array.isArray(changedFileDetails)) {
-                    if (changedFileDetails.length > 0)
-                        next.changedFileDetails = changedFileDetails;
-                    else
-                        delete next.changedFileDetails;
-                    changed = true;
-                }
-                if (!changed)
-                    return m;
-                parts[i] = next;
-                return { ...m, parts };
-            }
-            return m;
-        });
-    }
-    function upsertToolCallDelta(assistantId, callId, toolName, argsTextDelta, linesWritten, meta) {
-        const idRaw = String(callId ?? "").trim();
-        if (!idRaw)
-            return;
-        const name = String(toolName ?? "").trim() || "tool";
-        const shouldTrackStartedAt = /^shell$/i.test(name);
-        const delta = String(argsTextDelta ?? "");
-        const subagentId = String(meta?.subagentId ?? "").trim() || undefined;
-        const subagentTurnId = String(meta?.subagentTurnId ?? "").trim() || undefined;
-        const t0 = perfStreamEnabled ? Date.now() : 0;
-        updateAssistant(assistantId, (m) => {
-            // Streaming optimization: mutate in-place to avoid allocating a new parts array per tool chunk.
-            const parts = getRuntimeParts(m);
-            let idx = -1;
-            for (let i = parts.length - 1; i >= 0; i--) {
-                const p = parts[i];
-                if (p?.type === "tool_call" && p?.call?.id === idRaw) {
-                    idx = i;
-                    break;
-                }
-            }
-            if (idx >= 0) {
-                const p = parts[idx];
-                const prevTail = String(p.call.argumentsText ?? "");
-                const prevFullLen = Number(p.call.streamMeta?.argsTextFullLen ?? prevTail.length);
-                const nextFullLen = prevFullLen + delta.length;
-                const nextTailRaw = `${prevTail}${delta}`;
-                const nextTail = nextTailRaw.length > streamToolArgsTailLimit
-                    ? nextTailRaw.slice(-streamToolArgsTailLimit)
-                    : nextTailRaw;
-                const prevStartedAtMs = Number(p.call.startedAtMs ?? 0);
-                const metaStartedAtMs = Number(meta?.startedAtMs ?? 0);
-                const startedAtMs = shouldTrackStartedAt
-                    ? Number.isFinite(prevStartedAtMs) && prevStartedAtMs > 0
-                        ? prevStartedAtMs
-                        : Number.isFinite(metaStartedAtMs) && metaStartedAtMs > 0
-                            ? metaStartedAtMs
-                            : Date.now()
-                    : undefined;
-                const nextCall = {
-                    ...p.call,
-                    name,
-                    ...(subagentId ? { subagentId } : {}),
-                    ...(subagentTurnId ? { subagentTurnId } : {}),
-                    argumentsText: nextTail,
-                    streamMeta: {
-                        ...p.call.streamMeta,
-                        argsTextFullLen: nextFullLen,
-                        argsTextTailLimit: streamToolArgsTailLimit,
-                    },
-                    ...(typeof startedAtMs === "number" ? { startedAtMs } : null),
-                    ...(typeof linesWritten === "number" ? { linesWritten } : null),
-                };
-                parts[idx] = { type: "tool_call", call: nextCall };
-                return { ...m, parts: m.parts };
-            }
-            const firstTail = delta.length > streamToolArgsTailLimit ? delta.slice(-streamToolArgsTailLimit) : delta;
-            const call = {
-                id: idRaw,
-                name,
-                ...(subagentId ? { subagentId } : {}),
-                ...(subagentTurnId ? { subagentTurnId } : {}),
-                arguments: {},
-                argumentsText: firstTail,
-                streamMeta: {
-                    argsTextFullLen: delta.length,
-                    argsTextTailLimit: streamToolArgsTailLimit,
-                },
-                ...(shouldTrackStartedAt
-                    ? {
-                        startedAtMs: typeof meta?.startedAtMs === "number" && Number.isFinite(meta.startedAtMs)
-                            ? meta.startedAtMs
-                            : Date.now(),
-                    }
-                    : null),
-                ...(typeof linesWritten === "number" ? { linesWritten } : null),
-            };
-            const next = {
-                type: "tool_call",
-                call,
-                ...(subagentId ? { _subagentId: subagentId } : {}),
-            };
-            if (subagentId) {
-                const insertAt = findSubagentInsertAfter(parts, subagentId);
-                parts.splice(insertAt, 0, next);
-            }
-            else {
-                parts.push(next);
-            }
-            return { ...m, parts: m.parts };
-        });
-        if (perfStreamEnabled) {
-            const ms = Date.now() - t0;
-            const threshold = isOneShotEnabled() ? 5 : 40;
-            if (ms >= threshold) {
-                const now = Date.now();
-                if (isOneShotEnabled() || now - lastStreamSlowLogAt >= 800) {
-                    lastStreamSlowLogAt = now;
-                    perfLogStream(`[STREAM_TC] ${ms}ms callId=${idRaw} tool=${name} deltaChars=${delta.length}`);
-                }
-            }
-        }
-    }
-    function upsertToolCallEnd(assistantId, callId, toolName, args, thoughtSignature, meta) {
-        const idRaw = String(callId ?? "").trim();
-        if (!idRaw)
-            return;
-        const subagentId = String(meta?.subagentId ?? "").trim() || undefined;
-        const subagentTurnId = String(meta?.subagentTurnId ?? "").trim() || undefined;
-        const shouldTrackStartedAt = /^shell$/i.test(toolName);
-        updateAssistant(assistantId, (m) => {
-            const parts = m.parts.slice();
-            const idx = findToolCallPartIndex(parts, idRaw);
-            const prevCall = idx >= 0 && parts[idx]?.type === "tool_call" ? parts[idx].call : undefined;
-            const prevArgsText = prevCall?.argumentsText;
-            const nextThoughtSignature = thoughtSignature || prevCall?.thoughtSignature;
-            const prevStartedAtMs = typeof prevCall?.startedAtMs === "number" && Number.isFinite(prevCall.startedAtMs)
-                ? prevCall.startedAtMs
-                : undefined;
-            const metaStartedAtMs = typeof meta?.startedAtMs === "number" && Number.isFinite(meta.startedAtMs)
-                ? meta.startedAtMs
-                : undefined;
-            const prevLinesWritten = typeof prevCall?.linesWritten === "number" ? prevCall.linesWritten : undefined;
-            const call = {
-                id: idRaw,
-                name: toolName,
-                ...(subagentId ? { subagentId } : {}),
-                ...(subagentTurnId ? { subagentTurnId } : {}),
-                arguments: args,
-                argumentsText: prevArgsText,
-                ...(shouldTrackStartedAt
-                    ? typeof prevStartedAtMs === "number"
-                        ? { startedAtMs: prevStartedAtMs }
-                        : typeof metaStartedAtMs === "number"
-                            ? { startedAtMs: metaStartedAtMs }
-                            : null
-                    : null),
-                ...(nextThoughtSignature ? { thoughtSignature: nextThoughtSignature } : {}),
-                ...(typeof prevLinesWritten === "number" ? { linesWritten: prevLinesWritten } : null),
-            };
-            const nextPart = {
-                type: "tool_call",
-                call,
-                ...(subagentId ? { _subagentId: subagentId } : {}),
-            };
-            if (idx >= 0)
-                parts[idx] = nextPart;
-            else if (subagentId) {
-                const insertAt = findSubagentInsertAfter(parts, subagentId);
-                parts.splice(insertAt, 0, nextPart);
-            }
-            else
-                parts.push(nextPart);
-            return { ...m, parts };
-        });
-    }
-    function upsertToolOutputStart(assistantId, toolCallId, toolName, meta) {
-        const idRaw = String(toolCallId ?? "").trim();
-        if (!idRaw)
-            return;
-        const name = String(toolName ?? "").trim() || "tool";
-        const subagentId = String(meta?.subagentId ?? "").trim() || undefined;
-        const isExplore = name.toLowerCase() === "task";
-        const tailLimit = isExplore
-            ? Math.max(streamToolOutputTailLimit, 200_000)
-            : streamToolOutputTailLimit;
-        const tailLinesLimit = isExplore
-            ? Math.max(streamToolOutputTailLinesLimit, 10_000)
-            : streamToolOutputTailLinesLimit;
-        updateAssistant(assistantId, (m) => {
-            const parts = getRuntimeParts(m);
-            const idx = findToolOutputPartIndex(parts, idRaw);
-            if (idx >= 0) {
-                const prev = parts[idx];
-                if (prev?.type !== "tool_output")
-                    return { ...m, parts: m.parts };
-                parts[idx] = {
-                    ...prev,
-                    type: "tool_output",
-                    toolCallId: idRaw,
-                    toolName: prev.toolName || name,
-                    ...(subagentId ? { subagentId } : {}),
-                    streamMeta: {
-                        ...prev.streamMeta,
-                        tailLimit,
-                        tailLinesLimit,
-                    },
-                };
-                return { ...m, parts: m.parts };
-            }
-            const next = {
-                type: "tool_output",
-                toolCallId: idRaw,
-                toolName: name,
-                output: "",
-                ...(subagentId ? { subagentId, _subagentId: subagentId } : {}),
-                streamMeta: {
-                    fullLen: 0,
-                    lineBreaks: 0,
-                    tailLines: [""],
-                    tailLimit,
-                    tailLinesLimit,
-                },
-            };
-            const callIdx = findToolCallPartIndex(parts, idRaw);
-            if (callIdx >= 0) {
-                let insertAt = callIdx + 1;
-                while (insertAt < parts.length && isApprovalForToolCall(parts[insertAt], idRaw)) {
-                    insertAt++;
-                }
-                parts.splice(insertAt, 0, next);
-            }
-            else if (subagentId) {
-                const insertAt = findSubagentInsertAfter(parts, subagentId);
-                parts.splice(insertAt, 0, next);
-            }
-            else {
-                parts.push(next);
-            }
-            return { ...m, parts: m.parts };
-        });
-    }
-    function appendToolOutputDelta(assistantId, toolCallId, toolName, delta, meta) {
-        const idRaw = String(toolCallId ?? "").trim();
-        if (!idRaw)
-            return;
-        const d = String(delta ?? "").replace(/\r/g, "");
-        if (!d)
-            return;
-        const name = String(toolName ?? "").trim() || "tool";
-        const subagentId = String(meta?.subagentId ?? "").trim() || undefined;
-        const isExplore = name.toLowerCase() === "task";
-        const t0 = perfStreamEnabled ? Date.now() : 0;
-        updateAssistant(assistantId, (m) => {
-            // Streaming optimization: mutate in-place to avoid allocating a new parts array per chunk.
-            const parts = getRuntimeParts(m);
-            const idx = findToolOutputPartIndex(parts, idRaw);
-            if (idx >= 0) {
-                const prev = parts[idx];
-                if (prev?.type !== "tool_output")
-                    return { ...m, parts: m.parts };
-                const prevTail = String(prev.output ?? "");
-                const tailLimit = (() => {
-                    const v = Number(prev.streamMeta?.tailLimit);
-                    if (Number.isFinite(v) && v > 0)
-                        return Math.floor(v);
-                    return isExplore
-                        ? Math.max(streamToolOutputTailLimit, 200_000)
-                        : streamToolOutputTailLimit;
-                })();
-                const tailLinesLimit = (() => {
-                    const v = Number(prev.streamMeta?.tailLinesLimit);
-                    if (Number.isFinite(v) && v > 0)
-                        return Math.floor(v);
-                    return isExplore
-                        ? Math.max(streamToolOutputTailLinesLimit, 10_000)
-                        : streamToolOutputTailLinesLimit;
-                })();
-                const nextTailRaw = `${prevTail}${d}`;
-                const nextTail = nextTailRaw.length > tailLimit ? nextTailRaw.slice(-tailLimit) : nextTailRaw;
-                const prevFullLen = Number(prev.streamMeta?.fullLen ?? prevTail.length);
-                const prevLineBreaks = Number(prev.streamMeta?.lineBreaks ?? countNewlines(prevTail));
-                const nextFullLen = prevFullLen + d.length;
-                const nextLineBreaks = prevLineBreaks + countNewlines(d);
-                const prevTailLines = Array.isArray(prev.streamMeta?.tailLines)
-                    ? prev.streamMeta.tailLines
-                    : computeTailLinesFromTailText(prevTail, tailLinesLimit);
-                const nextTailLines = appendTailLines(prevTailLines, d, tailLinesLimit, nextTail.length);
-                parts[idx] = {
-                    ...prev,
-                    type: "tool_output",
-                    toolCallId: idRaw,
-                    toolName: prev.toolName || name,
-                    ...(subagentId ? { subagentId } : {}),
-                    output: nextTail,
-                    streamMeta: {
-                        fullLen: nextFullLen,
-                        lineBreaks: nextLineBreaks,
-                        tailLines: nextTailLines,
-                        tailLimit,
-                        tailLinesLimit,
-                    },
-                };
-                return { ...m, parts: m.parts };
-            }
-            const tailLimit = isExplore
-                ? Math.max(streamToolOutputTailLimit, 200_000)
-                : streamToolOutputTailLimit;
-            const tailLinesLimit = isExplore
-                ? Math.max(streamToolOutputTailLinesLimit, 10_000)
-                : streamToolOutputTailLinesLimit;
-            const firstTail = d.length > tailLimit ? d.slice(-tailLimit) : d;
-            const firstTailLines = computeTailLinesFromTailText(firstTail, tailLinesLimit);
-            const next = {
-                type: "tool_output",
-                toolCallId: idRaw,
-                toolName: name,
-                output: firstTail,
-                ...(subagentId ? { subagentId, _subagentId: subagentId } : {}),
-                streamMeta: {
-                    fullLen: d.length,
-                    lineBreaks: countNewlines(d),
-                    tailLines: firstTailLines,
-                    tailLimit,
-                    tailLinesLimit,
-                },
-            };
-            const callIdx = findToolCallPartIndex(parts, idRaw);
-            if (callIdx >= 0) {
-                let insertAt = callIdx + 1;
-                while (insertAt < parts.length && isApprovalForToolCall(parts[insertAt], idRaw)) {
-                    insertAt++;
-                }
-                parts.splice(insertAt, 0, next);
-            }
-            else if (subagentId) {
-                const insertAt = findSubagentInsertAfter(parts, subagentId);
-                parts.splice(insertAt, 0, next);
-            }
-            else {
-                parts.push(next);
-            }
-            return { ...m, parts: m.parts };
-        });
-        if (perfStreamEnabled) {
-            const ms = Date.now() - t0;
-            const threshold = isOneShotEnabled() ? 5 : 40;
-            if (ms >= threshold) {
-                const now = Date.now();
-                if (isOneShotEnabled() || now - lastStreamSlowLogAt >= 800) {
-                    lastStreamSlowLogAt = now;
-                    perfLogStream(`[STREAM_TO] ${ms}ms callId=${idRaw} tool=${name} deltaChars=${d.length}`);
-                }
-            }
-        }
-    }
-    function attachToolResultPart(assistantId, result, meta) {
-        const callId = String(result.toolCallId ?? "").trim();
-        if (!callId)
-            return;
-        const subagentId = String(meta?.subagentId ?? result.subagentId ?? "").trim() || undefined;
-        const subagentTurnId = String(meta?.subagentTurnId ??
-            result.subagentTurnId ??
-            "").trim() || undefined;
-        const nextResult = subagentId || subagentTurnId
-            ? {
-                ...result,
-                ...(subagentId ? { subagentId } : {}),
-                ...(subagentTurnId ? { subagentTurnId } : {}),
-            }
-            : result;
-        updateAssistant(assistantId, (m) => {
-            const parts = m.parts.slice();
-            const callIdx = findToolCallPartIndex(parts, callId);
-            const withoutPrev = parts.filter((p) => !(p.type === "tool_result" && p.result.toolCallId === callId));
-            const rebuilt = withoutPrev.slice();
-            if (callIdx >= 0) {
-                const rebuiltCallIdx = findToolCallPartIndex(rebuilt, callId);
-                if (rebuiltCallIdx >= 0) {
-                    let insertAt = rebuiltCallIdx + 1;
-                    while (insertAt < rebuilt.length && isApprovalForToolCall(rebuilt[insertAt], callId)) {
-                        insertAt++;
-                    }
-                    while (insertAt < rebuilt.length && isToolOutputForCall(rebuilt[insertAt], callId))
-                        insertAt++;
-                    rebuilt.splice(insertAt, 0, {
-                        type: "tool_result",
-                        result: nextResult,
-                        ...(subagentId ? { _subagentId: subagentId } : {}),
-                    });
-                }
-                else {
-                    rebuilt.push({
-                        type: "tool_result",
-                        result: nextResult,
-                        ...(subagentId ? { _subagentId: subagentId } : {}),
-                    });
-                }
-            }
-            else if (subagentId) {
-                const insertAt = findSubagentInsertAfter(rebuilt, subagentId);
-                rebuilt.splice(insertAt, 0, {
-                    type: "tool_result",
-                    result: nextResult,
-                    _subagentId: subagentId,
-                });
-            }
-            else {
-                rebuilt.push({ type: "tool_result", result });
-            }
-            return { ...m, parts: rebuilt };
-        });
-    }
-    function insertApprovalPart(assistantId, request) {
-        updateAssistant(assistantId, (m) => {
-            const has = m.parts.some((p) => p.type === "approve" &&
-                p.request.toolCallId === request.toolCallId &&
-                p.request.status === "pending");
-            if (has)
-                return m;
-            const parts = m.parts.slice();
-            const callIdx = parts.findIndex((p) => p.type === "tool_call" && p.call.id === request.toolCallId);
-            if (callIdx >= 0)
-                parts.splice(callIdx + 1, 0, { type: "approve", request });
-            else if (request.subagentId) {
-                const insertAt = findSubagentInsertAfter(parts, request.subagentId);
-                parts.splice(insertAt, 0, { type: "approve", request });
-            }
-            else
-                parts.push({ type: "approve", request });
-            return { ...m, parts };
-        });
-    }
-    function toggleChecklist(messageId, partType, itemId) {
-        const msg = messageById(messageId);
-        if (!msg || msg.role !== "assistant")
-            return;
-        // Tool-derived TodoWrite checklists are read-only in the transcript UI.
-        // (They reflect the tool result and should not be mutated by user clicks.)
-        if (partType === "todo") {
-            const block = msg.parts.find((p) => p.type === "todo" && p.items.some((it) => it.id === itemId));
-            const callId = String(block?.toolCallId ?? "").trim();
-            if (callId) {
-                const toolCall = msg.parts.find((p) => p.type === "tool_call" && p.call.id === callId);
-                const name = String(toolCall?.call?.name ?? "")
-                    .trim()
-                    .toLowerCase();
-                if (!name || name === "todowrite")
-                    return;
-            }
-        }
-        const parts = msg.parts.map((p) => {
-            if (p.type !== partType)
-                return p;
-            return {
-                ...p,
-                items: p.items.map((it) => {
-                    if (it.id !== itemId)
-                        return it;
-                    const done = !it.done;
-                    return { ...it, done, status: done ? "completed" : "pending" };
-                }),
-            };
-        });
-        replaceMessage(messageId, { ...msg, parts });
-    }
-    function toggleBlockCollapsed(messageId, partType, partId) {
-        const normalizedPartId = String(partId ?? "").trim();
-        if (!normalizedPartId)
-            return;
-        const msg = messageById(messageId);
-        if (!msg || msg.role !== "assistant")
-            return;
-        const parts = msg.parts.map((p) => {
-            if (p.type !== partType)
-                return p;
-            if (String(p.partId ?? "").trim() !== normalizedPartId)
-                return p;
-            return { ...p, collapsed: !p.collapsed };
-        });
-        replaceMessage(messageId, { ...msg, parts });
-    }
-    function revertFromMessage(messageId) {
-        const idx = messageIndex(messageId);
-        if (idx < 0)
-            return 0;
-        const removed = state.messages.splice(idx);
-        messageIndexById = null;
-        state.revertedMessages = removed;
-        setSessionHistoryDirty(true);
-        rebuildUserHistory();
-        hooks.onMessagesRemoved?.(removed);
-        return removed.length;
-    }
-    function restoreRevertedMessages() {
-        if (state.revertedMessages.length === 0)
-            return 0;
-        const count = state.revertedMessages.length;
-        const restored = state.revertedMessages.slice();
-        state.messages.push(...restored);
-        messageIndexById = null;
-        state.revertedMessages = [];
-        // A full restore brings the transcript back to its pre-revert shape.
-        setSessionHistoryDirty(false);
-        rebuildUserHistory();
-        hooks.onMessagesRestored?.(restored);
-        return count;
-    }
-    function clearRevertedMessages() {
-        state.revertedMessages = [];
-    }
-    const hasRevertedMessages = computed(() => state.revertedMessages.length > 0);
-    const revertedMessageCount = computed(() => state.revertedMessages.length);
-    function upsertChecklistPartFromDimSdk(assistantId, kind, toolCallId, structured) {
-        const todos = isRecord(structured) ? structured.todos : undefined;
-        if (!Array.isArray(todos))
-            return;
-        const items = todos
-            .filter(isRecord)
-            .map((todo, i) => {
-            const rawContent = todo.content;
-            const rawStatus = String(todo.status ?? "").trim() || "pending";
-            const text = String(rawContent ?? "").trim();
-            const status = rawStatus === "completed" || rawStatus === "in_progress" || rawStatus === "pending"
-                ? rawStatus
-                : rawStatus;
-            return {
-                id: `${toolCallId}:${i}`,
-                text,
-                done: status === "completed",
-                status,
-            };
-        })
-            .filter((item) => Boolean(item.text));
-        if (items.length === 0)
-            return;
-        const title = kind === "plan" ? t("chatParts.plan") : t("chatParts.todo");
-        const partId = createChecklistPartId(kind, toolCallId);
-        updateAssistant(assistantId, (m) => {
-            const parts = getRuntimeParts(m).slice();
-            const idx = parts.findIndex((p) => isChecklistPartOfKind(p, kind) && String(p.partId ?? "").trim() === partId);
-            if (idx >= 0) {
-                const prev = parts[idx];
-                const collapsed = isChecklistPartOfKind(prev, kind) ? Boolean(prev.collapsed) : false;
-                parts[idx] = createChecklistPart(kind, {
-                    collapsed,
-                    items,
-                    partId,
-                    title,
-                    toolCallId,
-                });
-                return { ...m, parts };
-            }
-            const nextPart = createChecklistPart(kind, {
-                collapsed: false,
-                items,
-                partId,
-                title,
-                toolCallId,
-            });
-            const callIdx = parts.findIndex((p) => p?.type === "tool_call" && p.call.id === toolCallId);
-            if (callIdx >= 0) {
-                let insertAt = callIdx + 1;
-                while (insertAt < parts.length && isApprovalForToolCall(parts[insertAt], toolCallId)) {
-                    insertAt++;
-                }
-                while (insertAt < parts.length && isToolOutputForCall(parts[insertAt], toolCallId))
-                    insertAt++;
-                while (insertAt < parts.length && isToolResultForCall(parts[insertAt], toolCallId))
-                    insertAt++;
-                parts.splice(insertAt, 0, nextPart);
-                return { ...m, parts };
-            }
-            parts.push(nextPart);
-            return { ...m, parts };
-        });
-    }
-    // Ensure history is correct if messages were preloaded (e.g. resumed session).
-    rebuildUserHistory();
-    return {
-        pushMessage,
-        setSessionHistoryDirty,
-        replaceMessage,
-        updateAssistant,
-        updateAssistantHidden,
-        setAssistantStatus,
-        setAssistantThinking,
-        startNewThinkingBlock,
-        endThinkingBlock,
-        appendAssistantMarkdown,
-        appendInfoPart,
-        upsertSubagentInfo,
-        upsertSubagentInfoBatch,
-        compactSettledSubagentTranscript,
-        tickSubagentFrame,
-        appendAssistantLlmMeta,
-        updateAssistantLlmMeta,
-        upsertToolCallDelta,
-        upsertToolCallEnd,
-        upsertToolOutputStart,
-        appendToolOutputDelta,
-        attachToolResultPart,
-        insertApprovalPart,
-        toggleChecklist,
-        toggleBlockCollapsed,
-        revertFromMessage,
-        restoreRevertedMessages,
-        clearRevertedMessages,
-        rebuildUserHistory,
-        hasRevertedMessages,
-        revertedMessageCount,
-        upsertChecklistPartFromDimSdk,
-    };
-}
-//# sourceMappingURL=message-mutations.js.map