@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/tui/display.js

@@ -0,0 +1,282 @@
+import { hasText, nonemptyText } from "./text-values.js";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { formatTokens, formatDuration, formatModelThinking, formatToolCall, } from "../shared/formatters.js";
+import { getDisplayItems } from "../shared/utils.js";
+import { formatActivityLabel } from "../shared/status-format.js";
+import { acceptanceHumanAction } from "../runs/shared/acceptance.js";
+export function getTermWidth() {
+    return process.stdout.columns > 0 ? process.stdout.columns : 120;
+}
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+// Recognize terminal SGR control sequences so truncation retains active styling.
+// oxlint-disable-next-line no-control-regex
+const sgr = /^\u001b\[[0-9;]*m/;
+/**
+ * Truncate a line to maxWidth, preserving ANSI styling through the ellipsis.
+ *
+ * pi-tui's truncateToWidth adds \x1b[0m before ellipsis which resets all styling,
+ * causing background color bleed in the TUI. This implementation tracks active
+ * ANSI styles and re-applies them before the ellipsis.
+ *
+ * Uses Intl.Segmenter for proper Unicode/emoji handling (not char-by-char).
+ */
+export function truncLine(text, maxWidth) {
+    if (visibleWidth(text) <= maxWidth) {
+        return text;
+    }
+    const targetWidth = maxWidth - 1;
+    let result = "";
+    let currentWidth = 0;
+    let activeStyles = [];
+    let i = 0;
+    while (i < text.length) {
+        const ansiMatch = text.slice(i).match(sgr);
+        if (ansiMatch) {
+            const code = ansiMatch[0];
+            result += code;
+            if (code === "\x1b[0m" || code === "\x1b[m") {
+                activeStyles = [];
+            }
+            else {
+                activeStyles.push(code);
+            }
+            i += code.length;
+            continue;
+        }
+        let end = i;
+        while (end < text.length && !sgr.test(text.slice(end))) {
+            end++;
+        }
+        const textPortion = text.slice(i, end);
+        for (const seg of segmenter.segment(textPortion)) {
+            const grapheme = seg.segment;
+            const graphemeWidth = visibleWidth(grapheme);
+            if (currentWidth + graphemeWidth > targetWidth) {
+                return result + activeStyles.join("") + "…";
+            }
+            result += grapheme;
+            currentWidth += graphemeWidth;
+        }
+        i = end;
+    }
+    return result + activeStyles.join("") + "…";
+}
+const RUNNING_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const STATIC_RUNNING_GLYPH = "●";
+export function runningSeed(...values) {
+    let seed;
+    for (const value of values) {
+        if (value === undefined || !Number.isFinite(value)) {
+            continue;
+        }
+        seed = (seed ?? 0) + Math.trunc(value);
+    }
+    return seed;
+}
+export function runningGlyph(seed) {
+    if (seed === undefined) {
+        return STATIC_RUNNING_GLYPH;
+    }
+    return RUNNING_FRAMES[Math.abs(seed) % RUNNING_FRAMES.length] ?? STATIC_RUNNING_GLYPH;
+}
+export function progressRunningSeed(progress) {
+    if (!progress) {
+        return undefined;
+    }
+    return runningSeed(progress.index, progress.toolCount, progress.tokens, progress.durationMs, progress.lastActivityAt, progress.currentToolStartedAt, progress.turnCount);
+}
+export function extractOutputTarget(task) {
+    const writeToMatch = task.match(/\[Write to:\s*([^\]\n]+)\]/i);
+    if (hasText(writeToMatch?.[1]?.trim())) {
+        return writeToMatch[1].trim();
+    }
+    const findingsMatch = task.match(/Write your findings to:\s*(\S+)/i);
+    if (hasText(findingsMatch?.[1]?.trim())) {
+        return findingsMatch[1].trim();
+    }
+    const outputMatch = task.match(/[Oo]utput(?:\s+to)?\s*:\s*(\S+)/i);
+    if (hasText(outputMatch?.[1]?.trim())) {
+        return outputMatch[1].trim();
+    }
+    return undefined;
+}
+export function hasEmptyTextOutputWithoutOutputTarget(task, output) {
+    if (hasText(output.trim())) {
+        return false;
+    }
+    return !hasText(extractOutputTarget(task));
+}
+export function getToolCallLines(result, expanded) {
+    if (result.messages) {
+        return getDisplayItems(result.messages)
+            .filter((item) => item.type === "tool")
+            .map((item) => formatToolCall(item.name, item.args, expanded));
+    }
+    return (result.toolCalls?.map((toolCall) => (expanded ? toolCall.expandedText : toolCall.text)) ?? []);
+}
+export function snapshotNowForProgress(progress) {
+    if (progress.currentToolStartedAt !== undefined) {
+        return progress.currentToolStartedAt + progress.durationMs;
+    }
+    return progress.lastActivityAt;
+}
+export function formatCurrentToolLine(progress, availableWidth, expanded, snapshotNow) {
+    if (!hasText(progress.currentTool)) {
+        return undefined;
+    }
+    const maxToolArgsLen = Math.max(50, availableWidth - 20);
+    const toolArgsPreview = toolArgsText(progress.currentToolArgs, maxToolArgsLen, expanded);
+    const durationSuffix = progress.currentToolStartedAt !== undefined && snapshotNow !== undefined
+        ? ` | ${formatDuration(Math.max(0, snapshotNow - progress.currentToolStartedAt))}`
+        : "";
+    return hasText(toolArgsPreview)
+        ? `${progress.currentTool}: ${toolArgsPreview}${durationSuffix}`
+        : `${progress.currentTool}${durationSuffix}`;
+}
+function toolArgsText(args, limit, expanded) {
+    if (!hasText(args)) {
+        return "";
+    }
+    return expanded || args.length <= limit ? args : `${args.slice(0, limit)}...`;
+}
+export function buildLiveStatusLine(progress, snapshotNow) {
+    if (progress.lastActivityAt !== undefined && snapshotNow !== undefined) {
+        return formatActivityLabel(progress.lastActivityAt, progress.activityState, snapshotNow);
+    }
+    if (progress.activityState === "needs_attention") {
+        return "needs attention";
+    }
+    if (progress.lastActivityAt !== undefined) {
+        return "active";
+    }
+    return undefined;
+}
+export function themeBold(theme, text) {
+    return theme.bold(text);
+}
+export function statJoin(theme, parts) {
+    return parts
+        .filter(Boolean)
+        .map((part) => theme.fg("dim", part))
+        .join(` ${theme.fg("dim", "·")} `);
+}
+export function formatTokenStat(tokens) {
+    return `${formatTokens(tokens)} token`;
+}
+export function formatToolUseStat(count) {
+    return `${count} tool use${count === 1 ? "" : "s"}`;
+}
+export function formatProgressStats(theme, progress, includeDuration = true) {
+    if (!progress) {
+        return "";
+    }
+    const parts = [];
+    if (progress.toolCount > 0) {
+        parts.push(formatToolUseStat(progress.toolCount));
+    }
+    if (progress.tokens > 0) {
+        parts.push(formatTokenStat(progress.tokens));
+    }
+    if (includeDuration && progress.durationMs > 0) {
+        parts.push(formatDuration(progress.durationMs));
+    }
+    return statJoin(theme, parts);
+}
+export function firstOutputLine(text) {
+    return (text
+        .split("\n")
+        .find((line) => hasText(line.trim()))
+        // One-line status previews reject ASCII controls while retaining ordinary whitespace.
+        // oxlint-disable-next-line no-control-regex
+        ?.replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "")
+        .trim() ?? "");
+}
+function formatAcceptanceStatus(result) {
+    const acceptance = result.acceptance;
+    if (!hasText(acceptance?.status) || acceptance.status === "not-required") {
+        return undefined;
+    }
+    const finalization = acceptance.finalization
+        ? ` · finalization: ${acceptance.finalization.status} after ${acceptance.finalization.turns.length}/${acceptance.finalization.maxTurns} turns`
+        : "";
+    return `acceptance: ${acceptance.status}${finalization}`;
+}
+function stoppedStatusLine(result, output) {
+    if (result.detached === true) {
+        return hasText(result.detachedReason) ? `Detached: ${result.detachedReason}` : "Detached";
+    }
+    if (result.timedOut === true) {
+        return `Timed out${hasText(result.error) ? `: ${result.error}` : ""}`;
+    }
+    if (result.interrupted === true) {
+        return "Paused";
+    }
+    if (result.exitCode !== 0) {
+        return `Error: ${result.error ?? nonemptyText(firstOutputLine(output)) ?? `exit ${result.exitCode}`}`;
+    }
+    return;
+}
+export function resultStatusLine(result, output) {
+    const stopped = stoppedStatusLine(result, output);
+    if (stopped !== undefined) {
+        return stopped;
+    }
+    if (result.acceptance?.status === "blocked") {
+        const action = acceptanceHumanAction(result.acceptance)?.split("\n").at(0) ?? "";
+        return `Needs your action · acceptance incomplete · ${action}`;
+    }
+    const acceptance = formatAcceptanceStatus(result);
+    if (hasText(acceptance)) {
+        return `Done · ${acceptance}`;
+    }
+    if (hasEmptyTextOutputWithoutOutputTarget(result.task, output)) {
+        return "Done (no text output)";
+    }
+    return "Done";
+}
+export function resultGlyph(result, output, theme, options = {}) {
+    const running = options.running ?? result.progress?.status === "running";
+    const seed = options.seed ?? progressRunningSeed(result.progress ?? result.progressSummary);
+    if (running) {
+        return theme.fg("accent", runningGlyph(seed));
+    }
+    const stopped = stoppedGlyph(result, theme);
+    if (stopped !== undefined) {
+        return stopped;
+    }
+    if (hasEmptyTextOutputWithoutOutputTarget(result.task, output)) {
+        return theme.fg("warning", "✓");
+    }
+    return theme.fg("success", "✓");
+}
+function stoppedGlyph(result, theme) {
+    if (result.detached === true) {
+        return theme.fg("warning", "■");
+    }
+    if (result.timedOut === true) {
+        return theme.fg("error", "✗");
+    }
+    if (result.interrupted === true) {
+        return theme.fg("warning", "■");
+    }
+    if (result.exitCode !== 0) {
+        return theme.fg("error", "✗");
+    }
+    if (result.acceptance?.status === "blocked") {
+        return theme.fg("warning", "■");
+    }
+    return;
+}
+export function compactCurrentActivity(progress) {
+    const snapshotNow = snapshotNowForProgress(progress);
+    return (formatCurrentToolLine(progress, getTermWidth() - 4, false, snapshotNow) ??
+        buildLiveStatusLine(progress, snapshotNow) ??
+        "thinking…");
+}
+export function modelThinkingBadge(theme, model, thinking) {
+    const label = formatModelThinking(model, thinking);
+    return hasText(label) ? theme.fg("dim", ` (${label})`) : "";
+}
+export function modelStat(theme, model) {
+    return hasText(model) ? ` ${theme.fg("dim", "·")} ${theme.fg("dim", model)}` : "";
+}

