@bastani/atomic 0.8.31-alpha.4 → 0.9.0-alpha.1

package/dist/builtin/subagents/src/tui/render-result.ts

@@ -0,0 +1,390 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { getMarkdownTheme } from "@bastani/atomic";
+import { Container, Markdown, Spacer, Text, type Component } from "@earendil-works/pi-tui";
+import type { AgentProgress, AsyncJobStep, Details } from "../shared/types.ts";
+import { formatDuration, formatTokens, formatUsage, shortenPath } from "../shared/formatters.ts";
+import { getSingleResultOutput } from "../shared/utils.ts";
+import { getTermWidth, truncLine, type Theme } from "./render-layout.ts";
+import { clearResultAnimationTimer, ensureResultAnimation, type ResultAnimationContext } from "./render-result-animation.ts";
+import { renderMultiCompact, renderSingleCompact } from "./render-result-compact.ts";
+import { buildChainRenderEntries, buildMultiProgressLabel, resultRowLabel, workflowGraphHasStatus, type ChainRenderEntry } from "./render-chain-graph.ts";
+import { isRunningSubagentResult, subagentResultRenderKey } from "./render-stable-output.ts";
+import { modelThinkingBadge, widgetStepStatus } from "./render-event-formatting.ts";
+import {
+	buildLiveStatusLine,
+	displayProgressDurationMs,
+	extractOutputTarget,
+	formatCurrentToolLine,
+	getToolCallLines,
+	hasEmptyTextOutputWithoutOutputTarget,
+	snapshotNowForProgress,
+} from "./render-status-progress.ts";
+
+export function renderLiveSubagentResult(
+	result: AgentToolResult<Details>,
+	options: { expanded: boolean; isPartial: boolean },
+	theme: Theme,
+	context: ResultAnimationContext,
+): Component {
+	const nextKey = subagentResultRenderKey(result, options);
+	if (context.state.subagentResultSnapshotKey !== nextKey) {
+		const frameNow = Date.now();
+		context.state.subagentResultSnapshotKey = nextKey;
+		context.state.subagentResultSnapshotNow = frameNow;
+		context.state.subagentResultSpinnerFrameNow = frameNow;
+	}
+	context.state.subagentResultSnapshotNow ??= Date.now();
+	context.state.subagentResultSpinnerFrameNow ??= context.state.subagentResultSnapshotNow;
+	// Foreground subagent results render inside chat scrollback. Keep semantic
+	// content time stable between tool/progress updates, but let the spinner tick
+	// independently. That limits timer-driven diffs to spinner glyph cells instead
+	// of updating elapsed/tool/activity text and causing broad chatbox churn.
+	if (options.isPartial && isRunningSubagentResult(result)) {
+		ensureResultAnimation(context);
+	} else {
+		clearResultAnimationTimer(context);
+	}
+	return renderSubagentResult(result, {
+		...options,
+		now: context.state.subagentResultSnapshotNow,
+		spinnerNow: context.state.subagentResultSpinnerFrameNow,
+	}, theme);
+}
+
+/**
+ * Render a subagent result
+ */
+export function renderSubagentResult(
+	result: AgentToolResult<Details>,
+	options: { expanded: boolean; now?: number; spinnerNow?: number },
+	theme: Theme,
+): Component {
+	const d = result.details;
+	if (!d || !d.results.length) {
+		const t = result.content[0];
+		const text = t?.type === "text" ? t.text : "(no output)";
+		const contextPrefix = d?.context === "fork" ? `${theme.fg("warning", "[fork]")} ` : "";
+		return new Text(truncLine(`${contextPrefix}${text}`, getTermWidth() - 4), 0, 0);
+	}
+
+	const expanded = options.expanded;
+	const mdTheme = getMarkdownTheme();
+
+	if (d.mode === "single" && d.results.length === 1) {
+		const r = d.results[0];
+		if (!expanded) return renderSingleCompact(d, r, theme, options.now, options.spinnerNow);
+		const isRunning = r.progress?.status === "running";
+		const icon = isRunning
+			? theme.fg("warning", "running")
+			: r.detached
+				? theme.fg("warning", "detached")
+				: r.exitCode === 0
+					? theme.fg("success", "ok")
+					: theme.fg("error", "failed");
+		const contextBadge = d.context === "fork" ? theme.fg("warning", " [fork]") : "";
+		const output = r.truncation?.text || getSingleResultOutput(r);
+
+		const progressInfo = isRunning && r.progress
+			? ` | ${r.progress.toolCount} tools, ${formatTokens(r.progress.tokens)} tok, ${formatDuration(displayProgressDurationMs(r.progress, options.now))}`
+			: r.progressSummary
+				? ` | ${r.progressSummary.toolCount} tools, ${formatTokens(r.progressSummary.tokens)} tok, ${formatDuration(r.progressSummary.durationMs)}`
+				: "";
+
+		const w = getTermWidth() - 4;
+		const fit = (text: string) => expanded ? text : truncLine(text, w);
+		const toolCallLines = getToolCallLines(r, expanded);
+		const c = new Container();
+		c.addChild(new Text(fit(`${icon} ${theme.fg("toolTitle", theme.bold(r.agent))}${contextBadge}${progressInfo}`), 0, 0));
+		c.addChild(new Spacer(1));
+		const taskMaxLen = Math.max(20, w - 8);
+		const taskPreview = expanded || r.task.length <= taskMaxLen
+			? r.task
+			: `${r.task.slice(0, taskMaxLen)}...`;
+		c.addChild(
+			new Text(fit(theme.fg("dim", `Task: ${taskPreview}`)), 0, 0),
+		);
+		c.addChild(new Spacer(1));
+
+		if (isRunning && r.progress) {
+			const progressSnapshotNow = snapshotNowForProgress(r.progress, options.now);
+			const toolLine = formatCurrentToolLine(r.progress, w, expanded, progressSnapshotNow);
+			if (toolLine) {
+				c.addChild(new Text(fit(theme.fg("warning", `> ${toolLine}`)), 0, 0));
+			}
+			const liveStatusLine = buildLiveStatusLine(r.progress, progressSnapshotNow);
+			if (liveStatusLine) {
+				c.addChild(new Text(fit(theme.fg("accent", liveStatusLine)), 0, 0));
+			}
+			c.addChild(new Text(fit(theme.fg("accent", "Press ctrl+o for live detail")), 0, 0));
+			if (r.artifactPaths) {
+				c.addChild(new Text(fit(theme.fg("dim", `Artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
+			}
+			if (r.progress.recentTools?.length) {
+				for (const t of r.progress.recentTools.slice(-3)) {
+					const maxArgsLen = Math.max(40, w - 24);
+					const argsPreview = expanded || t.args.length <= maxArgsLen
+						? t.args
+						: `${t.args.slice(0, maxArgsLen)}...`;
+					c.addChild(new Text(fit(theme.fg("dim", `${t.tool}: ${argsPreview}`)), 0, 0));
+				}
+			}
+			for (const line of (r.progress.recentOutput ?? []).slice(-5)) {
+				c.addChild(new Text(fit(theme.fg("dim", `  ${line}`)), 0, 0));
+			}
+			if (toolLine || liveStatusLine || r.progress.recentTools?.length || r.progress.recentOutput?.length || r.artifactPaths) {
+				c.addChild(new Spacer(1));
+			}
+		}
+
+		if (expanded) {
+			for (const line of toolCallLines) {
+				c.addChild(new Text(fit(theme.fg("muted", line)), 0, 0));
+			}
+			if (toolCallLines.length) c.addChild(new Spacer(1));
+		}
+
+		if (output) c.addChild(new Markdown(output, 0, 0, mdTheme));
+		c.addChild(new Spacer(1));
+		if (r.skills?.length) {
+			c.addChild(new Text(fit(theme.fg("dim", `Skills: ${r.skills.join(", ")}`)), 0, 0));
+		}
+		if (r.skillsWarning) {
+			c.addChild(new Text(fit(theme.fg("warning", `Warning: ${r.skillsWarning}`)), 0, 0));
+		}
+		if (r.attemptedModels && r.attemptedModels.length > 1) {
+			c.addChild(new Text(fit(theme.fg("dim", `Fallbacks: ${r.attemptedModels.join(" → ")}`)), 0, 0));
+		}
+		c.addChild(new Text(fit(theme.fg("dim", formatUsage(r.usage, r.model))), 0, 0));
+		if (r.sessionFile) {
+			c.addChild(new Text(fit(theme.fg("dim", `Session: ${shortenPath(r.sessionFile)}`)), 0, 0));
+		}
+
+		if (!isRunning && r.artifactPaths) {
+			c.addChild(new Spacer(1));
+			c.addChild(new Text(fit(theme.fg("dim", `Artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
+		}
+		return c;
+	}
+
+	if (!expanded) return renderMultiCompact(d, theme, options.now, options.spinnerNow);
+
+	const hasRunning = d.progress?.some((p) => p.status === "running")
+		|| d.results.some((r) => r.progress?.status === "running")
+		|| workflowGraphHasStatus(d, ["running"]);
+	const ok = d.results.filter((r) => r.progress?.status === "completed" || (r.exitCode === 0 && r.progress?.status !== "running")).length;
+	const hasEmptyWithoutTarget = d.results.some((r) =>
+		r.exitCode === 0
+		&& r.progress?.status !== "running"
+		&& hasEmptyTextOutputWithoutOutputTarget(r.task, getSingleResultOutput(r)),
+	);
+	const hasWorkflowFailure = workflowGraphHasStatus(d, ["failed"]);
+	const hasWorkflowPause = workflowGraphHasStatus(d, ["paused", "detached"]);
+	const icon = hasRunning
+		? theme.fg("warning", "running")
+		: hasEmptyWithoutTarget
+			? theme.fg("warning", "warning")
+			: hasWorkflowFailure
+				? theme.fg("error", "failed")
+				: hasWorkflowPause
+					? theme.fg("warning", "paused")
+					: ok === d.results.length
+						? theme.fg("success", "ok")
+						: theme.fg("error", "failed");
+
+	const totalSummary =
+		d.progressSummary ||
+		d.results.reduce(
+			(acc, r) => {
+				const prog = r.progress || r.progressSummary;
+				if (prog) {
+					acc.toolCount += prog.toolCount;
+					acc.tokens += prog.tokens;
+					acc.durationMs =
+						d.mode === "chain"
+							? acc.durationMs + prog.durationMs
+							: Math.max(acc.durationMs, prog.durationMs);
+				}
+				return acc;
+			},
+			{ toolCount: 0, tokens: 0, durationMs: 0 },
+		);
+
+	const summaryStr =
+		totalSummary.toolCount || totalSummary.tokens
+			? ` | ${totalSummary.toolCount} tools, ${formatTokens(totalSummary.tokens)} tok, ${formatDuration(totalSummary.durationMs)}`
+			: "";
+
+	const modeLabel = d.mode;
+	const contextBadge = d.context === "fork" ? theme.fg("warning", " [fork]") : "";
+	const multiLabel = buildMultiProgressLabel(d, hasRunning);
+	const itemTitle = multiLabel.itemTitle;
+
+	const chainVis = d.chainAgents?.length && !multiLabel.hasParallelInChain
+		? d.chainAgents
+				.map((agent, i) => {
+					const result = d.results[i];
+					const isFailed = result && result.exitCode !== 0 && result.progress?.status !== "running";
+					const isComplete = result && result.exitCode === 0 && result.progress?.status !== "running";
+					const isEmptyWithoutTarget = Boolean(result)
+						&& Boolean(isComplete)
+						&& hasEmptyTextOutputWithoutOutputTarget(result.task, getSingleResultOutput(result));
+					const isCurrent = i === (d.currentStepIndex ?? d.results.length);
+					const stepIcon = isFailed
+						? theme.fg("error", "failed")
+						: isEmptyWithoutTarget
+							? theme.fg("warning", "warning")
+							: isComplete
+								? theme.fg("success", "done")
+								: isCurrent && hasRunning
+									? theme.fg("warning", "running")
+									: theme.fg("dim", "pending");
+					return `${stepIcon} ${agent}`;
+				})
+				.join(theme.fg("dim", " → "))
+		: null;
+
+	const w = getTermWidth() - 4;
+	const fit = (text: string) => expanded ? text : truncLine(text, w);
+	const c = new Container();
+	c.addChild(
+		new Text(
+			fit(`${icon} ${theme.fg("toolTitle", theme.bold(modeLabel))}${contextBadge} · ${multiLabel.headerLabel}${summaryStr}`),
+			0,
+			0,
+		),
+	);
+	if (chainVis) {
+		c.addChild(new Text(fit(`  ${chainVis}`), 0, 0));
+	}
+
+	const useResultsDirectly = multiLabel.hasParallelInChain || !d.chainAgents?.length;
+	const displayStart = multiLabel.showActiveGroupOnly ? multiLabel.groupStartIndex : 0;
+	const displayEnd = multiLabel.showActiveGroupOnly ? multiLabel.groupEndIndex : (useResultsDirectly ? d.results.length : d.chainAgents!.length);
+	const chainEntries = buildChainRenderEntries(d, multiLabel);
+	const renderEntries = chainEntries ?? Array.from({ length: displayEnd - displayStart }, (_, offset): ChainRenderEntry => {
+		const i = displayStart + offset;
+		const r = d.results[i];
+		const rowNumber = multiLabel.showActiveGroupOnly ? (i - multiLabel.groupStartIndex + 1) : (i + 1);
+		return { kind: "result", resultIndex: i, rowNumber, agentName: useResultsDirectly ? (r?.agent || `step-${rowNumber}`) : (d.chainAgents![i] || r?.agent || `step-${rowNumber}`) };
+	});
+
+	c.addChild(new Spacer(1));
+
+	for (const entry of renderEntries) {
+		if (entry.kind === "placeholder") {
+			const statusLabel = widgetStepStatus(entry.status as AsyncJobStep["status"], theme);
+			c.addChild(new Text(fit(`  ${statusLabel} ${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) c.addChild(new Text(theme.fg("error", `    error: ${entry.error}`), 0, 0));
+			c.addChild(new Spacer(1));
+			continue;
+		}
+		const i = entry.resultIndex;
+		const r = d.results[i];
+		const rowNumber = entry.rowNumber;
+		const agentName = entry.agentName;
+
+		if (!r) {
+			const pendingLabel = chainEntries ? resultRowLabel(d, multiLabel, i, rowNumber) : `${itemTitle} ${rowNumber}`;
+			c.addChild(new Text(fit(theme.fg("dim", `  ${pendingLabel}: ${agentName}`)), 0, 0));
+			c.addChild(new Text(theme.fg("dim", `    status: pending`), 0, 0));
+			c.addChild(new Spacer(1));
+			continue;
+		}
+
+		const progressFromArray = d.progress?.find((p) => p.index === i)
+			|| d.progress?.find((p) => p.agent === r.agent && p.status === "running");
+		const rProg = (r.progress || progressFromArray || r.progressSummary) as AgentProgress | undefined;
+		const rRunning = rProg?.status === "running";
+		const stepNumber = typeof rProg?.index === "number" ? rProg.index + 1 : i + 1;
+
+		const resultOutput = getSingleResultOutput(r);
+		const statusIcon = rRunning
+			? theme.fg("warning", "running")
+			: r.exitCode !== 0
+				? theme.fg("error", "failed")
+				: hasEmptyTextOutputWithoutOutputTarget(r.task, resultOutput)
+					? theme.fg("warning", "warning")
+					: theme.fg("success", "done");
+		const stats = rProg ? ` | ${rProg.toolCount} tools, ${formatDuration(displayProgressDurationMs(rProg, options.now))}` : "";
+		const modelDisplay = modelThinkingBadge(theme, r.model, undefined, r.fastMode);
+		const stepLabel = resultRowLabel(d, multiLabel, i, stepNumber);
+		const stepHeader = rRunning
+			? `${statusIcon} ${stepLabel}: ${theme.bold(theme.fg("warning", r.agent))}${modelDisplay}${stats}`
+			: `${statusIcon} ${stepLabel}: ${theme.bold(r.agent)}${modelDisplay}${stats}`;
+		const toolCallLines = getToolCallLines(r, expanded);
+		c.addChild(new Text(fit(stepHeader), 0, 0));
+
+		const taskMaxLen = Math.max(20, w - 12);
+		const taskPreview = expanded || r.task.length <= taskMaxLen
+			? r.task
+			: `${r.task.slice(0, taskMaxLen)}...`;
+		c.addChild(new Text(fit(theme.fg("dim", `    task: ${taskPreview}`)), 0, 0));
+
+		const outputTarget = extractOutputTarget(r.task);
+		if (outputTarget) {
+			c.addChild(new Text(fit(theme.fg("dim", `    output: ${outputTarget}`)), 0, 0));
+		}
+
+		if (r.skills?.length) {
+			c.addChild(new Text(fit(theme.fg("dim", `    skills: ${r.skills.join(", ")}`)), 0, 0));
+		}
+		if (r.skillsWarning) {
+			c.addChild(new Text(fit(theme.fg("warning", `    Warning: ${r.skillsWarning}`)), 0, 0));
+		}
+		if (r.attemptedModels && r.attemptedModels.length > 1) {
+			c.addChild(new Text(fit(theme.fg("dim", `    fallbacks: ${r.attemptedModels.join(" → ")}`)), 0, 0));
+		}
+
+		if (rRunning && rProg) {
+			if (rProg.skills?.length) {
+				c.addChild(new Text(fit(theme.fg("accent", `    skills: ${rProg.skills.join(", ")}`)), 0, 0));
+			}
+			const progressSnapshotNow = snapshotNowForProgress(rProg, options.now);
+			const toolLine = formatCurrentToolLine(rProg, w, expanded, progressSnapshotNow);
+			if (toolLine) {
+				c.addChild(new Text(fit(theme.fg("warning", `    > ${toolLine}`)), 0, 0));
+			}
+			const liveStatusLine = buildLiveStatusLine(rProg, progressSnapshotNow);
+			if (liveStatusLine) {
+				c.addChild(new Text(fit(theme.fg("accent", `    ${liveStatusLine}`)), 0, 0));
+			}
+			c.addChild(new Text(fit(theme.fg("accent", "    Press ctrl+o for live detail")), 0, 0));
+			if (r.artifactPaths) {
+				c.addChild(new Text(fit(theme.fg("dim", `    artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
+			}
+			if (rProg.recentTools?.length) {
+				for (const t of rProg.recentTools.slice(-3)) {
+					const maxArgsLen = Math.max(40, w - 30);
+					const argsPreview = expanded || t.args.length <= maxArgsLen
+						? t.args
+						: `${t.args.slice(0, maxArgsLen)}...`;
+					c.addChild(new Text(fit(theme.fg("dim", `      ${t.tool}: ${argsPreview}`)), 0, 0));
+				}
+			}
+			const recentLines = (rProg.recentOutput ?? []).slice(-5);
+			for (const line of recentLines) {
+				c.addChild(new Text(fit(theme.fg("dim", `      ${line}`)), 0, 0));
+			}
+		}
+
+		if (!rRunning && r.artifactPaths) {
+			c.addChild(new Text(fit(theme.fg("dim", `    artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
+		}
+
+		if (expanded && !rRunning) {
+			for (const line of toolCallLines) {
+				c.addChild(new Text(fit(theme.fg("muted", `      ${line}`)), 0, 0));
+			}
+			if (toolCallLines.length) c.addChild(new Spacer(1));
+		}
+
+		c.addChild(new Spacer(1));
+	}
+
+	if (d.artifacts) {
+		c.addChild(new Spacer(1));
+		c.addChild(new Text(fit(theme.fg("dim", `Artifacts dir: ${shortenPath(d.artifacts.dir)}`)), 0, 0));
+	}
+	return c;
+}

package/dist/builtin/subagents/src/tui/render-stable-output.ts

@@ -0,0 +1,83 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { AgentProgress, AsyncJobState, Details } from "../shared/types.ts";
+
+export function widgetRenderKey(job: AsyncJobState): string {
+	return JSON.stringify({
+		asyncDir: job.asyncDir,
+		status: job.status,
+		activityState: job.activityState,
+		lastActivityAt: job.lastActivityAt,
+		currentTool: job.currentTool,
+		currentToolStartedAt: job.currentToolStartedAt,
+		currentPath: job.currentPath,
+		turnCount: job.turnCount,
+		toolCount: job.toolCount,
+		mode: job.mode,
+		agents: job.agents,
+		currentStep: job.currentStep,
+		chainStepCount: job.chainStepCount,
+		parallelGroups: job.parallelGroups,
+		steps: job.steps,
+		nestedChildren: job.nestedChildren,
+		stepsTotal: job.stepsTotal,
+		runningSteps: job.runningSteps,
+		completedSteps: job.completedSteps,
+		activeParallelGroup: job.activeParallelGroup,
+		startedAt: job.startedAt,
+		updatedAt: job.updatedAt,
+		totalTokens: job.totalTokens,
+	});
+}
+
+export function progressRenderKey(progress: Partial<AgentProgress> | undefined): string {
+	if (!progress) return "";
+	return [
+		progress.index,
+		progress.agent,
+		progress.status,
+		progress.durationMs,
+		progress.toolCount,
+		progress.tokens,
+		progress.turnCount ?? "",
+		progress.lastActivityAt ?? "",
+		progress.currentTool ?? "",
+		progress.currentToolStartedAt ?? "",
+		progress.currentPath ?? "",
+	].join(":");
+}
+
+export function isRunningSubagentResult(result: AgentToolResult<Details>): boolean {
+	return result.details?.progress?.some((entry) => entry.status === "running")
+		|| result.details?.results.some((entry) => entry.progress?.status === "running")
+		|| false;
+}
+
+export function subagentResultRenderKey(
+	result: AgentToolResult<Details>,
+	options: { expanded: boolean; isPartial: boolean },
+): string {
+	const details = result.details;
+	if (!details) return `${options.isPartial ? "partial" : "final"}:${result.content.length}`;
+	const progressKeys = [
+		...(details.progress ?? []).map(progressRenderKey),
+		...details.results.map((entry) => [
+			entry.agent,
+			entry.exitCode,
+			entry.interrupted === true ? "interrupted" : "",
+			entry.detached === true ? "detached" : "",
+			progressRenderKey(entry.progress),
+			progressRenderKey(entry.progressSummary),
+			entry.finalOutput?.length ?? "",
+			entry.error?.length ?? "",
+		].join(":")),
+	];
+	return [
+		options.isPartial ? "partial" : "final",
+		options.expanded ? "expanded" : "compact",
+		details.mode,
+		details.currentStepIndex ?? "",
+		details.totalSteps ?? "",
+		progressRenderKey(details.progressSummary),
+		progressKeys.join("|"),
+	].join("|");
+}

package/dist/builtin/subagents/src/tui/render-status-progress.ts

@@ -0,0 +1,133 @@
+import type { AgentProgress, Details } from "../shared/types.ts";
+import { formatDuration, formatTokens, formatToolCall } from "../shared/formatters.ts";
+import { getDisplayItems } from "../shared/utils.ts";
+import { formatActivityLabel } from "../shared/status-format.ts";
+import { getTermWidth, progressRunningSeed, runningGlyph, type Theme } from "./render-layout.ts";
+
+export function extractOutputTarget(task: string): string | undefined {
+	const writeToMatch = task.match(/\[Write to:\s*([^\]\n]+)\]/i);
+	if (writeToMatch?.[1]?.trim()) return writeToMatch[1].trim();
+	const findingsMatch = task.match(/Write your findings to:\s*(\S+)/i);
+	if (findingsMatch?.[1]?.trim()) return findingsMatch[1].trim();
+	const outputMatch = task.match(/[Oo]utput(?:\s+to)?\s*:\s*(\S+)/i);
+	if (outputMatch?.[1]?.trim()) return outputMatch[1].trim();
+	return undefined;
+}
+
+export function hasEmptyTextOutputWithoutOutputTarget(task: string, output: string): boolean {
+	if (output.trim()) return false;
+	return !extractOutputTarget(task);
+}
+
+export function getToolCallLines(
+	result: Pick<Details["results"][number], "messages" | "toolCalls">,
+	expanded: boolean,
+): string[] {
+	if (result.messages) {
+		return getDisplayItems(result.messages)
+			.filter((item): item is { type: "tool"; name: string; args: Record<string, unknown> } => 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: Pick<AgentProgress, "currentToolStartedAt" | "durationMs" | "lastActivityAt">, now?: number): number | undefined {
+	if (now !== undefined) return now;
+	if (progress.lastActivityAt !== undefined) return progress.lastActivityAt;
+	if (progress.currentToolStartedAt !== undefined && progress.durationMs !== undefined) return progress.currentToolStartedAt + progress.durationMs;
+	return undefined;
+}
+
+export function formatCurrentToolLine(
+	progress: Pick<AgentProgress, "currentTool" | "currentToolArgs" | "currentToolStartedAt">,
+	availableWidth: number,
+	expanded: boolean,
+	snapshotNow?: number,
+): string | undefined {
+	if (!progress.currentTool) return undefined;
+	const maxToolArgsLen = Math.max(50, availableWidth - 20);
+	const toolArgsPreview = progress.currentToolArgs
+		? (expanded || progress.currentToolArgs.length <= maxToolArgsLen
+			? progress.currentToolArgs
+			: `${progress.currentToolArgs.slice(0, maxToolArgsLen)}...`)
+		: "";
+	const durationSuffix = progress.currentToolStartedAt !== undefined && snapshotNow !== undefined
+		? ` | ${formatDuration(Math.max(0, snapshotNow - progress.currentToolStartedAt))}`
+		: "";
+	return toolArgsPreview
+		? `${progress.currentTool}: ${toolArgsPreview}${durationSuffix}`
+		: `${progress.currentTool}${durationSuffix}`;
+}
+
+export function buildLiveStatusLine(progress: Pick<AgentProgress, "activityState" | "lastActivityAt">, snapshotNow?: number): string | undefined {
+	if (progress.lastActivityAt !== undefined && snapshotNow !== undefined) return formatActivityLabel(progress.lastActivityAt, progress.activityState, snapshotNow);
+	if (progress.activityState === "needs_attention") return "needs attention";
+	if (progress.activityState === "active_long_running") return "active but long-running";
+	if (progress.lastActivityAt !== undefined) return "active";
+	return undefined;
+}
+
+export function themeBold(theme: Theme, text: string): string {
+	return ((theme as { bold?: (value: string) => string }).bold?.(text)) ?? text;
+}
+
+export function statJoin(theme: Theme, parts: string[]): string {
+	return parts.filter(Boolean).map((part) => theme.fg("dim", part)).join(` ${theme.fg("dim", "·")} `);
+}
+
+export function formatTokenStat(tokens: number): string {
+	return `${formatTokens(tokens)} token`;
+}
+
+export function formatToolUseStat(count: number): string {
+	return `${count} tool use${count === 1 ? "" : "s"}`;
+}
+
+export function displayProgressDurationMs(progress: Pick<AgentProgress, "durationMs"> & Partial<Pick<AgentProgress, "lastActivityAt" | "status">>, now?: number): number {
+	if (progress.status === "running" && progress.lastActivityAt !== undefined && now !== undefined) {
+		return progress.durationMs + Math.max(0, now - progress.lastActivityAt);
+	}
+	return progress.durationMs;
+}
+
+export function formatProgressStats(
+	theme: Theme,
+	progress: (Pick<AgentProgress, "toolCount" | "tokens" | "durationMs"> & Partial<Pick<AgentProgress, "lastActivityAt" | "status">>) | undefined,
+	includeDuration = true,
+	now?: number,
+): string {
+	if (!progress) return "";
+	const parts: string[] = [];
+	if (progress.toolCount > 0) parts.push(formatToolUseStat(progress.toolCount));
+	if (progress.tokens > 0) parts.push(formatTokenStat(progress.tokens));
+	const durationMs = displayProgressDurationMs(progress, now);
+	if (includeDuration && durationMs > 0) parts.push(formatDuration(durationMs));
+	return statJoin(theme, parts);
+}
+
+export function firstOutputLine(text: string): string {
+	return text.split("\n").find((line) => line.trim())?.trim() ?? "";
+}
+
+export function resultStatusLine(result: Details["results"][number], output: string): string {
+	if (result.detached) return result.detachedReason ? `Detached: ${result.detachedReason}` : "Detached";
+	if (result.interrupted) return "Paused";
+	if (result.exitCode !== 0) return `Error: ${result.error ?? (firstOutputLine(output) || `exit ${result.exitCode}`)}`;
+	if (hasEmptyTextOutputWithoutOutputTarget(result.task, output)) return "Done (no text output)";
+	return "Done";
+}
+
+export function resultGlyph(result: Details["results"][number], output: string, theme: Theme, running = result.progress?.status === "running", seed = progressRunningSeed(result.progress ?? result.progressSummary), now?: number): string {
+	if (running) return theme.fg("accent", runningGlyph(seed, now));
+	if (result.detached) return theme.fg("warning", "■");
+	if (result.interrupted) return theme.fg("warning", "■");
+	if (result.exitCode !== 0) return theme.fg("error", "✗");
+	if (hasEmptyTextOutputWithoutOutputTarget(result.task, output)) return theme.fg("warning", "✓");
+	return theme.fg("success", "✓");
+}
+
+export function compactCurrentActivity(progress: AgentProgress, now?: number): string {
+	const snapshotNow = snapshotNowForProgress(progress, now);
+	return formatCurrentToolLine(progress, getTermWidth() - 4, false, snapshotNow) ?? buildLiveStatusLine(progress, snapshotNow) ?? "thinking…";
+}