@astralyn/pi 0.82.5 → 0.82.7

package/dist/extensions/subagent/render.js

@@ -1,20 +1,38 @@
 import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
 import { getMarkdownTheme } from "../../modes/interactive/theme/theme.js";
+import { getSubagentRetryView } from "./retry.js";
 import { statusSummary } from "./runner.js";
 const SINGLE_EXCERPT_LIMIT = 200;
-const RUN_LINE_EXCERPT_LIMIT = 64;
+const RUN_LINE_EXCERPT_LIMIT = 96;
+const RUN_ERROR_EXCERPT_LIMIT = 200;
+const RETRY_ERROR_EXCERPT_LIMIT = 160;
 const LIVE_TAIL_LIMIT = 100;
 const COLLAPSED_RUN_LIMIT = 4;
-const ACTIVITY_GROUPS = [
-    { toolName: "read", verb: "read", singular: "file", plural: "files" },
-    { toolName: "grep", verb: "searched", singular: "pattern", plural: "patterns" },
-    { toolName: "find", verb: "searched", singular: "path pattern", plural: "path patterns" },
-    { toolName: "ls", verb: "listed", singular: "directory", plural: "directories" },
-    { toolName: "bash", verb: "ran", singular: "command", plural: "commands" },
-    { toolName: "edit", verb: "edited", singular: "file", plural: "files" },
-    { toolName: "write", verb: "wrote", singular: "file", plural: "files" },
-];
+const PROMPT_PREVIEW_LINES = 2;
+const PROMPT_PREVIEW_LINE_LIMIT = 120;
+const ACTIVITY_SUMMARY_LIMIT = 96;
+const ACTIVITY_RESULT_LIMIT = 64;
+// Sub-10s tool calls are routine; a duration only earns ink when it
+// explains where the time went.
+const ACTIVITY_DURATION_MIN_MS = 10_000;
+const EXPANDED_LIVE_TAIL_LINES = 3;
+class IndentedText {
+    text;
+    indent;
+    constructor(text, indent) {
+        this.text = new Text(text, 0, 0);
+        this.indent = indent;
+    }
+    render(width) {
+        const indent = Math.min(this.indent, Math.max(0, width - 1));
+        const prefix = " ".repeat(indent);
+        return this.text.render(Math.max(1, width - indent)).map((line) => `${prefix}${line}`);
+    }
+    invalidate() {
+        this.text.invalidate();
+    }
+}
 // Display-only: profile names stay lowercase everywhere the model sees
 // them; the transcript shows "general" as "General", "code-reviewer" as
 // "Code Reviewer".
@@ -55,18 +73,54 @@ function stripBlockMarkdown(text) {
     })
         .join("\n");
 }
+// finalOutput/liveText carry model-facing truncation notices from
+// boundText/tailText. Only recognize their exact boundary lines so literal
+// discussion of the marker remains visible in the transcript.
+const OUTPUT_TRUNCATION_NOTICE_PATTERN = /^\[Output truncated(?:: \d+ bytes omitted)?\.\]$/u;
+const EARLIER_OUTPUT_NOTICE = "[Earlier output omitted.]";
+function terminalOutputNotice(text) {
+    const lines = text.split("\n");
+    let index = lines.length - 1;
+    while (index >= 0 && !lines[index]?.trim())
+        index--;
+    if (index < 0 || !OUTPUT_TRUNCATION_NOTICE_PATTERN.test(lines[index]?.trim() ?? "")) {
+        return { text, truncated: false };
+    }
+    lines.splice(index, 1);
+    return { text: lines.join("\n").trimEnd(), truncated: true };
+}
+function replaceBoundaryNotices(text) {
+    const lines = text.split("\n");
+    const first = lines.findIndex((line) => Boolean(line.trim()));
+    if (first >= 0 && lines[first]?.trim() === EARLIER_OUTPUT_NOTICE)
+        lines[first] = "…";
+    let last = lines.length - 1;
+    while (last >= 0 && !lines[last]?.trim())
+        last--;
+    if (last >= 0 && OUTPUT_TRUNCATION_NOTICE_PATTERN.test(lines[last]?.trim() ?? ""))
+        lines[last] = "…";
+    return lines.join("\n");
+}
+function plainExcerpt(text, limit) {
+    return truncate(stripInlineMarkdown(stripBlockMarkdown(text)).replace(/\s+/gu, " ").trim(), limit);
+}
 function excerpt(text, limit) {
-    // finalOutput/liveText carry model-facing truncation notices from
-    // boundText/tailText; in the transcript an ellipsis is enough.
-    const cleaned = text.replace(/\[(?:Output truncated(?:: \d+ bytes omitted\.)?|Earlier output omitted\.)\]/gu, "…");
-    return truncate(stripInlineMarkdown(stripBlockMarkdown(cleaned)).replace(/\s+/gu, " ").trim(), limit);
+    return plainExcerpt(replaceBoundaryNotices(text), limit);
 }