package/dist/tui/editor-viewport.js

@@ -0,0 +1,18 @@
+import { CURSOR_MARKER } from "@earendil-works/pi-tui";
+/** Bound native editor output without replacing its cursor or input handling. */
+export function editorViewport(editor, height) {
+    let offset = 0;
+    return {
+        invalidate: () => editor.invalidate(),
+        render(width) {
+            const lines = editor.render(width), rows = height();
+            const cursor = lines.findIndex((line) => line.includes(CURSOR_MARKER));
+            if (cursor >= 0) {
+                offset = Math.max(0, cursor - rows + 1);
+            }
+            offset = Math.max(0, Math.min(offset, lines.length - rows));
+            return lines.slice(offset, offset + rows);
+        },
+        handleMouse: (event) => editor.handleMouse({ ...event, y: event.y + offset }),
+    };
+}

package/dist/tui/expanded-content.js

@@ -0,0 +1,87 @@
+import { getMarkdownTheme, keyText } from "@earendil-works/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+import { formatUsage, shortenPath } from "../shared/formatters.js";
+import { formatAgentProcessExit } from "../shared/status-format.js";
+import { getToolCallLines, buildLiveStatusLine, formatCurrentToolLine, snapshotNowForProgress, getTermWidth, } from "./display.js";
+export function liveContent(progress, theme, indent, artifact) {
+    const c = new Container(), width = getTermWidth() - 4;
+    const now = snapshotNowForProgress(progress);
+    const tool = formatCurrentToolLine(progress, width, true, now), live = buildLiveStatusLine(progress, now);
+    if (tool !== undefined) {
+        c.addChild(new Text(theme.fg("warning", `${indent}> ${tool}`), 0, 0));
+    }
+    if (live !== undefined) {
+        c.addChild(new Text(theme.fg("accent", `${indent}${live}`), 0, 0));
+    }
+    const expand = keyText("app.tools.expand");
+    if (expand.length > 0) {
+        c.addChild(new Text(theme.fg("accent", `${indent}Press ${expand} for live detail`), 0, 0));
+    }
+    if (artifact !== undefined) {
+        c.addChild(new Text(theme.fg("dim", `${indent}${indent.length === 0 ? "Artifacts" : "artifacts"}: ${shortenPath(artifact)}`), 0, 0));
+    }
+    c.addChild(recentContent(progress, theme, indent));
+    return c;
+}
+function recentContent(progress, theme, indent) {
+    const c = new Container(), toolIndent = indent.length === 0 ? "" : "      ", outputIndent = indent.length === 0 ? "  " : "      ";
+    for (const t of progress.recentTools?.slice(-3) ?? []) {
+        c.addChild(new Text(theme.fg("dim", `${toolIndent}${t.tool}: ${t.args}`), 0, 0));
+    }
+    for (const line of (progress.recentOutput ?? []).slice(-5)) {
+        c.addChild(new Text(theme.fg("dim", `${outputIndent}${line}`), 0, 0));
+    }
+    return c;
+}
+export function resultContent(r, theme, output, toolIndent = "") {
+    const c = new Container(), toolLines = getToolCallLines(r, true);
+    for (const line of toolLines) {
+        c.addChild(new Text(theme.fg("muted", `${toolIndent}${line}`), 0, 0));
+    }
+    if (toolLines.length > 0) {
+        c.addChild(new Spacer(1));
+    }
+    if (r.error !== undefined && r.error.length > 0 && !output.includes(r.error)) {
+        c.addChild(new Text(theme.fg("error", r.error), 0, 0));
+    }
+    if (output.length > 0) {
+        c.addChild(new Markdown(output, 0, 0, getMarkdownTheme()));
+    }
+    return c;
+}
+export function profileContent(r, theme, indent = "") {
+    const c = new Container(), skills = r.skills ?? [], attempts = r.attemptedModels ?? [];
+    const label = (word) => (indent.length === 0 ? word : word.toLowerCase());
+    if (skills.length > 0) {
+        c.addChild(new Text(theme.fg("dim", `${indent}${label("Skills")}: ${skills.join(", ")}`), 0, 0));
+    }
+    if (r.skillsWarning !== undefined && r.skillsWarning.length > 0) {
+        c.addChild(new Text(theme.fg("warning", `${indent}Warning: ${r.skillsWarning}`), 0, 0));
+    }
+    if (attempts.length > 1) {
+        const title = indent.length === 0 ? "Fallbacks" : "model attempts";
+        c.addChild(new Text(theme.fg("dim", `${indent}${title}: ${attempts.join(" → ")}`), 0, 0));
+    }
+    return c;
+}
+export function accountingContent(r, theme, running) {
+    const c = new Container();
+    const accounting = [
+        formatUsage(r.usage, r.model),
+        r.accounting?.state === "incomplete" ? "accounting incomplete · reported totals only" : "",
+    ]
+        .filter(Boolean)
+        .join(" · ");
+    c.addChild(new Text(theme.fg("dim", accounting), 0, 0));
+    if (!running) {
+        c.addChild(new Text(theme.fg("dim", formatAgentProcessExit(r.agentProcessExit)), 0, 0));
+    }
+    if (r.sessionFile !== undefined && r.sessionFile.length > 0) {
+        c.addChild(new Text(theme.fg("dim", `Session: ${shortenPath(r.sessionFile)}`), 0, 0));
+    }
+    if (!running && r.artifactPaths) {
+        c.addChild(new Spacer(1));
+        c.addChild(new Text(theme.fg("dim", `Artifacts: ${shortenPath(r.artifactPaths.outputPath)}`), 0, 0));
+    }
+    return c;
+}

