pi-subagents 0.22.0 → 0.23.1

package/src/shared/types.ts

@@ -207,6 +207,7 @@ export interface SingleResult {
 
 export interface Details {
 	mode: SubagentRunMode | "management";
+	runId?: string;
 	context?: "fresh" | "fork";
 	results: SingleResult[];
 	controlEvents?: ControlEvent[];
@@ -296,11 +297,15 @@ export interface AsyncStatus {
 	steps?: Array<{
 		agent: string;
 		status: "pending" | "running" | "complete" | "completed" | "failed" | "paused";
+		sessionFile?: string;
 		activityState?: ActivityState;
 		lastActivityAt?: number;
 		currentTool?: string;
+		currentToolArgs?: string;
 		currentToolStartedAt?: number;
 		currentPath?: string;
+		recentTools?: Array<{ tool: string; args: string; endMs: number }>;
+		recentOutput?: string[];
 		turnCount?: number;
 		toolCount?: number;
 		startedAt?: number;
@@ -320,6 +325,10 @@ export interface AsyncStatus {
 	sessionFile?: string;
 }
 
+export type AsyncJobStep = NonNullable<AsyncStatus["steps"]>[number] & {
+	index?: number;
+};
+
 export interface AsyncJobState {
 	asyncId: string;
 	asyncDir: string;
@@ -338,7 +347,7 @@ export interface AsyncJobState {
 	currentStep?: number;
 	chainStepCount?: number;
 	parallelGroups?: AsyncParallelGroupStatus[];
-	steps?: AsyncStatus["steps"];
+	steps?: AsyncJobStep[];
 	stepsTotal?: number;
 	runningSteps?: number;
 	completedSteps?: number;
@@ -353,10 +362,26 @@ export interface AsyncJobState {
 	controlEventCursor?: number;
 }
 
+export interface ForegroundResumeChild {
+	agent: string;
+	index: number;
+	sessionFile?: string;
+	status: SubagentResultStatus;
+}
+
+export interface ForegroundResumeRun {
+	runId: string;
+	mode: SubagentRunMode;
+	cwd: string;
+	updatedAt: number;
+	children: ForegroundResumeChild[];
+}
+
 export interface SubagentState {
 	baseCwd: string;
 	currentSessionId: string | null;
 	asyncJobs: Map<string, AsyncJobState>;
+	foregroundRuns?: Map<string, ForegroundResumeRun>;
 	foregroundControls: Map<string, {
 		runId: string;
 		mode: SubagentRunMode;

package/src/slash/slash-commands.ts

@@ -279,6 +279,7 @@ async function runSlashSubagent(
 	ctx: ExtensionContext,
 	params: SubagentParamsLike,
 ): Promise<void> {
+	if (ctx.hasUI) ctx.ui.setToolsExpanded(false);
 	const requestId = randomUUID();
 	const initialDetails = buildSlashInitialResult(requestId, params);
 	const initialText = extractSlashMessageText(initialDetails.result.content) || "Running subagent...";

package/src/tui/render.ts

@@ -2,6 +2,7 @@
  * Rendering functions for subagent results
  */
 
+import * as path from "node:path";
 import type { AgentToolResult } from "@mariozechner/pi-agent-core";
 import { getMarkdownTheme, type ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { Container, Markdown, Spacer, Text, visibleWidth, type Component } from "@mariozechner/pi-tui";
@@ -14,6 +15,7 @@ import {
 } from "../shared/types.ts";
 import { formatTokens, formatUsage, formatDuration, formatToolCall, shortenPath } from "../shared/formatters.ts";
 import { getDisplayItems, getLastActivity, getSingleResultOutput } from "../shared/utils.ts";
+import { flatToLogicalStepIndex } from "../runs/background/parallel-groups.ts";
 
 type Theme = ExtensionContext["ui"]["theme"];
 
@@ -264,10 +266,10 @@ function formatWidgetAgents(agents: string[]): string {
 }
 
 function widgetJobName(job: AsyncJobState): string {
-	const agents = job.agents?.length ? formatWidgetAgents(job.agents) : undefined;
-	if (job.mode === "parallel") return agents ? `parallel · ${agents}` : "parallel";
-	if (job.activeParallelGroup) return agents ? `parallel group · ${agents}` : "parallel group";
-	if (job.agents?.length) return job.agents.join(" → ");
+	if (job.mode === "parallel") return "parallel";
+	if (job.mode === "chain") return "chain";
+	if (job.mode === "single" && job.agents?.length === 1) return job.agents[0]!;
+	if (job.agents?.length) return formatWidgetAgents(job.agents);
 	return job.mode ?? "subagent";
 }
 
@@ -293,6 +295,7 @@ function widgetActivity(job: AsyncJobState): string {
 	if (activity && facts.length) return `${activity} · ${facts.join(" · ")}`;
 	if (activity) return activity;
 	if (facts.length) return facts.join(" · ");
+	if (job.status === "running") return "thinking…";
 	if (job.status === "queued") return "queued…";
 	if (job.status === "paused") return "Paused";
 	if (job.status === "failed") return "Failed";
@@ -308,7 +311,7 @@ function widgetStatusGlyph(job: AsyncJobState, theme: Theme): string {
 }
 
 function widgetStepGlyph(status: string, theme: Theme): string {
-	if (status === "running") return theme.fg("accent", "▶");
+	if (status === "running") return theme.fg("accent", spinnerFrame());
 	if (status === "complete" || status === "completed") return theme.fg("success", "✓");
 	if (status === "failed") return theme.fg("error", "✗");
 	if (status === "paused") return theme.fg("warning", "■");
@@ -337,14 +340,62 @@ function widgetStepActivity(step: NonNullable<AsyncJobState["steps"]>[number]):
 	return facts.join(" · ");
 }
 
+function widgetAggregateStepStatus(steps: NonNullable<AsyncJobState["steps"]>): string {
+	if (steps.some((step) => step.status === "running")) return "running";
+	if (steps.some((step) => step.status === "failed")) return "failed";
+	if (steps.some((step) => step.status === "paused")) return "paused";
+	if (steps.length > 0 && steps.every((step) => step.status === "complete" || step.status === "completed")) return "complete";
+	return "pending";
+}
+
+function widgetParallelOutcome(steps: NonNullable<AsyncJobState["steps"]>, total: number): string {
+	const running = steps.filter((step) => step.status === "running").length;
+	const done = steps.filter((step) => step.status === "complete" || step.status === "completed").length;
+	const failed = steps.filter((step) => step.status === "failed").length;
+	const paused = steps.filter((step) => step.status === "paused").length;
+	const parts = [`${done}/${total} done`];
+	if (running > 0) parts.unshift(formatAgentRunningLabel(running));
+	if (failed > 0) parts.push(`${failed} failed`);
+	if (paused > 0) parts.push(`${paused} paused`);
+	return parts.join(" · ");
+}
+
+function widgetChainDetails(job: AsyncJobState, theme: Theme, expanded = false, width = getTermWidth()): string[] {
+	if (!job.steps?.length) return [];
+	const total = job.chainStepCount ?? job.steps.length;
+	const groups = job.parallelGroups ?? [];
+	const lines: string[] = [];
+	let flatIndex = 0;
+	for (let stepIndex = 0; stepIndex < total; stepIndex++) {
+		const group = groups.find((candidate) => candidate.stepIndex === stepIndex);
+		if (group) {
+			const steps = job.steps.slice(group.start, group.start + group.count);
+			const status = widgetAggregateStepStatus(steps);
+			lines.push(`  ${widgetStepGlyph(status, theme)} Step ${stepIndex + 1}/${total}: ${themeBold(theme, "parallel group")} ${theme.fg("dim", "·")} ${theme.fg("dim", widgetParallelOutcome(steps, group.count))}`);
+			flatIndex = Math.max(flatIndex, group.start + group.count);
+			continue;
+		}
+		const step = job.steps[flatIndex];
+		if (!step) {
+			lines.push(`  ${theme.fg("dim", `◦ Step ${stepIndex + 1}/${total}: pending`)}`);
+			continue;
+		}
+		lines.push(...foregroundStyleWidgetStepLines(job, theme, step, "Step", stepIndex + 1, total, expanded, width));
+		flatIndex++;
+	}
+	return lines;
+}
+
 function widgetParallelAgentDetails(job: AsyncJobState, theme: Theme): string[] {
-	if (!job.activeParallelGroup || !job.steps?.length) return [];
+	if (!job.steps?.length) return [];
 	if (job.mode !== "parallel" && job.mode !== "chain") return [];
+	if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length) return widgetChainDetails(job, theme);
 	const total = job.stepsTotal ?? job.steps.length;
 	return job.steps.map((step, index) => {
 		const marker = index === job.steps!.length - 1 ? "└" : "├";
 		const activity = widgetStepActivity(step);
-		return `  ${theme.fg("dim", `${marker} ${widgetStepGlyph(step.status, theme)} Agent ${index + 1}/${total}: ${step.agent} · ${widgetStepStatus(step.status, theme)}${activity ? ` · ${activity}` : ""}`)}`;
+		const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
+		return `  ${theme.fg("dim", `${marker} ${widgetStepGlyph(step.status, theme)} ${itemTitle} ${index + 1}/${total}: ${step.agent} · ${widgetStepStatus(step.status, theme)}${activity ? ` · ${activity}` : ""}`)}`;
 	});
 }
 
@@ -513,7 +564,7 @@ function widgetStats(job: AsyncJobState, theme: Theme): string {
 		const running = job.runningSteps ?? (job.status === "running" ? 1 : 0);
 		const done = job.completedSteps ?? (job.status === "complete" ? stepsTotal : 0);
 		if (job.mode === "parallel") {
-			if (job.status === "running") parts.push(formatAgentRunningLabel(running));
+			if (job.status === "running" && running > 0) parts.push(formatAgentRunningLabel(running));
 			if (stepsTotal > 0) parts.push(`${done}/${stepsTotal} done`);
 		} else {
 			const activeGroup = job.currentStep !== undefined
@@ -521,24 +572,159 @@ function widgetStats(job: AsyncJobState, theme: Theme): string {
 				: job.parallelGroups?.find((group) => group.start === 0);
 			const logicalStep = activeGroup?.stepIndex ?? job.currentStep ?? 0;
 			const total = job.chainStepCount ?? stepsTotal;
-			const groupProgress = job.status === "running"
-				? `${formatAgentRunningLabel(running)} · ${done}/${stepsTotal} done`
-				: `${done}/${stepsTotal} done`;
-			parts.push(`step ${logicalStep + 1}/${total} · parallel group: ${groupProgress}`);
+			const groupParts = [`${done}/${stepsTotal} done`];
+			if (job.status === "running" && running > 0) groupParts.unshift(formatAgentRunningLabel(running));
+			parts.push(`step ${logicalStep + 1}/${total} · parallel group: ${groupParts.join(" · ")}`);
 		}
 	} else if (job.currentStep !== undefined) {
-		parts.push(`step ${job.currentStep + 1}/${stepsTotal}`);
+		if (job.mode === "chain" && job.parallelGroups?.length) {
+			const total = job.chainStepCount ?? stepsTotal;
+			parts.push(`step ${flatToLogicalStepIndex(job.currentStep, total, job.parallelGroups) + 1}/${total}`);
+		} else {
+			parts.push(`step ${job.currentStep + 1}/${stepsTotal}`);
+		}
 	} else if (stepsTotal > 1) {
 		parts.push(`steps ${stepsTotal}`);
 	}
+	if (job.toolCount !== undefined) parts.push(formatToolUseStat(job.toolCount));
 	if (job.totalTokens?.total) parts.push(formatTokenStat(job.totalTokens.total));
 	const endTime = job.status === "complete" || job.status === "failed" || job.status === "paused" ? (job.updatedAt ?? Date.now()) : Date.now();
 	if (job.startedAt) parts.push(formatDuration(Math.max(0, endTime - job.startedAt)));
 	return statJoin(theme, parts);
 }
 
-export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = getTermWidth()): string[] {
+function widgetStepStats(theme: Theme, step: NonNullable<AsyncJobState["steps"]>[number]): string {
+	return statJoin(theme, [
+		step.turnCount !== undefined ? `${step.turnCount} turns` : "",
+		step.toolCount !== undefined ? formatToolUseStat(step.toolCount) : "",
+		step.tokens?.total ? formatTokenStat(step.tokens.total) : "",
+		step.durationMs !== undefined ? formatDuration(step.durationMs) : "",
+	]);
+}
+
+function widgetStepActivityLine(step: NonNullable<AsyncJobState["steps"]>[number], width: number, expanded: boolean): string {
+	const toolLine = formatCurrentToolLine(step, width, expanded);
+	if (toolLine) return toolLine;
+	const activity = formatActivityLabel(step.lastActivityAt, step.activityState);
+	if (activity) return activity;
+	if (step.status === "running") return "thinking…";
+	return "";
+}
+
+function widgetOutputPath(job: AsyncJobState, step: NonNullable<AsyncJobState["steps"]>[number]): string | undefined {
+	if (typeof step.index !== "number") return undefined;
+	return path.join(job.asyncDir, `output-${step.index}.log`);
+}
+
+function foregroundStyleWidgetStepLines(
+	job: AsyncJobState,
+	theme: Theme,
+	step: NonNullable<AsyncJobState["steps"]>[number],
+	itemTitle: "Agent" | "Step",
+	index: number,
+	total: number,
+	expanded: boolean,
+	width: number,
+): string[] {
+	const status = widgetStepStatus(step.status, theme);
+	const stats = widgetStepStats(theme, step);
+	const lines = [`  ${widgetStepGlyph(step.status, theme)} ${itemTitle} ${index}/${total}: ${themeBold(theme, step.agent)} ${theme.fg("dim", "·")} ${status}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`];
+	const activity = widgetStepActivityLine(step, width, expanded);
+	if (activity) lines.push(`    ${theme.fg("dim", `⎿  ${activity}`)}`);
+	if (step.status === "running") {
+		if (!expanded) lines.push(`    ${theme.fg("accent", "Press Ctrl+O for live detail")}`);
+		const output = widgetOutputPath(job, step);
+		if (output) lines.push(`    ${theme.fg("dim", `output: ${shortenPath(output)}`)}`);
+		if (expanded) {
+			const liveStatus = buildLiveStatusLine(step);
+			if (liveStatus && liveStatus !== activity) lines.push(`    ${theme.fg("accent", liveStatus)}`);
+			for (const tool of step.recentTools?.slice(-3) ?? []) {
+				const maxArgsLen = Math.max(40, width - 30);
+				const argsPreview = tool.args.length <= maxArgsLen ? tool.args : `${tool.args.slice(0, maxArgsLen)}...`;
+				lines.push(`      ${theme.fg("dim", `${tool.tool}${argsPreview ? `: ${argsPreview}` : ""}`)}`);
+			}
+			for (const line of step.recentOutput?.slice(-5) ?? []) {
+				lines.push(`      ${theme.fg("dim", line)}`);
+			}
+		}
+	}
+	return lines;
+}
+
+function foregroundStyleWidgetDetails(job: AsyncJobState, theme: Theme, expanded: boolean, width: number): string[] {
+	if (!job.steps?.length) return [`  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`];
+	if (job.mode !== "parallel" && job.mode !== "chain") return [`  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`];
+	if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length) return widgetChainDetails(job, theme, expanded, width);
+	const total = job.stepsTotal ?? job.steps.length;
+	const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
+	const lines: string[] = [];
+	for (const [index, step] of job.steps.entries()) {
+		lines.push(...foregroundStyleWidgetStepLines(job, theme, step, itemTitle, index + 1, total, expanded, width));
+	}
+	return lines;
+}
+
+function buildSingleWidgetLines(job: AsyncJobState, theme: Theme, width: number, expanded: boolean): string[] {
+	const stats = widgetStats(job, theme);
+	const count = job.mode === "chain" ? job.chainStepCount : job.stepsTotal ?? job.agents?.length ?? job.steps?.length;
+	const mode = widgetJobName(job);
+	const title = `async subagent ${mode}${count && count > 1 ? ` (${count})` : ""}`;
+	return [
+		`${theme.fg("toolTitle", themeBold(theme, title))} ${theme.fg("dim", "· background · /subagents-status")}`,
+		`${widgetStatusGlyph(job, theme)} ${themeBold(theme, mode)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+		...foregroundStyleWidgetDetails(job, theme, expanded, width),
+	].map((line) => truncLine(line, width));
+}
+
+function compactSingleWidgetLines(job: AsyncJobState, theme: Theme, width: number): string[] {
+	const fullLines = buildSingleWidgetLines(job, theme, width, false);
+	if (fullLines.length <= 10 || !job.steps?.length || (job.mode !== "parallel" && !job.activeParallelGroup)) return fullLines;
+
+	const total = job.stepsTotal ?? job.steps.length;
+	const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
+	const lines = fullLines.slice(0, 2);
+	for (const [index, step] of job.steps.entries()) {
+		const status = widgetStepStatus(step.status, theme);
+		const activity = widgetStepActivityLine(step, width, false);
+		const stepStats = widgetStepStats(theme, step);
+		const activitySuffix = activity ? ` ${theme.fg("dim", "·")} ${theme.fg("dim", activity)}` : "";
+		lines.push(`  ${widgetStepGlyph(step.status, theme)} ${itemTitle} ${index + 1}/${total}: ${themeBold(theme, step.agent)} ${theme.fg("dim", "·")} ${status}${activitySuffix}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}`);
+	}
+	if (job.steps.some((step) => step.status === "running")) lines.push(theme.fg("accent", "  Press Ctrl+O for live detail · /subagents-status for output paths"));
+	return lines.map((line) => truncLine(line, width));
+}
+
+function fitWidgetLineBudget(lines: string[], theme: Theme, width: number, expanded: boolean): string[] {
+	const rows = process.stdout.rows || 30;
+	const budget = expanded
+		? Math.max(12, Math.min(24, Math.floor(rows * 0.55)))
+		: Math.max(10, Math.min(14, Math.floor(rows * 0.35)));
+	if (lines.length <= budget) return lines;
+	const visibleLines = Math.max(1, budget - 1);
+	const hiddenCount = lines.length - visibleLines;
+	const hint = expanded
+		? `… ${hiddenCount} live-detail lines hidden · /subagents-status for full detail`
+		: `… ${hiddenCount} lines hidden · Ctrl+O expands · /subagents-status for full detail`;
+	return [...lines.slice(0, visibleLines), truncLine(theme.fg("dim", hint), width)];
+}
+
+function buildWidgetComponent(jobs: AsyncJobState[], expanded: boolean): (_tui: unknown, theme: Theme) => Component {
+	return (_tui, theme) => {
+		const width = getTermWidth();
+		const lines = expanded
+			? buildWidgetLines(jobs, theme, width, true)
+			: jobs.length === 1
+				? compactSingleWidgetLines(jobs[0]!, theme, width)
+				: buildWidgetLines(jobs, theme, width, false);
+		const container = new Container();
+		for (const line of fitWidgetLineBudget(lines, theme, width, expanded)) container.addChild(new Text(line, 1, 0));
+		return container;
+	};
+}
+
+export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = getTermWidth(), expanded = false): string[] {
 	if (jobs.length === 0) return [];
+	if (jobs.length === 1) return buildSingleWidgetLines(jobs[0]!, theme, width, expanded);
 	const running = jobs.filter((job) => job.status === "running");
 	const queued = jobs.filter((job) => job.status === "queued");
 	const finished = jobs.filter((job) => job.status !== "running" && job.status !== "queued");
@@ -608,7 +794,7 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
 function refreshAnimatedWidget(): void {
 	try {
 		if (!latestWidgetCtx?.hasUI || latestWidgetJobs.length === 0) return;
-		latestWidgetCtx.ui.setWidget(WIDGET_KEY, buildWidgetLines(latestWidgetJobs, latestWidgetCtx.ui.theme));
+		latestWidgetCtx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(latestWidgetJobs, latestWidgetCtx.ui.getToolsExpanded?.() ?? false));
 		latestWidgetCtx.ui.requestRender?.();
 	} catch (error) {
 		if (!isStaleExtensionContextError(error)) throw error;
@@ -662,7 +848,7 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void
 	latestWidgetCtx = ctx;
 	latestWidgetJobs = [...jobs];
 
-	ctx.ui.setWidget(WIDGET_KEY, buildWidgetLines(jobs, ctx.ui.theme));
+	ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(jobs, ctx.ui.getToolsExpanded?.() ?? false));
 	if (hasAnimatedWidgetJobs(jobs)) ensureWidgetAnimation();
 	else stopWidgetAnimation();
 }

package/src/tui/subagents-status.ts

@@ -62,11 +62,20 @@ function stepGlyph(theme: Theme, status: string): string {
 	return theme.fg("dim", "◦");
 }
 
+function runGlyph(theme: Theme, status: AsyncRunSummary["state"]): string {
+	if (status === "running") return theme.fg("accent", "▶");
+	if (status === "queued") return theme.fg("dim", "◦");
+	if (status === "complete") return theme.fg("success", "✓");
+	if (status === "paused") return theme.fg("warning", "■");
+	return theme.fg("error", "✗");
+}
+
 function runLabel(theme: Theme, run: AsyncRunSummary, selected: boolean): string {
 	const prefix = selected ? theme.fg("accent", ">") : " ";
 	const stepLabel = formatAsyncRunProgressLabel(run);
 	const cwd = shortenPath(run.cwd ?? run.asyncDir);
-	return `${prefix} ${run.id.slice(0, 8)} ${statusColor(theme, run.state)} | ${run.mode} | ${stepLabel} | ${cwd}`;
+	const mode = ((theme as { bold?: (value: string) => string }).bold?.(run.mode)) ?? run.mode;
+	return `${prefix} ${runGlyph(theme, run.state)} ${mode} · ${stepLabel} · ${run.id.slice(0, 8)} · ${cwd}`;
 }
 
 function selectedIndex(rows: StatusRow[], cursor: number): number {
@@ -332,7 +341,13 @@ export class SubagentsStatusComponent implements Component {
 		if (run.sessionFile) {
 			lines.push(row(`session: ${truncateToWidth(shortenPath(run.sessionFile), innerW - 9)}`, width, this.theme));
 		}
-		lines.push(...this.renderStepRows(run, width, innerW));
+		if (run.mode === "chain" && (run.chainStepCount !== undefined || run.parallelGroups?.length)) {
+			lines.push(...this.renderChainProgressRows(run, width, innerW));
+		} else if (run.mode === "parallel") {
+			lines.push(...this.renderAgentRows(run, width, innerW));
+		} else {
+			lines.push(...this.renderStepRows(run, width, innerW));
+		}
 		return lines;
 	}
 
@@ -438,7 +453,7 @@ export class SubagentsStatusComponent implements Component {
 			: undefined;
 
 		const body: string[] = [];
-		body.push(...detailRows(`${run.id} | ${statusColor(this.theme, run.state)} | ${run.mode} | ${stepLabel} | ${duration}`, width, innerW, this.theme));
+		body.push(...detailRows(`${runGlyph(this.theme, run.state)} ${run.mode} · ${stepLabel} · ${statusColor(this.theme, run.state)} · ${duration}`, width, innerW, this.theme));
 		if (activity) body.push(...detailRows(activity, width, innerW, this.theme));
 		body.push(row("", width, this.theme));
 		if (run.mode === "chain" && (run.chainStepCount !== undefined || run.parallelGroups?.length)) {