-function liveTail(run) {
-    const lines = run.liveText
+// Generated notice-only boundary lines must never become the live line the
+// user watches; identical text in the body remains ordinary model output.
+function liveTailLines(run) {
+    const { text } = terminalOutputNotice(run.liveText);
+    const lines = text
         .split("\n")
         .map((line) => line.trim())
         .filter(Boolean);
-    const last = lines.at(-1);
+    if (lines[0] === EARLIER_OUTPUT_NOTICE)
+        lines.shift();
+    return lines;
+}
+function liveTail(run) {
+    const last = liveTailLines(run).at(-1);
     return last ? excerpt(last, LIVE_TAIL_LIMIT) : undefined;
 }
 // Completed-run excerpts read better cut at a sentence boundary than
@@ -83,17 +137,30 @@ function leadingSentences(text, limit) {
     }
     if (boundary >= limit / 2)
         return window.slice(0, boundary).trimEnd();
-    return truncate(window, limit);
+    return truncate(cleaned, limit);
 }
 const VERIFY_COMMAND_PATTERN = /\b(test|lint|typecheck|tsc|vitest|jest|pytest|build|check|fmt|format|compile)\b/iu;
 const INSPECT_COMMAND_PATTERN = /\b(rg|grep|find|git (?:diff|status|log|show)|ls|tree|cat|head|tail)\b/iu;
 const RETRY_MARKER_PATTERN = /^Retrying\b/u;
 const STREAM_MARKERS = new Set(["Thinking…", "Writing response…"]);
