@apolloyh/apollo-agent 0.1.0

package/dist/trace.js

@@ -0,0 +1,600 @@
+import { stderr } from "node:process";
+import { formatWaitLine } from "./status-ui.js";
+const color = {
+    reset: "\x1b[0m",
+    normal: "",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+    cyan: "\x1b[36m",
+    blue: "\x1b[38;2;96;165;250m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    magenta: "\x1b[35m",
+    gray: "\x1b[90m",
+};
+export class CliTraceRenderer {
+    options;
+    spinner;
+    spinnerIndex = 0;
+    statusText = "";
+    statusDetail = "";
+    statusLines = 0;
+    statusStartedAt = 0;
+    wroteAssistantText = false;
+    thoughtStartedAt = 0;
+    turnStartedAt = 0;
+    hasPrintedTurn = false;
+    turnSpacingPrinted = false;
+    staticStatusActive = false;
+    assistantLineBuffer = "";
+    insideCodeFence = false;
+    activeTasks = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    sink() {
+        return (event) => this.render(event);
+    }
+    resetTurn() {
+        this.stopStatus();
+        this.wroteAssistantText = false;
+        this.turnSpacingPrinted = false;
+        this.statusDetail = "";
+        this.staticStatusActive = false;
+        this.assistantLineBuffer = "";
+        this.insideCodeFence = false;
+        this.thoughtStartedAt = 0;
+        this.turnStartedAt = Date.now();
+        this.activeTasks.clear();
+    }
+    finishTurn() {
+        this.stopStatus();
+        this.flushAssistantLine(false);
+        if (this.wroteAssistantText) {
+            this.out("\n");
+            this.wroteAssistantText = false;
+        }
+        if (this.options.verbose && this.turnStartedAt) {
+            this.bullet(`Done · ${this.elapsedSince(this.turnStartedAt)}`, "green");
+            this.out("\n");
+        }
+        this.hasPrintedTurn = true;
+        this.activeTasks.clear();
+    }
+    render(event) {
+        // Quiet mode: stream answers, flush before tools, and show concise results.
+        if (!this.options.verbose &&
+            event.type !== "assistant_delta" &&
+            event.type !== "llm_retry" &&
+            event.type !== "llm_tool_delta" &&
+            event.type !== "tool_call" &&
+            event.type !== "tool_result" &&
+            event.type !== "context_compacted" &&
+            event.type !== "context_compaction_failed")
+            return;
+        switch (event.type) {
+            case "llm_retry":
+                this.completeStatus(undefined, "yellow", Boolean(this.options.staticStatus));
+                this.bullet(`${retryLabel(event.mode, event.delayMs)} · ${compactValue(event.reason, 160)}`, "yellow");
+                break;
+            case "assistant_delta":
+                if (this.statusText === "thinking" && !this.statusDetail) {
+                    this.statusDetail = "receiving direct answer";
+                }
+                // Interactive: index.ts already printed ● Thought — clear silently
+                this.completeStatus(undefined, "green", Boolean(this.options.staticStatus));
+                if (this.options.stream) {
+                    if (this.options.verbose)
+                        this.ensureTurnSpacing();
+                    this.writeAssistantDelta(event.text);
+                    this.wroteAssistantText = true;
+                }
+                break;
+            case "llm_request":
+                if (this.options.verbose)
+                    this.ensureTurnSpacing();
+                this.thoughtStartedAt = Date.now();
+                this.startStatus("thinking");
+                break;
+            case "llm_tool_delta":
+                if (this.options.staticStatus) {
+                    this.flushAssistantLine(true);
+                    break;
+                }
+                if (this.statusText !== "thinking")
+                    this.startStatus("thinking");
+                this.statusDetail = `preparing ${event.tool ?? "tool"} input (${formatBytes(event.bytes)})`;
+                break;
+            case "llm_response":
+                if (this.statusText === "thinking") {
+                    this.statusDetail = thoughtDetail(event.stopReason);
+                }
+                this.completeStatus(undefined, "green", Boolean(this.options.staticStatus));
+                if (!this.options.stream && event.text) {
+                    if (this.options.verbose)
+                        this.ensureTurnSpacing();
+                    this.writeAssistantDelta(event.text);
+                    this.flushAssistantLine(true);
+                }
+                break;
+            case "tool_call":
+                this.flushAssistantLine(true);
+                if (event.tool === "Task") {
+                    this.completeStatus(undefined, "green", Boolean(this.options.staticStatus));
+                    break;
+                }
+                this.completeStatus(undefined, "green", Boolean(this.options.staticStatus));
+                // Tool wait line is owned by index live status in interactive mode
+                if (this.options.staticStatus)
+                    break;
+                this.ensureTurnSpacing();
+                this.startStatus(`using ${event.tool}`, `${riskLabel(event.risk)} ${compactToolInput(event.tool, event.input, 160)}`);
+                break;
+            case "tool_result":
+                if (event.tool === "Task")
+                    break;
+                if (event.fileChange && !event.isError) {
+                    this.completeStatus(undefined, "green", true);
+                    this.renderFileChange(event.fileChange);
+                    break;
+                }
+                if (this.options.staticStatus) {
+                    const denied = isPermissionDenied(event.content);
+                    this.renderInteractiveToolResult(event, denied);
+                    break;
+                }
+                this.completeStatus(event.isError ? `${event.tool} failed ${compactValue(event.content, 240)}` : `${event.tool} done`, event.isError ? "normal" : "green");
+                break;
+            case "approval_required":
+                this.completeStatus(undefined, "green", Boolean(this.options.staticStatus));
+                break;
+            case "approval_result":
+                this.bullet(`${event.tool}: ${event.approved ? "approved" : "denied"}`, event.approved ? "green" : "normal");
+                break;
+            case "context_compacted":
+                this.bullet(`context compacted ${event.beforeChars} → ${event.afterChars} chars`, "green");
+                break;
+            case "context_compaction_failed":
+                this.bullet(`context compaction failed · ${compactValue(event.reason, 200)}`, "red");
+                break;
+            case "context_compaction_start":
+                break;
+            case "task_start": {
+                this.completeStatus(undefined, "green", Boolean(this.options.staticStatus));
+                this.ensureTurnSpacing();
+                this.activeTasks.set(event.id, {
+                    subagentType: event.subagentType,
+                    description: event.description,
+                });
+                this.bullet(`Task(${event.subagentType}): ${event.description}`, "blue");
+                break;
+            }
+            case "task_progress":
+                break;
+            case "task_finish": {
+                this.completeStatus(undefined, "green", Boolean(this.options.staticStatus));
+                this.activeTasks.delete(event.id);
+                const secs = (event.durationMs / 1000).toFixed(1);
+                this.subBullet(`finished · ${secs}s`, "gray");
+                break;
+            }
+        }
+    }
+    startStatus(text, detail = "") {
+        this.statusText = text;
+        this.statusDetail = detail;
+        this.statusStartedAt = Date.now();
+        if (this.options.staticStatus) {
+            this.staticStatusActive = true;
+            return;
+        }
+        if (!this.options.status || !this.options.stderr?.isTTY || this.options.suspendLiveStatus?.())
+            return;
+        this.spinnerIndex = 0;
+        this.spinner ??= setInterval(() => this.renderStatus(), 160);
+        this.renderStatus();
+    }
+    stopStatus() {
+        if (!this.spinner)
+            return;
+        clearInterval(this.spinner);
+        this.spinner = undefined;
+        if (this.options.stderr?.isTTY && this.statusLines > 0) {
+            this.clearStatusLines();
+        }
+        this.statusLines = 0;
+    }
+    /**
+     * @param silent When true, clear internal status without printing a bullet
+     *               (used in interactive mode where index.ts owns the outcome line).
+     */
+    completeStatus(text = undefined, colorName = "green", silent = false) {
+        const label = text ?? this.statusText;
+        const hadStatus = this.spinner !== undefined || this.statusLines > 0 || Boolean(this.statusText);
+        const detail = this.statusDetail;
+        const startedAt = this.statusStartedAt;
+        this.stopStatus();
+        this.statusText = "";
+        this.statusDetail = "";
+        this.staticStatusActive = false;
+        this.statusStartedAt = 0;
+        if (silent || !hadStatus || !label)
+            return;
+        const elapsed = startedAt ? ` ${this.elapsedSince(startedAt)}` : "";
+        this.bullet(`${formatCompletedStatusText(label)}${elapsed}`, colorName);
+        if (detail)
+            this.subBullet(detail, "gray");
+    }
+    /** Non-interactive: Claude Code–style morphing glyph + shimmer label. */
+    renderStatus() {
+        const frame = this.spinnerIndex;
+        this.spinnerIndex += 1;
+        const label = formatStatusText(this.statusText);
+        const elapsed = this.statusStartedAt ? this.elapsedSince(this.statusStartedAt) : this.elapsedThought();
+        const line = formatWaitLine({
+            frame,
+            label,
+            elapsed,
+            useColor: this.options.color,
+        });
+        this.out(`\r\x1b[2K${line}`);
+        this.statusLines = 1;
+    }
+    bullet(text, colorName) {
+        this.stopStatus();
+        this.flushAssistantLine(false);
+        if (this.wroteAssistantText) {
+            this.out("\n");
+            this.wroteAssistantText = false;
+        }
+        this.out(`${this.paint("•", colorName)} ${this.paint(text, colorName)}\n`);
+    }
+    subBullet(text, colorName) {
+        this.stopStatus();
+        this.flushAssistantLine(false);
+        if (this.wroteAssistantText) {
+            this.out("\n");
+            this.wroteAssistantText = false;
+        }
+        this.out(`  ${this.paint("└", colorName)} ${this.paint(text, colorName)}\n`);
+    }
+    renderFileChange(change) {
+        this.stopStatus();
+        this.flushAssistantLine(false);
+        if (this.wroteAssistantText) {
+            this.out("\n");
+            this.wroteAssistantText = false;
+        }
+        const path = stripTerminalEscapes(change.path);
+        const action = change.kind === "create" ? "Write" : "Update";
+        const added = `${change.added} ${change.added === 1 ? "line" : "lines"}`;
+        const removed = `${change.removed} ${change.removed === 1 ? "line" : "lines"}`;
+        const summary = change.kind === "create" ? `Added ${added}` : `Added ${added}, removed ${removed}`;
+        this.out(`${this.paint("●", "green")} ${this.paint(`${action}(${path})`, "bold")}\n`);
+        this.out(`  ${this.paint("└", "gray")} ${this.paint(summary, "gray")}\n`);
+        this.renderCodeChange(change);
+        if (change.omitted > 0) {
+            this.out(`  ${this.paint("└", "gray")} ${this.paint(`… +${change.omitted} lines`, "gray")}\n`);
+        }
+    }
+    renderInteractiveToolResult(event, denied) {
+        this.bullet(formatInteractiveToolResult(event.tool, event.content, event.isError, event.input), denied ? "yellow" : event.isError ? "red" : "green");
+        if (event.tool !== "shell_exec" || event.isError || event.content === "(no output)")
+            return;
+        const lines = stripTerminalEscapes(event.content).split(/\r?\n/);
+        for (const [index, line] of lines.slice(0, 6).entries()) {
+            this.out(`  ${this.paint(index === 0 ? "└" : " ", "gray")} ${this.paint(truncateDisplayLine(line, 140), "gray")}\n`);
+        }
+        if (lines.length > 6)
+            this.out(`    ${this.paint(`… +${lines.length - 6} lines`, "gray")}\n`);
+    }
+    renderCodeChange(change) {
+        const width = Math.max(40, Math.min(this.options.stdout?.columns ?? 120, 160));
+        let oldLine = 1;
+        let newLine = 1;
+        for (const rawLine of change.lines) {
+            const line = stripTerminalEscapes(rawLine);
+            const hunk = line.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+            if (hunk) {
+                oldLine = Number(hunk[1]);
+                newLine = Number(hunk[2]);
+                continue;
+            }
+            if (line.startsWith("\\ No newline"))
+                continue;
+            let number = newLine;
+            let marker = " ";
+            let style = "context";
+            let content = line;
+            if (change.kind === "create") {
+                newLine += 1;
+            }
+            else if (line.startsWith("+")) {
+                marker = "+";
+                style = "add";
+                content = line.slice(1);
+                newLine += 1;
+            }
+            else if (line.startsWith("-")) {
+                number = oldLine;
+                marker = "-";
+                style = "remove";
+                content = line.slice(1);
+                oldLine += 1;
+            }
+            else {
+                content = line.startsWith(" ") ? line.slice(1) : line;
+                oldLine += 1;
+                newLine += 1;
+            }
+            this.out(`${renderCodeLine(number, marker, content, style, width, this.options.color)}\n`);
+        }
+    }
+    paint(text, colorName) {
+        if (!this.options.color)
+            return text;
+        if (colorName === "normal")
+            return text;
+        return `${color[colorName]}${text}${color.reset}`;
+    }
+    elapsedThought() {
+        if (!this.thoughtStartedAt)
+            return "0.0s";
+        return `${((Date.now() - this.thoughtStartedAt) / 1000).toFixed(1)}s`;
+    }
+    elapsedSince(startedAt) {
+        return `${((Date.now() - startedAt) / 1000).toFixed(1)}s`;
+    }
+    writeAssistantDelta(text) {
+        // Buffer only the current line, then render it once. This preserves
+        // streaming without rewriting terminal content or exposing raw Markdown.
+        this.assistantLineBuffer += text;
+        let newlineIndex = this.assistantLineBuffer.indexOf("\n");
+        while (newlineIndex >= 0) {
+            const line = this.assistantLineBuffer.slice(0, newlineIndex).replace(/\r$/, "");
+            this.out(`${this.renderMarkdownLine(line)}\n`);
+            this.assistantLineBuffer = this.assistantLineBuffer.slice(newlineIndex + 1);
+            newlineIndex = this.assistantLineBuffer.indexOf("\n");
+        }
+    }
+    flushAssistantLine(terminate) {
+        if (!this.assistantLineBuffer)
+            return;
+        this.out(this.renderMarkdownLine(this.assistantLineBuffer));
+        this.assistantLineBuffer = "";
+        if (terminate)
+            this.out("\n");
+    }
+    renderMarkdownLine(line) {
+        // Strip any terminal escapes from model/tool-relayed content before we add our own.
+        // This is a web agent: untrusted page text can carry OSC/CSI sequences (title/clipboard/
+        // hyperlink/screen-clear injection). Every branch below starts from sanitized input.
+        line = stripTerminalEscapes(line);
+        const fence = line.match(/^\s*```\s*([^\s`]*)/);
+        if (fence) {
+            const opening = !this.insideCodeFence;
+            this.insideCodeFence = !this.insideCodeFence;
+            const label = opening ? ` ${fence[1] || "code"} ` : "";
+            return this.paint(label ? `─────${label}─────` : "───────────────", "gray");
+        }
+        if (this.insideCodeFence)
+            return `  ${this.paint(line, "cyan")}`;
+        const heading = line.match(/^\s{0,3}(#{1,6})\s+(.+)$/);
+        if (heading)
+            return this.paint(renderInlineMarkdown(heading[2] ?? "", this.options.color), "blue");
+        const bullet = line.match(/^\s{0,3}[-*+]\s+(.+)$/);
+        if (bullet) {
+            return `  ${this.paint("•", "blue")} ${renderInlineMarkdown(bullet[1] ?? "", this.options.color)}`;
+        }
+        const numbered = line.match(/^\s{0,3}(\d+)[.)]\s+(.+)$/);
+        if (numbered) {
+            return `  ${this.paint(`${numbered[1]}.`, "blue")} ${renderInlineMarkdown(numbered[2] ?? "", this.options.color)}`;
+        }
+        const quote = line.match(/^\s{0,3}>\s?(.*)$/);
+        if (quote) {
+            return `  ${this.paint("│", "gray")} ${this.paint(renderInlineMarkdown(quote[1] ?? "", this.options.color), "gray")}`;
+        }
+        if (/^\s{0,3}([-*_])(?:\s*\1){2,}\s*$/.test(line))
+            return this.paint("─".repeat(48), "gray");
+        return renderInlineMarkdown(line, this.options.color);
+    }
+    ensureTurnSpacing() {
+        if (this.turnSpacingPrinted)
+            return;
+        this.out("\n");
+        this.turnSpacingPrinted = true;
+    }
+    clearStatusLines() {
+        if (this.statusLines === 2) {
+            this.out("\r\x1b[2K\x1b[1F\r\x1b[2K");
+            return;
+        }
+        this.out("\r\x1b[2K");
+    }
+    out(text) {
+        this.options.beforeOutput?.();
+        (this.options.stdout ?? process.stdout).write(text);
+        this.options.afterOutput?.(text);
+    }
+}
+export function renderTraceEvent(event) {
+    new CliTraceRenderer({
+        verbose: true,
+        stream: false,
+        color: stderr.isTTY,
+        status: false,
+    }).render(event);
+}
+export function createCliTraceSink(verbose) {
+    return new CliTraceRenderer({
+        verbose,
+        stream: false,
+        color: stderr.isTTY,
+        status: false,
+    }).sink();
+}
+function riskLabel(risk) {
+    if (risk === "high")
+        return "high risk";
+    if (risk === "medium")
+        return "medium risk";
+    return "low risk";
+}
+function compactValue(value, max) {
+    const text = typeof value === "string" ? value : JSON.stringify(value);
+    if (!text)
+        return "";
+    const normalized = text.replace(/\s+/g, " ");
+    return normalized.length > max ? `${normalized.slice(0, max)}...` : normalized;
+}
+function truncateDisplayLine(value, max) {
+    const characters = Array.from(value.replace(/\t/g, "  "));
+    return characters.length <= max ? characters.join("") : `${characters.slice(0, max - 1).join("")}…`;
+}
+function renderCodeLine(lineNumber, marker, value, style, width, useColor) {
+    const prefix = `  ${String(lineNumber).padStart(5)} ${marker}  `;
+    const content = truncateDisplayLine(value, Math.max(10, width - displayCells(prefix)));
+    const padding = " ".repeat(Math.max(0, width - displayCells(prefix) - displayCells(content)));
+    if (!useColor)
+        return `${prefix}${content}${padding}`;
+    const background = style === "add"
+        ? "\x1b[48;2;0;55;18m"
+        : style === "remove"
+            ? "\x1b[48;2;75;8;14m"
+            : "";
+    const gutter = style === "add"
+        ? "\x1b[38;2;74;222;128m"
+        : style === "remove"
+            ? "\x1b[38;2;248;113;113m"
+            : "\x1b[38;2;115;115;125m";
+    return `${background}${gutter}${prefix}${highlightCode(content)}${padding}\x1b[0m`;
+}
+function highlightCode(value) {
+    const normal = "\x1b[38;2;235;235;240m";
+    return `${normal}${value.replace(/(\/\/.*$|\/\*.*?\*\/|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\b(?:const|let|var|new|if|else|for|while|return|async|await|function|class|interface|type|import|export|from|extends|throw|try|catch|finally)\b|\b(?:true|false|null|undefined)\b|\b\d+(?:\.\d+)?\b)/g, (token) => {
+        if (token.startsWith("//") || token.startsWith("/*"))
+            return `\x1b[38;2;130;130;120m${token}${normal}`;
+        if (/^["'`]/.test(token))
+            return `\x1b[38;2;250;204;92m${token}${normal}`;
+        if (/^(?:true|false|null|undefined|\d)/.test(token))
+            return `\x1b[38;2;189;147;249m${token}${normal}`;
+        return `\x1b[38;2;255;80;155m${token}${normal}`;
+    })}`;
+}
+function displayCells(value) {
+    let width = 0;
+    for (const char of value) {
+        width += /[\u1100-\u115F\u2E80-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE10-\uFE6F\uFF00-\uFF60\uFFE0-\uFFE6]/u.test(char) ? 2 : 1;
+    }
+    return width;
+}
+function retryLabel(mode, delayMs) {
+    if (mode === "after-compaction")
+        return "Context compacted; retrying model response";
+    if (mode === "continue")
+        return "Output limit reached; continuing response";
+    const delay = delayMs && delayMs > 0 ? ` in ${(delayMs / 1000).toFixed(1)}s` : "";
+    return mode === "non-stream"
+        ? `Retrying model response without streaming${delay}`
+        : `Retrying model response${delay}`;
+}
+export function stripTerminalEscapes(value) {
+    return value
+        // CSI: ESC [ ... final-byte
+        .replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "")
+        // OSC: ESC ] ... (BEL or ST terminator)
+        .replace(/\x1B\][^\x07\x1B]*(?:\x07|\x1B\\)/g, "")
+        // DCS/SOS/PM/APC: ESC (P|X|^|_) ... ST
+        .replace(/\x1B[PX^_][^\x1B]*(?:\x1B\\)?/g, "")
+        // Any remaining bare ESC (incl. single-char sequences)
+        .replace(/\x1B[@-Z\\-~]?/g, "")
+        // Other C0 controls except tab/newline/carriage-return
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+}
+function renderInlineMarkdown(value, useColor) {
+    let rendered = stripTerminalEscapes(value);
+    rendered = rendered.replace(/\[([^\]]+)]\((https?:\/\/[^)]+)\)/g, (_match, label, url) => useColor ? `\x1b[4;38;2;96;165;250m${label}\x1b[0m \x1b[90m(${url})\x1b[0m` : `${label} (${url})`);
+    rendered = rendered.replace(/`([^`]+)`/g, (_match, codeText) => useColor ? `\x1b[48;5;236m\x1b[38;2;125;211;252m ${codeText} \x1b[0m` : codeText);
+    rendered = rendered.replace(/\*\*([^*]+)\*\*/g, (_match, boldText) => useColor ? `\x1b[1m${boldText}\x1b[0m` : boldText);
+    rendered = rendered.replace(/__([^_]+)__/g, (_match, boldText) => useColor ? `\x1b[1m${boldText}\x1b[0m` : boldText);
+    rendered = rendered.replace(/(^|[^*])\*([^*\n]+)\*(?!\*)/g, (_match, prefix, italicText) => useColor ? `${prefix}\x1b[3m${italicText}\x1b[0m` : `${prefix}${italicText}`);
+    return rendered;
+}
+function compactToolInput(tool, value, max) {
+    if (tool === "Task" && value && typeof value === "object" && !Array.isArray(value)) {
+        const input = value;
+        const subagentType = (typeof input.subagent_type === "string" && input.subagent_type) ||
+            (typeof input.worker === "string" && input.worker) ||
+            "agent";
+        const description = typeof input.description === "string" ? input.description : "subtask";
+        return compactValue({ subagent_type: subagentType, description }, max);
+    }
+    return compactValue(value, max);
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    return `${(bytes / 1024).toFixed(1)} KB`;
+}
+function formatStatusText(text) {
+    if (text === "thinking")
+        return "Thinking...";
+    if (text.startsWith("running "))
+        return `Running ${text.slice("running ".length)}...`;
+    if (text.startsWith("using "))
+        return `Using ${text.slice("using ".length)}...`;
+    return `${text.slice(0, 1).toUpperCase()}${text.slice(1)}...`;
+}
+function formatCompletedStatusText(text) {
+    if (text === "thinking")
+        return "Thought";
+    if (text.startsWith("using "))
+        return `Used ${text.slice("using ".length)}`;
+    if (text.startsWith("running "))
+        return `Ran ${text.slice("running ".length)}`;
+    return text;
+}
+function thoughtDetail(stopReason) {
+    if (stopReason === "tool_use")
+        return "model requested tool use";
+    if (stopReason === "max_tokens")
+        return "model reached max token limit";
+    if (stopReason === "end_turn")
+        return "answered directly, no tools used";
+    return stopReason ? `stopped by ${stopReason}` : "model response received";
+}
+function formatInteractiveToolResult(tool, content, isError, input) {
+    const name = tool === "write_file" ? "Write" : tool === "shell_exec" ? "Bash" : toolLabel(tool);
+    const key = tool === "list_files" ? "directory" : tool === "web_search" ? "query" : tool === "web_fetch" ? "url" : tool === "shell_exec" ? "command" : "path";
+    const rawDetail = input?.[key];
+    const detail = typeof rawDetail === "string" && rawDetail.trim()
+        ? `(${compactValue(stripTerminalEscapes(rawDetail), 100)})`
+        : "";
+    const label = `${name}${detail}`;
+    if (isPermissionDenied(content))
+        return `${label} skipped · approval not granted`;
+    if (isError)
+        return `${label} failed · ${compactValue(content, 160)}`;
+    if (tool === "write_file" && content.startsWith("Wrote "))
+        return content;
+    if (tool === "list_files")
+        return `${label} · ${content ? content.split(/\r?\n/).length : 0} entries`;
+    if (tool === "web_search") {
+        const count = content.match(/"count"\s*:\s*(\d+)/)?.[1];
+        return `${label}${count ? ` · ${count} results` : ""}`;
+    }
+    if (tool === "shell_exec")
+        return label;
+    return `${label} completed`;
+}
+function toolLabel(tool) {
+    return tool
+        .split("_")
+        .filter(Boolean)
+        .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+        .join(" ");
+}
+function isPermissionDenied(content) {
+    return content.startsWith("Permission denied for tool ");
+}