@armadra/agent 0.5.0 → 0.6.0

package/dist/trace/build.js

@@ -0,0 +1,382 @@
+/**
+ * 轨迹构建器（docs/wave6-plan.md §2.3、D6）。[W6-T1]
+ *
+ * `buildTrace(input, opts)` 把会话条目重建成 `Trace`（Turn → Step → Tool → Subcall / Subagent）：
+ * TUI `/trace`、`ama sessions trace`、RPC `get_trace` 三方共用同一棵树。
+ *
+ * 性质：
+ * - **纯函数**：不读时钟、不做 I/O；子会话经 `opts.loadChild` 回调读取（深度 ≤ 1：子轨迹里不再展开孙任务）。
+ * - **确定性**：同样的输入（含 `opts.now` / `opts.live`）得到逐字节相同的 JSON；节点顺序 = 条目顺序。
+ * - **不改历史**：老会话没有 `ama.trace` 时按条目时间回退推算并标 `approx`；推算出的时间不写回文件。
+ * - **容忍**：未知条目、未知 customType、损坏的 data 一律跳过；子会话缺失或读取抛错标 `childMissing`。
+ * - **不含正文**：只有 id、时间、计数与用量；提示 / 参数 / 结果的预览由调用方按 `entryIds` 回条目取。
+ *
+ * 算法：选分支（leaf = 根 → 叶子；all = 文件顺序）→ 预建索引（`ama.trace` 按 assistant / toolCall /
+ * compaction / usage 条目 id，`ama.task` 按父 toolCallId，`external_turn` 按 taskId，`context_edit` 的
+ * retry / overflow 目标）→ 顺序扫描建节点 → 叠加 `live` → 汇总。推算规则：`requestAt = assistant.timestamp`、
+ * `doneAt = 条目时间`、工具 `startedAt = assistant 条目时间`、`endedAt = toolResult.timestamp`；ttft 分位与
+ * 平均吞吐只用精确（非 approx）的 step。
+ *
+ * 汇总口径：`requests` 与 token / 费用和 `usageTotals`（session/export.ts）一致（assistant + 压缩 / 分支摘要 +
+ * `usage` 条目；进行中的请求不计）；`durationMs` = 各回合耗时之和（不含回合之间的空闲）；回合的 `endedAt`
+ * 不被后台子 Agent 拉长；文件里 `status: "running"` 的任务在没有 `live` 时视为 `interrupted`。
+ */
+import { indexEntries, pathToRoot } from "../session/tree.js";
+import { buildIndex, entryTime, num, splitRef, traceData, zeroUsage, } from "./build-index.js";
+import { abortedRequest, assistantStep, compactionAsAux, compactionNode, externalNodes, pushUsage, retryNode, subagentNode, } from "./build-nodes.js";
+import { accumulate, emptyTotals, finishTotals, maxDefined, mergeTotals } from "./build-util.js";
+import {} from "./types.js";
+/** 所选分支的条目。 */
+export function selectTraceEntries(input, branch = "leaf") {
+    if (branch === "all")
+        return [...input.entries];
+    const leaf = input.leaf === undefined ? (input.entries.at(-1)?.id ?? null) : input.leaf;
+    return pathToRoot(indexEntries(input.entries), leaf);
+}
+/**
+ * 从会话条目构建轨迹树。见文件头的性质与算法；选项见 `BuildTraceOptions`。
+ */
+export function buildTrace(input, opts = {}) {
+    const entries = selectTraceEntries(input, opts.branch ?? "leaf");
+    const index = buildIndex(entries);
+    const state = {
+        turns: [],
+        aux: [],
+        turn: undefined,
+        turnModel: undefined,
+        model: undefined,
+        tools: new Map(),
+        resolved: new Set(),
+        extraUsage: new Map(),
+    };
+    const openTurn = (id, startedAt, origin) => {
+        const turn = {
+            id,
+            kind: "turn",
+            status: "ok",
+            entryIds: [id],
+            steps: [],
+            usage: emptyTotals(),
+        };
+        if (startedAt !== undefined)
+            turn.startedAt = startedAt;
+        if (origin !== undefined)
+            turn.origin = origin;
+        state.turns.push(turn);
+        state.turn = turn;
+        state.turnModel = state.model;
+        return turn;
+    };
+    const currentTurn = (entry, at) => state.turn ?? openTurn(entry.id, at);
+    for (const entry of entries) {
+        const at = entryTime(entry);
+        switch (entry.type) {
+            case "model_change":
+                state.model = `${entry.provider}/${entry.modelId}`;
+                break;
+            case "message": {
+                const m = entry.message;
+                if (m.role === "user") {
+                    if (m.origin === "steer" && state.turn !== undefined)
+                        state.turn.entryIds.push(entry.id);
+                    else
+                        openTurn(entry.id, num(m.timestamp) ?? at, m.origin);
+                }
+                else if (m.role === "assistant") {
+                    const turn = currentTurn(entry, num(m.timestamp) ?? at);
+                    turn.steps.push(assistantStep(entry.id, m, at, turn, state, index));
+                }
+                else if (m.role === "toolResult") {
+                    const tool = state.tools.get(m.toolCallId);
+                    if (tool === undefined)
+                        break;
+                    state.resolved.add(tool.id);
+                    tool.entryIds.push(entry.id);
+                    tool.isError = m.isError === true;
+                    if (tool.status !== "denied")
+                        tool.status = tool.isError ? "error" : "ok";
+                    if (tool.approx === true) {
+                        const end = num(m.timestamp) ?? at;
+                        if (end !== undefined)
+                            tool.endedAt = end;
+                    }
+                }
+                break;
+            }
+            case "compaction": {
+                const turn = state.turn;
+                const node = compactionNode(entry.id, at, index.compactionByEntry.get(entry.id));
+                node.tokensBefore = entry.tokensBefore;
+                if (turn === undefined)
+                    state.aux.push(compactionAsAux(node, entry.usage));
+                else {
+                    turn.steps.push(node);
+                    if (entry.usage !== undefined)
+                        pushUsage(state, turn.id, entry.usage);
+                }
+                break;
+            }
+            case "branch_summary":
+                if (state.turn !== undefined && entry.usage !== undefined)
+                    pushUsage(state, state.turn.id, entry.usage);
+                break;
+            case "usage": {
+                const trace = index.auxByUsage.get(entry.id);
+                const node = {
+                    id: entry.id,
+                    kind: "aux",
+                    purpose: trace?.data.purpose ?? entry.kind,
+                    status: "ok",
+                    entryIds: trace === undefined ? [entry.id] : [entry.id, trace.entryId],
+                    usage: entry.usage,
+                };
+                const started = num(trace?.data.startedAt);
+                const ended = num(trace?.data.endedAt) ?? at;
+                if (started !== undefined)
+                    node.startedAt = started;
+                if (ended !== undefined)
+                    node.endedAt = ended;
+                if (started === undefined)
+                    node.approx = true;
+                state.aux.push(node);
+                break;
+            }
+            case "custom": {
+                const data = traceData(entry);
+                if (data === undefined || state.turn === undefined)
+                    break;
+                if (data.kind === "retry_wait")
+                    state.turn.steps.push(retryNode(entry.id, data));
+                else if (data.kind === "compaction" && typeof data.compactionEntryId !== "string") {
+                    // 中断的压缩没有 compaction 条目，只有这一条
+                    state.turn.steps.push(compactionNode(entry.id, at, { data, entryId: entry.id }));
+                }
+                else if (data.kind === "step" && typeof data.assistantEntryId !== "string")
+                    abortedRequest(entry.id, data, state);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    attachTasks(state, index, opts);
+    applyLive(state, opts.live);
+    return finish(input, state, opts);
+}
+function attachTasks(state, index, opts) {
+    for (const tool of state.tools.values()) {
+        const tasks = index.tasks.get(tool.id);
+        if (tasks === undefined)
+            continue;
+        for (const { data, entryId } of tasks.values()) {
+            const node = subagentNode(data, entryId, opts.live !== undefined);
+            const external = index.external.get(data.taskId);
+            if (external !== undefined)
+                node.external = externalNodes(data.taskId, external);
+            const file = node.childRef?.sessionFile;
+            if (opts.loadChild !== undefined && file !== undefined && node.runner === "ama")
+                loadSubagentTrace(node, opts.loadChild, opts.now);
+            tool.children.push(node);
+        }
+    }
+}
+/**
+ * 懒加载 ama 子 Agent 的子轨迹（就地写 `node.child` / `node.childMissing`，返回子轨迹）。深度 ≤ 1：
+ * 子轨迹里的任务不再展开。外部 runner 或没有会话文件时返回 undefined 且不标缺失。
+ */
+export function loadSubagentTrace(node, loadChild, now) {
+    if (node.child !== undefined)
+        return node.child;
+    const file = node.childRef?.sessionFile;
+    if (file === undefined || node.runner !== "ama")
+        return undefined;
+    let input;
+    try {
+        input = loadChild(file);
+    }
+    catch {
+        input = undefined;
+    }
+    if (input === undefined) {
+        node.childMissing = true;
+        return undefined;
+    }
+    try {
+        const child = buildTrace({ ...input, sessionFile: input.sessionFile ?? file }, now === undefined ? {} : { now });
+        node.child = child;
+        delete node.childMissing;
+        return child;
+    }
+    catch {
+        node.childMissing = true;
+        return undefined;
+    }
+}
+function applyLive(state, live) {
+    for (const tool of state.tools.values()) {
+        if (state.resolved.has(tool.id) || tool.status === "denied")
+            continue;
+        tool.status = live?.running === true ? "running" : "interrupted";
+    }
+    if (live === undefined)
+        return;
+    for (const lt of live.tools ?? []) {
+        if (lt.parentId !== undefined) {
+            const parent = state.tools.get(lt.parentId);
+            if (parent === undefined)
+                continue;
+            const existing = parent.children.find((c) => c.kind === "subcall" && c.id === lt.id);
+            if (existing !== undefined) {
+                existing.status = "running";
+                delete existing.endedAt;
+                continue;
+            }
+            parent.children.push({
+                id: lt.id,
+                kind: "subcall",
+                name: lt.name,
+                parentToolCallId: lt.parentId,
+                isError: false,
+                status: "running",
+                startedAt: lt.startedAt,
+                entryIds: [],
+            });
+            continue;
+        }
+        const tool = state.tools.get(lt.id);
+        if (tool === undefined || state.resolved.has(tool.id))
+            continue;
+        tool.status = "running";
+        tool.startedAt = lt.startedAt;
+        delete tool.endedAt;
+        delete tool.approx;
+    }
+    const turn = state.turn;
+    const request = live.request;
+    if (request !== undefined && turn !== undefined) {
+        const ref = splitRef(state.model);
+        const step = {
+            id: `live:${request.requestAt}`,
+            kind: "step",
+            status: "running",
+            entryIds: [],
+            provider: request.provider ?? ref.provider,
+            model: request.model ?? ref.model,
+            attempt: 1,
+            usage: { ...zeroUsage(), output: request.outputTokens ?? 0 },
+            stopReason: "",
+            requestAt: request.requestAt,
+            startedAt: request.requestAt,
+            tools: [],
+        };
+        if (request.firstTokenAt !== undefined) {
+            step.firstTokenAt = request.firstTokenAt;
+            step.ttftMs = Math.max(0, request.firstTokenAt - request.requestAt);
+        }
+        turn.steps.push(step);
+    }
+    if (live.running && turn !== undefined)
+        turn.status = "running";
+}
+function finish(input, state, opts) {
+    const all = emptyTotals();
+    let partial = false;
+    let endedAt;
+    let duration = 0;
+    let timed = false;
+    for (const turn of state.turns) {
+        const totals = emptyTotals();
+        let end;
+        let running = turn.status === "running";
+        let interrupted = false;
+        for (const node of turn.steps) {
+            if (node.approx === true)
+                turn.approx = true;
+            end = maxDefined(end, node.endedAt);
+            if (node.status === "running")
+                running = true;
+            if (node.kind !== "step")
+                continue;
+            accumulate(totals, node);
+            for (const tool of node.tools) {
+                totals.toolCalls++;
+                if (tool.approx === true)
+                    turn.approx = true;
+                if (tool.status === "running")
+                    running = true;
+                if (tool.status === "interrupted")
+                    interrupted = true;
+                end = maxDefined(end, tool.endedAt);
+                for (const child of tool.children) {
+                    if (child.status === "running")
+                        running = running || child.kind === "subcall";
+                    // 后台任务可能在回合结束后很久才结束，不拉长回合
+                    if (child.kind === "subcall" || !child.background)
+                        end = maxDefined(end, child.endedAt);
+                }
+            }
+        }
+        for (const usage of state.extraUsage.get(turn.id) ?? [])
+            accumulate(totals, { usage });
+        const last = [...turn.steps].reverse().find((s) => s.kind === "step");
+        if (running) {
+            turn.status = "running";
+            partial = true;
+        }
+        else if (interrupted)
+            turn.status = "interrupted";
+        else if (last?.status === "aborted")
+            turn.status = "aborted";
+        else if (last?.status === "error")
+            turn.status = "error";
+        if (!running && end !== undefined)
+            turn.endedAt = Math.max(end, turn.startedAt ?? end);
+        if (turn.startedAt !== undefined && turn.endedAt !== undefined) {
+            totals.durationMs = turn.endedAt - turn.startedAt;
+            duration += totals.durationMs;
+            timed = true;
+        }
+        turn.usage = finishTotals(totals);
+        mergeTotals(all, totals);
+        endedAt = maxDefined(endedAt, turn.endedAt);
+    }
+    for (const aux of state.aux) {
+        if (aux.usage !== undefined)
+            accumulate(all, { usage: aux.usage });
+        endedAt = maxDefined(endedAt, aux.endedAt);
+    }
+    if (timed)
+        all.durationMs = duration;
+    const startedAt = entryTime(input.header) ??
+        (input.entries[0] !== undefined ? entryTime(input.entries[0]) : undefined) ??
+        opts.now ??
+        0;
+    const trace = {
+        version: 1,
+        sessionId: input.header.id,
+        cwd: input.header.cwd,
+        startedAt,
+        totals: finishTotals(all),
+        turns: state.turns,
+        aux: state.aux,
+        partial,
+    };
+    if (input.sessionFile !== undefined)
+        trace.sessionFile = input.sessionFile;
+    if (!partial && endedAt !== undefined)
+        trace.endedAt = endedAt;
+    return trace;
+}
+/** 在轨迹里找任务（子 Agent 节点）；深度优先，先找到的为准。 */
+export function findSubagent(trace, taskId) {
+    for (const turn of trace.turns)
+        for (const step of turn.steps) {
+            if (step.kind !== "step")
+                continue;
+            for (const tool of step.tools)
+                for (const child of tool.children)
+                    if (child.kind === "subagent" && child.taskId === taskId)
+                        return child;
+        }
+    return undefined;
+}

package/dist/trace/detail.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 轨迹节点的正文预览与详情卡片（docs/wave6-plan.md §2.4：Enter 详情——概要 / 用量与缓存 / 参数与结果预览）。
+ * [W6-T1]
+ *
+ * 轨迹树不含正文；这里按节点的 `entryIds` 回会话条目取：回合 → 用户提示，请求 → 助手文字，工具 → 参数
+ * （JSON，截到 500 字符）与结果（截到 2000 字符），与 `sessions export --format md` 同一截断口径。
+ * 只给本机界面用（TUI 详情、line 模式标签）；HTML / RPC 的预览由 W6-T2 另行脱敏。
+ */
+import type { SessionEntry } from "../session/types.js";
+import type { Theme } from "../tui/component.js";
+import type { TraceRowNode } from "./flatten.js";
+/** 参数预览上限（字符）。 */
+export declare const ARGS_PREVIEW_MAX = 500;
+/** 结果 / 提示 / 输出预览上限（字符）。 */
+export declare const RESULT_PREVIEW_MAX = 2000;
+export interface TraceEntryLookup {
+    entry(id: string): SessionEntry | undefined;
+    /** 工具参数里的路径相对它显示。 */
+    cwd?: string;
+}
+/** 由条目数组建查找表。 */
+export declare function entryLookup(entries: readonly SessionEntry[], cwd?: string): TraceEntryLookup;
+/** 行标签里来自正文的部分：回合 → 提示预览，工具 → 参数摘要。 */
+export declare function describeNode(node: TraceRowNode, lookup: TraceEntryLookup): string | undefined;
+/** 详情里的两段预览（标题 → 正文）。 */
+export declare function nodePreviews(node: TraceRowNode, lookup: TraceEntryLookup): {
+    title: string;
+    text: string;
+}[];
+type Row = [label: string, value: string];
+/** 概要与用量两组键值行。 */
+export declare function summaryRows(node: TraceRowNode, theme: Theme, traceStart: number): Row[];
+/** 详情卡片的行（不含标题与边框；宽度内折行）。 */
+export declare function detailLines(node: TraceRowNode, lookup: TraceEntryLookup, width: number, theme: Theme, traceStart: number): string[];
+export {};

package/dist/trace/detail.js

@@ -0,0 +1,205 @@
+/**
+ * 轨迹节点的正文预览与详情卡片（docs/wave6-plan.md §2.4：Enter 详情——概要 / 用量与缓存 / 参数与结果预览）。
+ * [W6-T1]
+ *
+ * 轨迹树不含正文；这里按节点的 `entryIds` 回会话条目取：回合 → 用户提示，请求 → 助手文字，工具 → 参数
+ * （JSON，截到 500 字符）与结果（截到 2000 字符），与 `sessions export --format md` 同一截断口径。
+ * 只给本机界面用（TUI 详情、line 模式标签）；HTML / RPC 的预览由 W6-T2 另行脱敏。
+ */
+import { formatDuration, msg } from "../i18n/index.js";
+import { formatPercent, formatTokenCount, formatUsd } from "../modes/session-report.js";
+import { toolSummary } from "../modes/interactive/tool-summary.js";
+import { contentText } from "../session/reuse.js";
+import { padToWidth, visibleWidth, wrapTextWithAnsi } from "../tui/ansi.js";
+import { durationText } from "./format.js";
+/** 参数预览上限（字符）。 */
+export const ARGS_PREVIEW_MAX = 500;
+/** 结果 / 提示 / 输出预览上限（字符）。 */
+export const RESULT_PREVIEW_MAX = 2000;
+/** 行内标签里的提示预览上限（字符）。 */
+const LABEL_PREVIEW_MAX = 80;
+/** 由条目数组建查找表。 */
+export function entryLookup(entries, cwd) {
+    const map = new Map();
+    for (const entry of entries)
+        map.set(entry.id, entry);
+    return { entry: (id) => map.get(id), ...(cwd !== undefined ? { cwd } : {}) };
+}
+function oneLine(text, max) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+function truncate(text, max) {
+    return text.length > max
+        ? `${text.slice(0, max)}\n${msg().trace.detail.truncated(text.length)}`
+        : text;
+}
+function messageOf(lookup, id) {
+    const entry = id === undefined ? undefined : lookup.entry(id);
+    return entry?.type === "message" ? entry.message : undefined;
+}
+function toolArgs(lookup, node) {
+    if (node.kind !== "tool")
+        return undefined;
+    const m = messageOf(lookup, node.entryIds[0]);
+    if (m?.role !== "assistant")
+        return undefined;
+    for (const block of m.content)
+        if (block.type === "toolCall" && block.id === node.id)
+            return block.arguments;
+    return undefined;
+}
+/** 行标签里来自正文的部分：回合 → 提示预览，工具 → 参数摘要。 */
+export function describeNode(node, lookup) {
+    if (node.kind === "turn") {
+        const m = messageOf(lookup, node.id);
+        return m?.role === "user" ? oneLine(contentText(m.content), LABEL_PREVIEW_MAX) : undefined;
+    }
+    if (node.kind === "tool") {
+        const summary = toolSummary(node.name, toolArgs(lookup, node), lookup.cwd);
+        return summary === "" ? undefined : oneLine(summary, LABEL_PREVIEW_MAX);
+    }
+    return undefined;
+}
+/** 详情里的两段预览（标题 → 正文）。 */
+export function nodePreviews(node, lookup) {
+    const d = msg().trace.detail;
+    const out = [];
+    if (node.kind === "turn") {
+        const m = messageOf(lookup, node.id);
+        if (m?.role === "user")
+            out.push({ title: d.input, text: truncate(contentText(m.content), RESULT_PREVIEW_MAX) });
+    }
+    else if (node.kind === "step") {
+        const m = messageOf(lookup, node.id);
+        if (m?.role === "assistant") {
+            const text = m.content
+                .flatMap((b) => (b.type === "text" && b.text.trim() !== "" ? [b.text] : []))
+                .join("\n");
+            if (text !== "")
+                out.push({ title: d.output, text: truncate(text, RESULT_PREVIEW_MAX) });
+        }
+    }
+    else if (node.kind === "tool") {
+        const args = toolArgs(lookup, node);
+        if (args !== undefined)
+            out.push({ title: d.args, text: truncate(JSON.stringify(args, null, 2), ARGS_PREVIEW_MAX) });
+        const r = messageOf(lookup, node.entryIds[1]);
+        if (r?.role === "toolResult")
+            out.push({ title: d.result, text: truncate(contentText(r.content), RESULT_PREVIEW_MAX) });
+    }
+    return out;
+}
+function usageRows(usage, cost) {
+    const d = msg().trace.detail;
+    if (usage === undefined)
+        return [];
+    const t = formatTokenCount;
+    const rows = [
+        [
+            d.usage,
+            d.usageValue(t(usage.input), t(usage.output), t(usage.cacheRead), t(usage.cacheWrite)),
+        ],
+    ];
+    const prompt = usage.input + usage.cacheRead + usage.cacheWrite;
+    if (prompt > 0)
+        rows.push([d.cacheHit, formatPercent(usage.cacheRead / prompt)]);
+    if (cost !== undefined)
+        rows.push([d.cost, formatUsd(cost)]);
+    return rows;
+}
+/** 概要与用量两组键值行。 */
+export function summaryRows(node, theme, traceStart) {
+    const d = msg().trace.detail;
+    if (node.kind === "more" || node.kind === "aux_group")
+        return [];
+    const rows = [
+        [d.kind, node.kind],
+        [d.status, msg().trace.status[node.status]],
+    ];
+    if (node.startedAt !== undefined)
+        rows.push([d.start, `+${formatDuration(Math.max(0, node.startedAt - traceStart), "precise")}`]);
+    const duration = durationText(node, theme);
+    if (duration !== "")
+        rows.push([d.duration, duration]);
+    if (node.approx === true)
+        rows.push([d.approx, d.approxValue]);
+    switch (node.kind) {
+        case "turn":
+            if (node.origin !== undefined)
+                rows.push([d.origin, node.origin]);
+            rows.push(...usageRows(node.usage, node.usage.cost));
+            break;
+        case "step":
+            rows.push([d.model, `${node.provider}/${node.model}`], [d.attempt, String(node.attempt)]);
+            if (node.fallbackFrom !== undefined)
+                rows.push([d.fallbackFrom, node.fallbackFrom]);
+            if (node.ttftMs !== undefined)
+                rows.push([d.ttft, formatDuration(node.ttftMs, "precise")]);
+            if (node.tps !== undefined)
+                rows.push([d.tps, `${node.tps} tok/s`]);
+            if (node.thinkingLevel !== undefined)
+                rows.push([d.thinking, node.thinkingLevel]);
+            if (node.stopReason !== "")
+                rows.push([d.stopReason, node.stopReason]);
+            if (node.errorMessage !== undefined)
+                rows.push([d.error, node.errorMessage]);
+            rows.push(...usageRows(node.usage, node.usage.cost?.total));
+            break;
+        case "tool":
+            if (node.approvalMs !== undefined)
+                rows.push([d.approval, formatDuration(node.approvalMs, "precise")]);
+            if (node.denied === true)
+                rows.push([d.denied, d.yes]);
+            break;
+        case "subagent":
+            rows.push([d.task, `${node.taskId} ${node.agent}`], [d.runner, node.runner]);
+            if (node.background)
+                rows.push([d.background, d.yes]);
+            if (node.turns !== undefined)
+                rows.push([d.turns, String(node.turns)]);
+            rows.push(...usageRows(node.usage, node.costUsd));
+            if (node.childRef?.sessionFile !== undefined)
+                rows.push([d.childFile, node.childRef.sessionFile]);
+            if (node.childMissing === true)
+                rows.push([d.childFile, d.childMissing]);
+            break;
+        case "external_turn":
+            rows.push([d.stopReason, node.stopReason], [d.files, String(node.filesTouched)]);
+            if (node.tools.length > 0)
+                rows.push([d.tools, node.tools.map((t) => `${t.kind}:${t.status}`).join(" ")]);
+            break;
+        case "retry_wait":
+            if (node.reason !== undefined)
+                rows.push([d.reason, node.reason]);
+            break;
+        case "compaction":
+            if (node.tokensBefore !== undefined)
+                rows.push([d.usage, formatTokenCount(node.tokensBefore)]);
+            break;
+        case "aux":
+            rows.push(...usageRows(node.usage, node.usage?.cost?.total));
+            break;
+        default:
+            break;
+    }
+    return rows;
+}
+/** 详情卡片的行（不含标题与边框；宽度内折行）。 */
+export function detailLines(node, lookup, width, theme, traceStart) {
+    const rows = summaryRows(node, theme, traceStart);
+    // 键列宽取最长的键（en 的 Waiting for approval 比 16 列宽，封顶会让这一行错位）
+    const labelWidth = Math.max(0, ...rows.map(([label]) => visibleWidth(label)));
+    const out = [];
+    const valueWidth = Math.max(8, width - labelWidth - 2);
+    for (const [label, value] of rows) {
+        const wrapped = wrapTextWithAnsi(value, valueWidth);
+        wrapped.forEach((line, i) => out.push(`${i === 0 ? theme.fg("muted", padToWidth(label, labelWidth)) : " ".repeat(labelWidth)}  ${line}`));
+    }
+    for (const preview of nodePreviews(node, lookup)) {
+        out.push("", theme.bold(preview.title));
+        for (const line of preview.text.split("\n"))
+            out.push(...wrapTextWithAnsi(line, Math.max(8, width)));
+    }
+    return out;
+}