package/dist/tui/expanded-multi.js

@@ -0,0 +1,170 @@
+import { hasText, nonemptyText } from "./text-values.js";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { formatDuration, formatTokens, shortenPath } from "../shared/formatters.js";
+import { getSingleResultOutput } from "../shared/utils.js";
+import { extractOutputTarget, hasEmptyTextOutputWithoutOutputTarget, modelThinkingBadge, } from "./display.js";
+import { expandedResultStatus, resultProgress, totalProgress, workflowFacts, } from "./result-facts.js";
+import { liveContent, profileContent, resultContent } from "./expanded-content.js";
+import { buildMultiProgressLabel, isDoneResult, resultRowLabel, renderEntries, workflowGraphHasStatus, } from "./workflow-labels.js";
+import { widgetStepStatus } from "./widget-status.js";
+function statusColor(status) {
+    if (status === "failed") {
+        return "error";
+    }
+    return status === "done" || status === "ok" ? "success" : "warning";
+}
+function chainVisualization(d, theme, running) {
+    if ((d.chainAgents?.length ?? 0) === 0) {
+        return;
+    }
+    const emptyWarning = d.intercomDelivery?.delivered !== true;
+    return d.chainAgents
+        ?.map((agent, i) => {
+        let status = chainResultStatus(d.results.at(i), emptyWarning);
+        if (status === "pending" && i === (d.currentStepIndex ?? d.results.length) && running) {
+            status = "running";
+        }
+        const color = status === "pending" ? "dim" : statusColor(status);
+        return `${theme.fg(color, status)} ${agent}`;
+    })
+        .join(theme.fg("dim", " → "));
+}
+function chainResultStatus(result, emptyWarning) {
+    if (result === undefined) {
+        return "pending";
+    }
+    const complete = isDoneResult(result), status = expandedResultStatus(result, false, emptyWarning && complete);
+    return status === "done" && !complete ? "pending" : status;
+}
+function hasFailedResult(results) {
+    return results.some((r) => (r.exitCode !== 0 || r.timedOut === true) &&
+        r.interrupted !== true &&
+        r.detached !== true &&
+        r.progress?.status !== "running");
+}
+function hasEmptySuccess(results) {
+    return results.some((r) => r.exitCode === 0 &&
+        r.progress?.status !== "running" &&
+        hasEmptyTextOutputWithoutOutputTarget(r.task, getSingleResultOutput(r)));
+}
+function multiIcon(d, theme, isError) {
+    const facts = workflowFacts(d, isError);
+    if (facts.running) {
+        return theme.fg("warning", "running");
+    }
+    const failure = isError || hasFailedResult(d.results);
+    if (failure || (facts.failed && workflowGraphHasStatus(d, ["failed", "timed-out"]))) {
+        return theme.fg("error", "failed");
+    }
+    if (facts.blocked) {
+        return theme.fg("warning", "needs your action");
+    }
+    if (facts.paused) {
+        return theme.fg("warning", "paused");
+    }
+    return successIcon(d.results, d.intercomDelivery?.delivered === true, theme);
+}
+function successIcon(results, delivered, theme) {
+    const empty = !delivered && hasEmptySuccess(results);
+    return theme.fg(empty ? "warning" : "success", empty ? "warning" : "ok");
+}
+function placeholder(entry, theme) {
+    const c = new Container();
+    c.addChild(new Text(`  ${widgetStepStatus(entry.status, theme)} ${entry.stepLabel}: ${theme.bold(entry.agentName)}`, 0, 0));
+    c.addChild(new Text(theme.fg(entry.status === "failed" ? "error" : "dim", `    status: ${entry.status}`), 0, 0));
+    if (entry.error !== undefined && entry.error.length > 0) {
+        c.addChild(new Text(theme.fg("error", `    error: ${entry.error}`), 0, 0));
+    }
+    c.addChild(new Spacer(1));
+    return c;
+}
+function resultRow(d, entry, theme, label) {
+    const c = new Container(), r = d.results.at(entry.resultIndex);
+    if (!r) {
+        const pending = label.hasParallelInChain
+            ? resultRowLabel(d, label, entry.resultIndex, entry.rowNumber)
+            : `${label.itemTitle} ${entry.rowNumber}`;
+        c.addChild(new Text(theme.fg("dim", `  ${pending}: ${entry.agentName}`), 0, 0));
+        c.addChild(new Text(theme.fg("dim", "    status: pending"), 0, 0));
+        c.addChild(new Spacer(1));
+        return c;
+    }
+    const progress = resultProgress(d, entry.resultIndex), running = progress?.status === "running";
+    const number = typeof progress?.index === "number" ? progress.index + 1 : entry.resultIndex + 1;
+    const status = expandedResultStatus(r, running, d.intercomDelivery?.delivered !== true);
+    c.addChild(resultHeading(r, theme, {
+        progress,
+        status,
+        label: resultRowLabel(d, label, entry.resultIndex, number),
+    }));
+    c.addChild(resultBody(r, theme, progress));
+    c.addChild(new Spacer(1));
+    return c;
+}
+function resultHeading(r, theme, row) {
+    const progress = row.progress, running = progress?.status === "running";
+    const stats = progress
+        ? ` | ${progress.toolCount} tools, ${formatDuration(progress.durationMs)}`
+        : "";
+    const name = running ? theme.bold(theme.fg("warning", r.agent)) : theme.bold(r.agent);
+    return new Text(`${theme.fg(statusColor(row.status), row.status)} ${row.label}: ${name}${modelThinkingBadge(theme, r.model)}${stats}`, 0, 0);
+}
+function resultBody(r, theme, progress) {
+    const c = new Container();
+    c.addChild(new Text(theme.fg("dim", `    task: ${r.task}`), 0, 0));
+    const target = extractOutputTarget(r.task);
+    if (target !== undefined) {
+        c.addChild(new Text(theme.fg("dim", `    output: ${target}`), 0, 0));
+    }
+    c.addChild(profileContent(r, theme, "    "));
+    if (progress?.status === "running") {
+        const skills = progress.skills ?? [];
+        if (skills.length > 0) {
+            c.addChild(new Text(theme.fg("accent", `    skills: ${skills.join(", ")}`), 0, 0));
+        }
+        c.addChild(liveContent(progress, theme, "    ", r.artifactPaths?.outputPath));
+    }
+    else {
+        if (r.artifactPaths) {
+            c.addChild(new Text(theme.fg("dim", `    artifacts: ${shortenPath(r.artifactPaths.outputPath)}`), 0, 0));
+        }
+        c.addChild(resultContent(r, theme, nonemptyText(r.truncation?.text) ?? getSingleResultOutput(r), "      "));
+    }
+    return c;
+}
+function multiHeading(d, theme, headerLabel, isError) {
+    const total = totalProgress(d) ?? { toolCount: 0, tokens: 0, durationMs: 0 };
+    const stats = total.toolCount !== 0 || total.tokens !== 0
+        ? ` | ${total.toolCount} tools, ${formatTokens(total.tokens)} tok, ${formatDuration(total.durationMs)}`
+        : "";
+    const badge = d.context === "fork" ? theme.fg("warning", " [fork]") : "";
+    return new Text(`${multiIcon(d, theme, isError)} ${theme.fg("toolTitle", theme.bold(d.mode))}${badge} · ${headerLabel}${stats}`, 0, 0);
+}
+export function renderMultiExpanded(d, theme, options) {
+    const c = new Container(), facts = workflowFacts(d, options.isError);
+    const builtLabel = buildMultiProgressLabel(d, facts.running);
+    const label = {
+        ...builtLabel,
+        showActiveGroupOnly: builtLabel.showActiveGroupOnly && facts.running,
+    };
+    c.addChild(multiHeading(d, theme, label.headerLabel, options.isError));
+    if (options.showRun && d.runId !== undefined) {
+        c.addChild(new Text(theme.fg("dim", `Run: ${d.runId}`), 0, 0));
+    }
+    const chain = label.hasParallelInChain ? undefined : chainVisualization(d, theme, facts.running);
+    if (hasText(chain)) {
+        c.addChild(new Text(`  ${chain}`, 0, 0));
+    }
+    if (hasText(options.receipt)) {
+        c.addChild(new Text(options.receipt, 0, 0));
+    }
+    c.addChild(new Spacer(1));
+    for (const entry of renderEntries(d, label)) {
+        c.addChild(entry.kind === "placeholder" ? placeholder(entry, theme) : resultRow(d, entry, theme, label));
+    }
+    if (d.artifacts) {
+        c.addChild(new Spacer(1));
+        c.addChild(new Text(theme.fg("dim", `Artifacts dir: ${shortenPath(d.artifacts.dir)}`), 0, 0));
+    }
+    return c;
+}