+function retryText(run) {
+    const retry = getSubagentRetryView(run);
+    if (!retry)
+        return undefined;
+    const status = retry.remainingSeconds > 0
+        ? `Retrying (${retry.attempt}/${retry.maxAttempts}) in ${retry.remainingSeconds}s`
+        : `Retrying now… (${retry.attempt}/${retry.maxAttempts})`;
+    const error = excerpt(retry.error, RETRY_ERROR_EXCERPT_LIMIT);
+    return error ? `${status} — ${error}` : status;
+}
 // Translates raw tool traffic into what the worker is doing right now, so
 // the collapsed card reads as a phase instead of a command line. Modelled
 // on tool-type classification; the raw tool summary stays as evidence on
 // the next line.
 function runIntent(run) {
+    const retry = retryText(run);
+    if (retry)
+        return retry;
     const current = run.currentActivity;
     if (current && RETRY_MARKER_PATTERN.test(current))
         return current;
@@ -125,6 +192,8 @@ function runIntent(run) {
 // The raw tool summary backs up the intent line; suppress it when it would
 // just repeat a stream/retry marker.
 function runEvidence(run) {
+    if (getSubagentRetryView(run))
+        return undefined;
     const current = run.currentActivity;
     if (!current || STREAM_MARKERS.has(current) || RETRY_MARKER_PATTERN.test(current))
         return undefined;
@@ -136,44 +205,77 @@ function liveElapsed(run) {
     const end = run.endedAt ?? Date.now();
     return formatDuration(Math.max(0, (end - run.startedAt) / 1000));
 }
+function statusColor(status) {
+    switch (status) {
+        case "completed":
+            return "success";
+        case "failed":
+            return "error";
+        case "aborted":
+            return "warning";
+        case "running":
+            return "accent";
+        default:
+            return "muted";
+    }
+}
 // The tool shell already paints a call-level status dot (● in
 // warning/success/error), so `●` is off-limits here: `›` marks where the
 // work currently is, and the remaining glyphs are terminal states.
 function statusMarker(status, theme) {
+    const glyph = status === "completed"
+        ? "✓"
+        : status === "failed"
+            ? "×"
+            : status === "aborted"
+                ? "■"
+                : status === "running"
+                    ? "›"
+                    : "○";
+    return theme.fg(statusColor(status), glyph);
+}
+function statusWord(status) {
     switch (status) {
         case "completed":
-            return theme.fg("success", "✓");
+            return "Completed";
         case "failed":
-            return theme.fg("error", "×");
+            return "Failed";
         case "aborted":
-            return theme.fg("warning", "■");
+            return "Aborted";
         case "running":
-            return theme.fg("accent", "›");
+            return "Running";
         default:
-            return theme.fg("muted", "○");
+            return "Queued";
     }
 }
 function runTitle(run, theme, index) {
     const number = index === undefined ? "" : theme.fg("dim", `${index} · `);
     return `${statusMarker(run.status, theme)} ${number}${theme.fg("accent", displayAgentName(run.agent))}${theme.fg("dim", ` · ${truncate(run.description, 48)}`)}`;
 }
+// Mid-run token totals are cache-inflated (totalTokens sums cache reads
+// across turns), so live lines quote tool uses and the context watermark
+// instead; settled lines get the real total.
 function runProgressText(run) {
     const items = [`${run.usage.toolUses} tool use${run.usage.toolUses === 1 ? "" : "s"}`];
-    if (run.usage.totalTokens)
-        items.push(`${formatTokens(run.usage.totalTokens)} tokens`);
+    if (run.usage.contextTokens)
+        items.push(`ctx: ${formatTokens(run.usage.contextTokens)}`);
     return items.join(" · ");
 }
 function runLine(run, theme, index) {
     let line = runTitle(run, theme, index);
-    const detail = run.status === "running"
-        ? runIntent(run)
-        : run.status === "failed" || run.status === "aborted"
-            ? run.error && excerpt(run.error, RUN_LINE_EXCERPT_LIMIT)
-            : run.finalOutput && excerpt(run.finalOutput, RUN_LINE_EXCERPT_LIMIT);
+    const retry = retryText(run);
+    const detail = retry ??
+        (run.status === "running"
+            ? excerpt(runIntent(run), LIVE_TAIL_LIMIT)
+            : run.status === "failed" || run.status === "aborted"
+                ? undefined
+                : run.finalOutput && leadingSentences(run.finalOutput, RUN_LINE_EXCERPT_LIMIT));
     if (detail)
-        line += theme.fg(run.status === "failed" ? "error" : "dim", ` — ${detail}`);
+        line += theme.fg("dim", ` — ${detail}`);
     if (run.status === "running") {
         line += theme.fg("dim", ` · ${runProgressText(run)}`);
+        if (run.usage.cost)
+            line += theme.fg("dim", ` · $${run.usage.cost.toFixed(3)}`);
         const elapsed = liveElapsed(run);
         if (elapsed)
             line += theme.fg("dim", ` · ${elapsed}`);
@@ -184,6 +286,20 @@ function runLine(run, theme, index) {
     }
     return line;
 }
+function runErrorExcerpt(run) {
+    if ((run.status !== "failed" && run.status !== "aborted") || !run.error)
+        return undefined;
+    return leadingSentences(run.error, RUN_ERROR_EXCERPT_LIMIT);
+}
+function runErrorIndent(index) {
+    return index === undefined ? 2 : 5 + String(index).length;
+}
+function addRunSummary(container, run, theme, index) {
+    container.addChild(new Text(runLine(run, theme, index), 0, 0));
+    const error = runErrorExcerpt(run);
+    if (error)
+        container.addChild(new IndentedText(theme.fg("error", error), runErrorIndent(index)));
+}
 // Keep active work visible while a batch is in flight: completed runs
 // may otherwise crowd a still-running task out of the collapsed window.
 function selectCollapsedRuns(runs, isPartial) {
@@ -192,32 +308,44 @@ function selectCollapsedRuns(runs, isPartial) {
     if (!isPartial)
         return runs.slice(0, COLLAPSED_RUN_LIMIT);
     const active = runs.filter((run) => run.status === "running" || run.status === "queued");
+    const retrying = active.filter((run) => getSubagentRetryView(run));
+    const retryingSet = new Set(retrying);
+    const otherActive = active.filter((run) => !retryingSet.has(run));
     const settled = runs.filter((run) => run.status !== "running" && run.status !== "queued");
-    return [...active, ...settled].slice(0, COLLAPSED_RUN_LIMIT);
+    return [...retrying, ...otherActive, ...settled].slice(0, COLLAPSED_RUN_LIMIT);
 }
 function singleCollapsedLines(details, theme) {
     const run = details.runs[0];
     if (!run)
         return [theme.fg("muted", "Initializing…")];
     if (run.status === "running" || run.status === "queued") {
-        const isInitializing = run.status === "running" && run.usage.turns === 0 && run.usage.toolUses === 0 && run.liveText.length === 0;
-        const intent = run.status === "queued"
-            ? (run.currentActivity ?? "queued")
-            : isInitializing
-                ? "Initializing…"
-                : runIntent(run);
+        const retry = retryText(run);
+        const isInitializing = run.status === "running" &&
+            !retry &&
+            run.usage.turns === 0 &&
+            run.usage.toolUses === 0 &&
+            run.liveText.length === 0;
+        const rawIntent = retry ??
+            (run.status === "queued"
+                ? (run.currentActivity ?? statusWord(run.status))
+                : isInitializing
+                    ? "Initializing…"
+                    : runIntent(run));
+        const intent = excerpt(rawIntent, LIVE_TAIL_LIMIT);
         // No status marker here: the shell's call-level dot already covers
         // the whole card, and a single run has nothing to disambiguate.
         let status = theme.fg("dim", intent);
         if (run.status === "running" && !isInitializing) {
             status += theme.fg("dim", ` · ${runProgressText(run)}`);
+            if (run.usage.cost)
+                status += theme.fg("dim", ` · $${run.usage.cost.toFixed(3)}`);
             const elapsed = liveElapsed(run);
             if (elapsed)
                 status += theme.fg("dim", ` · ${elapsed}`);
         }
         const lines = [status];
         const evidence = runEvidence(run);
-        if (evidence && evidence !== intent)
+        if (evidence && evidence !== rawIntent)
             lines.push(`${theme.fg("accent", "›")} ${theme.fg("dim", excerpt(evidence, LIVE_TAIL_LIMIT))}`);
         const tail = liveTail(run);
         if (tail)
@@ -228,55 +356,45 @@ function singleCollapsedLines(details, theme) {
         return [theme.fg("error", excerpt(run.error, SINGLE_EXCERPT_LIMIT))];
     if (run.finalOutput)
         return [theme.fg("toolOutput", leadingSentences(run.finalOutput, SINGLE_EXCERPT_LIMIT))];
-    return [theme.fg("muted", run.status)];
+    return [theme.fg("muted", statusWord(run.status))];
 }
-function activitySummaryText(details) {
-    const toolCounts = new Map();
-    let activityCount = 0;
-    for (const run of details.runs) {
-        for (const activity of run.activities) {
-            activityCount++;
-            toolCounts.set(activity.toolName, (toolCounts.get(activity.toolName) ?? 0) + 1);
-        }
-    }
+// Deep-trimmed settled footer: turns and per-run breakdowns belong to the
+// expanded view. Parallel batches keep only whole-call numbers — the run
+// rows above already localize the work.
+function collapsedUsageText(details, extended) {
+    const usage = details.usage;
     const items = [];
-    let groupedCount = 0;
-    for (const group of ACTIVITY_GROUPS) {
-        const count = toolCounts.get(group.toolName) ?? 0;
-        if (count === 0)
-            continue;
-        groupedCount += count;
-        items.push(`${group.verb} ${count} ${count === 1 ? group.singular : group.plural}`);
+    if (usage.totalTokens)
+        items.push(`${formatTokens(usage.totalTokens)} tok`);
+    if (extended && usage.toolUses)
+        items.push(`${usage.toolUses} tool use${usage.toolUses === 1 ? "" : "s"}`);
+    if (extended && usage.contextTokens)
+        items.push(`ctx: ${formatTokens(usage.contextTokens)}`);
+    if (usage.cost)
+        items.push(`$${usage.cost.toFixed(3)}`);
+    if (details.endedAt !== undefined) {
+        items.push(formatDuration(Math.max(0, (details.endedAt - details.startedAt) / 1000)));
     }
-    const otherCount = activityCount - groupedCount;
-    if (otherCount > 0)
-        items.push(`used ${otherCount} other tool${otherCount === 1 ? "" : "s"}`);
-    if (items.length === 0)
-        return "";
-    const earlierCount = Math.max(0, details.usage.toolUses - activityCount);
-    if (earlierCount > 0)
-        items.push(`${earlierCount} earlier tool use${earlierCount === 1 ? "" : "s"}`);
-    return `${items[0][0].toUpperCase()}${items[0].slice(1)}${items
-        .slice(1)
-        .map((item) => ` · ${item}`)
-        .join("")}`;
-}
-function usageText(details, includeToolUses = true) {
+    return items.join(" · ");
+}
+function batchUsageText(details, isPartial) {
     const usage = details.usage;
     const items = [];
-    if (includeToolUses && usage.toolUses)
+    // The aggregate mixes settled and running runs while partial, and the
+    // running share is cache-inflated — quote the total only once settled.
+    if (!isPartial && usage.totalTokens)
+        items.push(`${formatTokens(usage.totalTokens)} tok`);
+    if (usage.toolUses)
         items.push(`${usage.toolUses} tool use${usage.toolUses === 1 ? "" : "s"}`);
     if (usage.turns)
         items.push(`${usage.turns} turn${usage.turns === 1 ? "" : "s"}`);
-    if (usage.output)
-        items.push(`↓${formatTokens(usage.output)}`);
     if (usage.contextTokens)
-        items.push(`ctx:${formatTokens(usage.contextTokens)}`);
+        items.push(`ctx: ${formatTokens(usage.contextTokens)}`);
     if (usage.cost)
         items.push(`$${usage.cost.toFixed(3)}`);
-    const duration = details.endedAt ? Math.max(0, (details.endedAt - details.startedAt) / 1000) : undefined;
-    if (duration !== undefined)
-        items.push(formatDuration(duration));
+    if (details.endedAt !== undefined) {
+        items.push(formatDuration(Math.max(0, (details.endedAt - details.startedAt) / 1000)));
+    }
     return items.join(" · ");
 }
 function formatTokens(value) {
@@ -287,55 +405,139 @@ function formatTokens(value) {
     return `${(value / 1_000_000).toFixed(1)}M`;
 }
 function formatDuration(seconds) {
-    if (seconds >= 90)
-        return `${Math.floor(seconds / 60)}m ${Math.round(seconds % 60)}s`;
+    const roundedSeconds = Math.round(seconds);
+    if (roundedSeconds >= 60)
+        return `${Math.floor(roundedSeconds / 60)}m ${roundedSeconds % 60}s`;
     return `${seconds.toFixed(seconds < 10 ? 1 : 0)}s`;
 }
-// A single run's title and usage would duplicate the call header and
-// the call-level usage line, so `single` drops both and folds the
-// duration into the metadata line instead. Multi-run sections carry a
-// numbered `──` header that matches the table of contents above them.
+function runDurationText(run) {
+    if (run.startedAt === undefined || run.endedAt === undefined)
+        return undefined;
+    return formatDuration(Math.max(0, (run.endedAt - run.startedAt) / 1000));
+}
+// One dim line per run: what it cost. Settled runs quote the real token
+// total; running runs skip it (cache-inflated mid-run) and tick elapsed
+// time instead. Batch sections fold model/thinking/cwd in here because
+// their `──` header already carries verdict and duration.
+function runMetricsText(run, includeIdentity) {
+    const usage = run.usage;
+    const settled = run.status !== "running" && run.status !== "queued";
+    const items = [];
+    if (includeIdentity) {
+        items.push(run.model);
+        if (run.thinking !== "off")
+            items.push(run.thinking);
+        if (run.cwd)
+            items.push(`cwd: ${run.cwd}`);
+    }
+    if (settled && usage.totalTokens)
+        items.push(`${formatTokens(usage.totalTokens)} tok`);
+    if (usage.toolUses)
+        items.push(`${usage.toolUses} tool use${usage.toolUses === 1 ? "" : "s"}`);
+    if (usage.turns)
+        items.push(`${usage.turns} turn${usage.turns === 1 ? "" : "s"}`);
+    if (usage.contextTokens)
+        items.push(`ctx: ${formatTokens(usage.contextTokens)}`);
+    if (usage.cost)
+        items.push(`$${usage.cost.toFixed(3)}`);
+    const duration = settled ? (includeIdentity ? undefined : runDurationText(run)) : liveElapsed(run);
+    if (duration)
+        items.push(duration);
+    return items.join(" · ");
+}
+// The details prompt is a 1KB bounded copy of the briefing; the preview
+// shows the first content lines (blank lines carry nothing at two lines
+// of budget) and never pretends to more fidelity than that.
+function promptSection(run, theme) {
+    const boundedPrompt = terminalOutputNotice(run.prompt);
+    const lines = boundedPrompt.text
+        .split("\n")
+        .map((line) => plainExcerpt(line.trim(), Number.MAX_SAFE_INTEGER))
+        .filter(Boolean);
+    const shown = lines.slice(0, PROMPT_PREVIEW_LINES);
+    const preview = shown.map((line) => theme.fg("dim", truncate(line, PROMPT_PREVIEW_LINE_LIMIT)));
+    // A one-line briefing clipped mid-sentence must still say it continues.
+    const clipped = shown.some((line) => line.length > PROMPT_PREVIEW_LINE_LIMIT);
+    const remaining = lines.length - shown.length;
+    const capped = boundedPrompt.truncated;
+    const section = [theme.fg("muted", "Prompt"), ...preview];
+    if (remaining > 0 || capped || clipped) {
+        let note = "… continues";
+        if (remaining > 0)
+            note += `, ${remaining} more line${remaining === 1 ? "" : "s"}`;
+        if (capped)
+            note += " · capped at 1KB";
+        section.push(theme.fg("muted", note));
+    }
+    return section;
+}
+// Each run expands into a report cover sheet: verdict and cost up top, a
+// bounded Prompt/Activity digest in the middle, then the full Report —
+// the one unbounded element, placed last so the card ends where reading
+// begins. Single runs skip the `──` header (the call header already names
+// them); batch sections carry a numbered header matching the contents
+// list above.
 function renderRunDetails(run, theme, single, index) {
     const container = new Container();
-    const duration = run.startedAt !== undefined && run.endedAt !== undefined
-        ? formatDuration(Math.max(0, (run.endedAt - run.startedAt) / 1000))
-        : undefined;
-    if (!single) {
+    const settled = run.status !== "running" && run.status !== "queued";
+    if (single) {
+        const identity = [run.model];
+        if (run.thinking !== "off")
+            identity.push(`${run.thinking} thinking`);
+        if (run.cwd)
+            identity.push(`cwd: ${run.cwd}`);
+        container.addChild(new Text(`${statusMarker(run.status, theme)} ${theme.fg(statusColor(run.status), statusWord(run.status))}${theme.fg("dim", ` · ${identity.join(" · ")}`)}`, 0, 0));
+    }
+    else {
         const label = index === undefined ? "" : `${index} · `;
-        container.addChild(new Text(`${theme.fg("dim", `── ${label}`)}${theme.fg("accent", displayAgentName(run.agent))}${theme.fg("dim", ` · ${truncate(run.description, 48)}`)}`, 0, 0));
+        const duration = settled ? runDurationText(run) : undefined;
+        container.addChild(new Text(`${theme.fg("dim", `── ${label}`)}${statusMarker(run.status, theme)} ${theme.fg("accent", displayAgentName(run.agent))}${theme.fg("dim", ` · ${truncate(run.description, 48)}`)}${duration ? theme.fg("dim", ` · ${duration}`) : ""}`, 0, 0));
+    }
+    if (run.status !== "queued") {
+        const metrics = runMetricsText(run, !single);
+        if (metrics)
+            container.addChild(new Text(theme.fg("dim", metrics), 0, 0));
     }
-    container.addChild(new Text(theme.fg("muted", "Task"), 0, 0));
-    container.addChild(new Text(theme.fg("dim", run.prompt), 0, 0));
+    const retry = retryText(run);
+    if (retry)
+        container.addChild(new Text(theme.fg("accent", retry), 0, 0));
+    container.addChild(new Spacer(1));
+    for (const line of promptSection(run, theme))
+        container.addChild(new Text(line, 0, 0));
     if (run.activities.length > 0) {
         container.addChild(new Spacer(1));
-        container.addChild(new Text(theme.fg("muted", "Activity"), 0, 0));
+        const total = run.usage.toolUses;
+        const label = total > run.activities.length ? `Activity · last ${run.activities.length} of ${total}` : "Activity";
+        container.addChild(new Text(theme.fg("muted", label), 0, 0));
         for (const activity of run.activities) {
-            const marker = activity.status === "succeeded"
-                ? theme.fg("success", "✓")
-                : activity.status === "failed"
-                    ? theme.fg("error", "×")
-                    : theme.fg("accent", "›");
-            let text = `${marker} ${theme.fg("toolOutput", excerpt(activity.summary, 96))}`;
-            if (activity.resultSummary) {
-                const color = activity.status === "failed" ? "error" : "dim";
-                text += ` ${theme.fg(color, `· ${excerpt(activity.resultSummary, 64)}`)}`;
+            // Deviation earns ink: × and › are marked, success rows are quiet
+            // one-liners without result echoes.
+            let text;
+            if (activity.status === "failed") {
+                text = `${theme.fg("error", "×")} ${theme.fg("toolOutput", excerpt(activity.summary, ACTIVITY_SUMMARY_LIMIT))}`;
+                if (activity.resultSummary) {
+                    text += ` ${theme.fg("error", `· ${excerpt(activity.resultSummary, ACTIVITY_RESULT_LIMIT)}`)}`;
+                }
             }
-            if (activity.endedAt !== undefined && activity.endedAt - activity.startedAt >= 1_000) {
+            else if (activity.status === "running") {
+                text = `${theme.fg("accent", "›")} ${theme.fg("toolOutput", excerpt(activity.summary, ACTIVITY_SUMMARY_LIMIT))}`;
+            }
+            else {
+                text = `  ${theme.fg("toolOutput", excerpt(activity.summary, ACTIVITY_SUMMARY_LIMIT))}`;
+            }
+            if (activity.endedAt !== undefined && activity.endedAt - activity.startedAt >= ACTIVITY_DURATION_MIN_MS) {
                 text += ` ${theme.fg("dim", `· ${formatDuration((activity.endedAt - activity.startedAt) / 1000)}`)}`;
             }
             container.addChild(new Text(text, 0, 0));
         }
     }
-    // The live tail is the "now" end of the timeline, so it sits after the
-    // activity list; once the run settles, Response takes its place.
+    // The live tail is the "now" end of the timeline; once the run settles,
+    // Report takes this slot without moving anything above it.
     if (run.status === "running" && run.liveText) {
-        const tail = run.liveText
-            .split("\n")
-            .map((line) => line.trim())
-            .filter(Boolean)
-            .slice(-4);
+        const tail = liveTailLines(run).slice(-EXPANDED_LIVE_TAIL_LINES);
         if (tail.length > 0) {
             container.addChild(new Spacer(1));
+            container.addChild(new Text(theme.fg("muted", "Working"), 0, 0));
             for (const line of tail) {
                 container.addChild(new Text(theme.fg("dim", excerpt(line, LIVE_TAIL_LIMIT)), 0, 0));
             }
@@ -343,28 +545,16 @@ function renderRunDetails(run, theme, single, index) {
     }
     if (run.error) {
         container.addChild(new Spacer(1));
-        container.addChild(new Text(theme.fg("error", `Error: ${run.error}`), 0, 0));
+        container.addChild(new Text(theme.fg("muted", "Error"), 0, 0));
+        container.addChild(new Text(theme.fg("error", run.error), 0, 0));
     }
     if (run.finalOutput) {
         container.addChild(new Spacer(1));
-        container.addChild(new Text(theme.fg("muted", "Response"), 0, 0));
-        container.addChild(new Markdown(run.finalOutput, 0, 0, getMarkdownTheme()));
-    }
-    const metadata = [
-        `${run.model} · ${run.thinking}`,
-        run.cwd ? `cwd: ${run.cwd}` : undefined,
-        run.usage.toolUses ? `${run.usage.toolUses} tool use${run.usage.toolUses === 1 ? "" : "s"}` : undefined,
-        run.usage.turns ? `${run.usage.turns} turn${run.usage.turns === 1 ? "" : "s"}` : undefined,
-        run.usage.output ? `↓${formatTokens(run.usage.output)}` : undefined,
-        run.usage.contextTokens ? `ctx:${formatTokens(run.usage.contextTokens)}` : undefined,
-        run.usage.cost ? `$${run.usage.cost.toFixed(3)}` : undefined,
-        single ? duration : undefined,
-    ]
-        .filter((item) => Boolean(item))
-        .join(" · ");
-    if (metadata) {
-        container.addChild(new Spacer(1));
-        container.addChild(new Text(theme.fg("dim", metadata), 0, 0));
+        const label = settled && run.status !== "completed" ? "Report · partial" : "Report";
+        container.addChild(new Text(theme.fg("muted", label), 0, 0));
+        container.addChild(new Markdown(run.finalOutput, 0, 0, getMarkdownTheme(), {
+            color: (text) => theme.fg("toolOutput", text),
+        }));
     }
     return container;
 }
@@ -391,33 +581,43 @@ export function renderSubagentResult(result, options, theme, isError) {
         const text = result.content.find((part) => part.type === "text");
         return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
     }
+    // The pre-resolution first paint carries no runs yet, in either mode.
+    if (details.runs.length === 0) {
+        return new Text(theme.fg("muted", "Initializing…"), 0, 0);
+    }
     if (!options.expanded) {
-        const lines = [];
         if (details.mode === "single") {
-            lines.push(...singleCollapsedLines(details, theme));
-        }
-        else {
-            let header = statusSummary(details);
-            if (options.isPartial) {
-                header += ` · ${formatDuration(Math.max(0, (Date.now() - details.startedAt) / 1000))}`;
+            const lines = singleCollapsedLines(details, theme);
+            if (!options.isPartial) {
+                const usage = collapsedUsageText(details, true);
+                if (usage)
+                    lines.push(theme.fg("dim", usage));
+                lines.push(theme.fg("muted", `(${keyHint("app.tools.expand", "to expand")})`));
             }
-            lines.push(theme.fg(isError ? "error" : options.isPartial ? "accent" : "muted", header));
-            const shown = selectCollapsedRuns(details.runs, Boolean(options.isPartial));
-            for (const run of shown)
-                lines.push(runLine(run, theme));
-            const hidden = details.runs.length - shown.length;
-            if (hidden > 0)
-                lines.push(theme.fg("muted", `+${hidden} more`));
+            return new Text(lines.join("\n"), 0, 0);
+        }
+        const container = new Container();
+        let header = statusSummary(details);
+        if (options.isPartial) {
+            header += ` · ${formatDuration(Math.max(0, (Date.now() - details.startedAt) / 1000))}`;
+        }
+        container.addChild(new Text(theme.fg(isError ? "error" : options.isPartial ? "accent" : "muted", header), 0, 0));
+        const shown = selectCollapsedRuns(details.runs, Boolean(options.isPartial));
+        // Stable ordinals (the run's task position, not its display slot)
+        // keep identity readable while active-first ordering reshuffles
+        // rows, and match the expanded section numbers.
+        for (const run of shown)
+            addRunSummary(container, run, theme, details.runs.indexOf(run) + 1);
+        const hidden = details.runs.length - shown.length;
+        if (hidden > 0)
+            container.addChild(new Text(theme.fg("muted", `+${hidden} more`), 0, 0));
+        if (!options.isPartial) {
+            const usage = collapsedUsageText(details, false);
+            if (usage)
+                container.addChild(new Text(theme.fg("dim", usage), 0, 0));
+            container.addChild(new Text(theme.fg("muted", `(${keyHint("app.tools.expand", "to expand")})`), 0, 0));
         }
-        const activitySummary = activitySummaryText(details);
-        if (activitySummary)
-            lines.push(theme.fg("dim", activitySummary));
-        const usage = usageText(details, !activitySummary);
-        if (usage)
-            lines.push(theme.fg("dim", usage));
-        if (!options.isPartial)
-            lines.push(theme.fg("muted", `(${keyHint("app.tools.expand", "to expand")})`));
-        return new Text(lines.join("\n"), 0, 0);
+        return container;
     }
     const container = new Container();
     const single = details.mode === "single" && details.runs.length === 1;
@@ -427,7 +627,7 @@ export function renderSubagentResult(result, options, theme, isError) {
         // numbers against the `──` section headers below makes an 8-run
         // batch navigable by eye.
         details.runs.forEach((run, index) => {
-            container.addChild(new Text(runLine(run, theme, index + 1), 0, 0));
+            addRunSummary(container, run, theme, index + 1);
         });
     }
     details.runs.forEach((run, index) => {
@@ -436,7 +636,7 @@ export function renderSubagentResult(result, options, theme, isError) {
         container.addChild(renderRunDetails(run, theme, single, single ? undefined : index + 1));
     });
     if (!single) {
-        const usage = usageText(details);
+        const usage = batchUsageText(details, Boolean(options.isPartial));
         if (usage) {
             container.addChild(new Spacer(1));
             container.addChild(new Text(theme.fg("dim", usage), 0, 0));