package/dist/tui/expanded-single.js

@@ -0,0 +1,65 @@
+import { hasText, nonemptyText } from "./text-values.js";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { formatDuration, formatTokens } from "../shared/formatters.js";
+import { getSingleResultOutput } from "../shared/utils.js";
+import { accountingContent, liveContent, profileContent, resultContent, } from "./expanded-content.js";
+function singleStatus(r, theme, isError) {
+    if (!isError && r.progress?.status === "running") {
+        return theme.fg("warning", "running");
+    }
+    if (isError || r.timedOut === true || r.exitCode !== 0) {
+        return theme.fg("error", "failed");
+    }
+    return completedStatus(r, theme);
+}
+function completedStatus(r, theme) {
+    if (r.detached === true) {
+        return theme.fg("warning", "detached");
+    }
+    if (r.interrupted === true) {
+        return theme.fg("warning", "paused");
+    }
+    if (r.acceptance?.status === "blocked") {
+        return theme.fg("warning", "needs your action");
+    }
+    return theme.fg("success", "ok");
+}
+function singleHeading(context, r, theme, isError) {
+    const running = !isError && r.progress?.status === "running";
+    const progress = running ? r.progress : r.progressSummary;
+    const progressInfo = progress
+        ? ` | ${progress.toolCount} tools, ${formatTokens(progress.tokens)} tok, ${formatDuration(progress.durationMs)}`
+        : "";
+    const contextBadge = context === "fork" ? theme.fg("warning", " [fork]") : "";
+    return new Text(`${singleStatus(r, theme, isError)} ${theme.fg("toolTitle", theme.bold(r.agent))}${contextBadge}${progressInfo}`, 0, 0);
+}
+function singleLive(r, theme, running) {
+    const c = new Container();
+    if (running && r.progress !== undefined) {
+        const live = liveContent(r.progress, theme, "", r.artifactPaths?.outputPath);
+        c.addChild(live);
+        if (live.children.length > 0) {
+            c.addChild(new Spacer(1));
+        }
+    }
+    return c;
+}
+export function renderSingleExpanded(d, r, theme, options) {
+    const c = new Container(), running = !options.isError && r.progress?.status === "running";
+    c.addChild(singleHeading(d.context, r, theme, options.isError));
+    if (options.showRun && d.runId !== undefined) {
+        c.addChild(new Text(theme.fg("dim", `Run: ${d.runId}`), 0, 0));
+    }
+    c.addChild(new Spacer(1));
+    c.addChild(new Text(theme.fg("dim", `Task: ${r.task}`), 0, 0));
+    c.addChild(new Spacer(1));
+    c.addChild(singleLive(r, theme, running));
+    c.addChild(resultContent(r, theme, nonemptyText(r.truncation?.text) ?? getSingleResultOutput(r)));
+    if (hasText(options.receipt)) {
+        c.addChild(new Text(options.receipt, 0, 0));
+    }
+    c.addChild(new Spacer(1));
+    c.addChild(profileContent(r, theme));
+    c.addChild(accountingContent(r, theme, running));
+    return c;
+}