@ferris1225/pi-subagents 0.26.2 → 0.27.0

package/README.md

@@ -27,7 +27,10 @@ report their results back to the main agent automatically.
 - **Parallel fan-out** — independent tasks run at the same time, with a configurable
   concurrency limit.
 - **Live progress** — a TUI widget shows each run's status, current activity, model,
-  token usage (input/output and cache read/write), and elapsed time.
+  token usage (input/output and cache read/write), and elapsed time. Auto-fix chain
+  rounds hang under their triggering review as a tree, and each finished round stays
+  visible with a one-line outcome (what a worker changed, or a re-review's
+  PASS/FAIL and what it found) until the chain resolves.
 - **Per-agent configuration** — enable agents, choose a model and thinking level per
   agent, and tune limits from `/subagents-setup`.
 - **Automatic model fallback** — if an agent's model fails at the provider level before
@@ -64,8 +67,9 @@ Several tools now offer some form of sub-agents. What this extension does differ
   tell you when any of these happened.
 - **A quality gate that closes the loop.** When a reviewer returns `REVIEW_FAIL`,
   the extension dispatches a worker briefed with the concrete findings, then a
-  re-review — up to `maxFixRounds` times — and only then wakes the main agent with
-  the whole chain. The gate runs itself instead of asking you to babysit it.
+  re-review — up to `maxFixRounds` times — and only then wakes the main agent.
+  The gate runs itself instead of asking you to babysit it, and the widget shows
+  every round as it happens instead of a black box.
 - **Honest results.** A sub-agent can end its turn with "still working" while its
   last build actually failed. The completion message surfaces the failed tool
   calls from the run's final attempt (`completed with N failed tool call(s)`) with
@@ -74,7 +78,12 @@ Several tools now offer some form of sub-agents. What this extension does differ
   attempt's tool calls are counted — never stale errors from an abandoned one.)
 - **You can see what it is doing.** The widget shows each run's status, current
   activity (which tool, which file), model, token usage including cache reads and
-  writes, and elapsed time — plus soft warnings when a run looks stuck.
+  writes, and elapsed time — plus soft warnings when a run looks stuck. When a
+  chain finishes, the delivered message is one condensed summary (one line per
+  round: verdict + what changed/found, plus aggregate usage) instead of every
+  round's raw output stacked together; the final round's full report is attached
+  only when its detail is actionable (a FAIL verdict or a crash), and any round's
+  full report stays one `subagent_status <id>` call away.
 - **Recursion is structurally impossible.** Children are leaf processes: the
   `subagent` tool is excluded from their toolset. No runaway delegation trees.
 - **Zero runtime dependencies.** It is a plain pi extension — install, configure,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferris1225/pi-subagents",
-  "version": "0.26.2",
+  "version": "0.27.0",
   "description": "Focused sub-agent delegation for pi: explore / worker / reviewer agents in isolated context, with proactive dispatch injection and per-agent model selection.",
   "type": "module",
   "license": "MIT",

package/src/fixloop.ts

@@ -12,6 +12,7 @@
  */
 
 import { getResultOutput, isFailedResult, reviewVerdict, type SingleResult } from "./spawn.ts";
+import { extractKeyFragments, formatUsageCompact } from "./monitor.ts";
 import type { SubagentsConfig } from "./config.ts";
 
 /**
@@ -62,6 +63,98 @@ export function buildFixTaskBrief(reviewerResult: SingleResult, round: number, m
 	].join("\n");
 }
 
+/**
+ * One step of an auto-fix chain as delivered: the run id (so the condensed
+ * summary can point at per-run detail via subagent_status), the result, and
+ * the human-readable role within the chain ("initial review", "fix round 1",
+ * "re-review round 2"). runId is undefined for steps that never spawned a run
+ * (e.g. an unknown agent).
+ */
+export interface ChainStep {
+	runId?: number;
+	result: SingleResult;
+	relation: string;
+}
+
+/** Max distinguishing fragments kept in a one-line chain summary. */
+export const CHAIN_SUMMARY_FRAGMENTS_MAX = 3;
+
+/** The most telling fragments (paths, quoted phrases, symbols) of a run's final
+ * output: for a worker these are the paths it changed, for a reviewer the
+ * issues it found. Capped so summaries stay one line. */
+export function chainKeyFragments(result: SingleResult): string[] {
+	return extractKeyFragments(getResultOutput(result)).slice(0, CHAIN_SUMMARY_FRAGMENTS_MAX);
+}
+
+/**
+ * Compact one-line outcome for a finished chain run, shown in the widget so
+ * each round reads as what it did: a reviewer reports its verdict plus the
+ * key fragments of what it found ("fail · src/index.ts · render()"), a worker
+ * the fragments of what it changed. Failed runs and runs with nothing
+ * distinctive get no summary.
+ */
+export function summarizeChainResult(result: SingleResult): string | undefined {
+	if (isFailedResult(result)) return undefined;
+	const verdict = result.agent === "reviewer" ? reviewVerdict(getResultOutput(result)) : undefined;
+	if (verdict === "pass") return "pass";
+	const fragments = chainKeyFragments(result);
+	if (verdict === "fail") return fragments.length > 0 ? `fail · ${fragments.join(" · ")}` : "fail";
+	return fragments.length > 0 ? fragments.join(" · ") : undefined;
+}
+
+/**
+ * Condensed, readable summary of a completed auto-fix chain: one line per step
+ * (run id, role, verdict / what changed) plus aggregate usage. Full per-step
+ * reports stay addressable via `subagent_status <id>`; the caller appends the
+ * final step's full block only when its detail is actionable (FAIL verdict or a
+ * crash), so the delivered message stays short instead of stacking every
+ * round's raw output.
+ */
+export function formatChainSummary(steps: readonly ChainStep[]): string {
+	const rounds = steps.filter((step) => step.relation.startsWith("fix round")).length;
+	const last = steps[steps.length - 1];
+	const stepStatus = (step: ChainStep): string => {
+		const { result } = step;
+		if (result.agent === "reviewer") {
+			const verdict = reviewVerdict(getResultOutput(result));
+			if (verdict) return verdict.toUpperCase();
+		}
+		return isFailedResult(result) ? "failed" : "completed";
+	};
+	const lines = [
+		`## Auto-fix chain: ${Math.max(1, rounds)} round${rounds === 1 ? "" : "s"} — final ${stepStatus(last)}`,
+		"",
+	];
+	for (const step of steps) {
+		const fragments = chainKeyFragments(step.result);
+		const suffix =
+			fragments.length > 0
+				? step.result.agent === "worker"
+					? ` — changed: ${fragments.join(" · ")}`
+					: ` — ${fragments.join(" · ")}`
+				: "";
+		const id = step.runId !== undefined ? `#${step.runId} ` : "";
+		lines.push(`- ${id}${step.result.agent} · ${step.relation} · ${stepStatus(step)}${suffix}`);
+	}
+	const total = steps.reduce(
+		(acc, step) => {
+			acc.input += step.result.usage.input;
+			acc.output += step.result.usage.output;
+			acc.cacheRead += step.result.usage.cacheRead;
+			acc.cacheWrite += step.result.usage.cacheWrite;
+			acc.cost += step.result.usage.cost;
+			acc.turns += step.result.usage.turns;
+			return acc;
+		},
+		{ input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+	);
+	const usage = formatUsageCompact(total);
+	lines.push("", `Totals: ${steps.length} run${steps.length === 1 ? "" : "s"}${usage ? ` · ${usage}` : ""}`);
+	const ids = steps.filter((step) => step.runId !== undefined).map((step) => `#${step.runId}`);
+	lines.push(`Full per-run reports (output, usage, failed tools): subagent_status ${ids.join(" ")}`);
+	return lines.join("\n");
+}
+
 /**
  * The re-review brief handed to the reviewer after a worker fix round. Includes
  * the prior review so the reviewer can verify the fixes without re-discovering

package/src/index.ts

@@ -42,7 +42,7 @@ import {
 	type SubagentLiveEvent,
 	type UsageStats,
 } from "./spawn.ts";
-import { buildFixTaskBrief, buildReReviewBrief, shouldTriggerFixLoop } from "./fixloop.ts";
+import { buildFixTaskBrief, buildReReviewBrief, formatChainSummary, shouldTriggerFixLoop, summarizeChainResult, type ChainStep } from "./fixloop.ts";
 import {
 	activityStateLabel,
 	compactLine,
@@ -469,9 +469,9 @@ export default function (pi: ExtensionAPI): void {
 				task: string,
 				signal: AbortSignal,
 				meta: RunChainMeta,
-			): Promise<SingleResult> => {
+			): Promise<{ runId?: number; result: SingleResult }> => {
 				const agent = agents.find((candidate) => candidate.name === agentName);
-				if (!agent) return failedStartResult(agentName, task, `Unknown agent: "${agentName}".`);
+				if (!agent) return { result: failedStartResult(agentName, task, `Unknown agent: "${agentName}".`) };
 				const thinkingLevel = config.agentThinkingLevels[agent.name] ?? agent.thinking ?? config.thinkingLevel;
 				const runId = monitor.addRun(agent.name, task, agent.model, thinkingLevel, meta);
 				const onLive = makeLiveHandler(runId);
@@ -490,11 +490,15 @@ export default function (pi: ExtensionAPI): void {
 						},
 						sessionRef,
 					);
-					finishRun(runId, isFailedResult(result) ? "failed" : "done");
+					// Keep the finished round visible in the widget while the chain is
+					// still running, with a one-line summary of what it did; the whole
+					// group is dropped when the chain resolves (see removeChainGroup).
+					monitor.setSummary(runId, summarizeChainResult(result));
+					finishRun(runId, isFailedResult(result) ? "failed" : "done", { retain: true });
 					registerRunResult(runId, result);
-					return result;
+					return { runId, result };
 				} catch (error) {
-					finishRun(runId, "failed");
+					finishRun(runId, "failed", { retain: true });
 					const errorMessage = error instanceof Error ? error.message : String(error);
 					const crashed = {
 						...queuedResult(agent, task, thinkingLevel),
@@ -505,7 +509,7 @@ export default function (pi: ExtensionAPI): void {
 						dispatchFailed: true,
 					};
 					registerRunResult(runId, crashed);
-					return crashed;
+					return { runId, result: crashed };
 				}
 			};
 
@@ -517,73 +521,90 @@ export default function (pi: ExtensionAPI): void {
 			 * The triggering reviewer's run stays visible in the widget (annotated) until
 			 * the chain resolves, so the ↳ rows have an obvious parent.
 			 */
+			/** Drop every widget row belonging to an auto-fix chain; the retained
+			 * parent row is removed separately (it does not carry the groupId). */
+			const removeChainGroup = (groupId: string): void => {
+				for (const run of [...monitor.getRuns()]) {
+					if (run.groupId === groupId) monitor.removeRun(run.id);
+				}
+			};
+
 			const startFixLoop = (initialReviewerResult: SingleResult, parentGroupId: string, parentRunId: number): void => {
 				runControllers.set(parentRunId, backgroundQueue.enqueue(
 					async (signal) => {
-						const chain: SingleResult[] = [initialReviewerResult];
+						const chain: ChainStep[] = [
+							{ runId: parentRunId, result: initialReviewerResult, relation: "initial review" },
+						];
 						let lastReviewer = initialReviewerResult;
 						for (let round = 1; round <= config.maxFixRounds; round++) {
 							if (!sessionActive) break;
 							const fixBrief = buildFixTaskBrief(lastReviewer, round, config.maxFixRounds);
-							const workerResult = await launchInLoop("worker", fixBrief, signal, {
+							const workerStep = await launchInLoop("worker", fixBrief, signal, {
 								groupId: parentGroupId,
 								relationLabel: `fix round ${round}`,
 							});
-							chain.push(workerResult);
-							if (!sessionActive || isFailedResult(workerResult)) break;
+							chain.push({ ...workerStep, relation: `fix round ${round}` });
+							if (!sessionActive || isFailedResult(workerStep.result)) break;
 							const reReviewBrief = buildReReviewBrief(lastReviewer, round);
-							const reviewResult = await launchInLoop("reviewer", reReviewBrief, signal, {
+							const reviewStep = await launchInLoop("reviewer", reReviewBrief, signal, {
 								groupId: parentGroupId,
 								relationLabel: `re-review round ${round}`,
 							});
-							chain.push(reviewResult);
-							lastReviewer = reviewResult;
+							chain.push({ ...reviewStep, relation: `re-review round ${round}` });
+							lastReviewer = reviewStep.result;
 							// A crashed re-review must stop the chain like a crashed worker: its
 							// output (if any) is not a verdict, and feeding it to the next fix
 							// round would brief the worker from garbage.
-							if (!sessionActive || isFailedResult(reviewResult)) break;
-							if (reviewVerdict(getResultOutput(reviewResult)) === "pass") break;
+							if (!sessionActive || isFailedResult(reviewStep.result)) break;
+							if (reviewVerdict(getResultOutput(reviewStep.result)) === "pass") break;
 						}
 						// The chain is done (success, exhaustion, or abort): drop the retained
-						// parent row, then deliver the whole chain as one group. The loop's
-						// outcome always wakes the main agent (a passing chain reports
-						// success, a stuck one needs a human). Register the parent's final
-						// state (the last chain result) before removal so subagent_wait can
-						// resolve it.
-						registerRunResult(parentRunId, chain[chain.length - 1]);
+						// parent row and its retained round rows, then deliver one condensed
+						// summary. Register the parent's final state (the last chain result)
+						// before removal so subagent_wait can resolve it.
+						registerRunResult(parentRunId, chain[chain.length - 1].result);
 						runControllers.delete(parentRunId);
+						removeChainGroup(parentGroupId);
 						monitor.removeRun(parentRunId);
 						if (!sessionActive) return;
-						const items: CompletionMessageItem[] = chain.map((r) => {
-							// A model-level chain run (worker or re-review whose provider never
-							// produced output) is handed to the main window like any other
-							// sub-agent run: the block carries the takeover note. Dispatch
-							// crashes (dispatchFailed) are excluded by the gate itself.
-							const modelLevel = isFailedResult(r) && isModelLevelFailure(r);
-							return {
-								agent: r.agent,
-								block: modelLevel
-									? `${formatCompletionBlock(r, config.maxResultLines, ctx.cwd)}\n\n${modelLevelTakeoverNote(r)}`
-									: formatCompletionBlock(r, config.maxResultLines, ctx.cwd),
+						// One compact message instead of every round's raw output: the summary
+						// lines cover each step (verdict + what changed/found), and the final
+						// step's full report is appended only when its detail is actionable
+						// (a FAIL verdict, a crash, or a model-level failure the main agent
+						// must take over). Everything else stays one `subagent_status #id`
+						// call away.
+						const last = chain[chain.length - 1];
+						let block = formatChainSummary(chain);
+						if (isFailedResult(last.result) && isModelLevelFailure(last.result)) {
+							block = `${block}\n\n${formatCompletionBlock(last.result, config.maxResultLines, ctx.cwd)}\n\n${modelLevelTakeoverNote(last.result)}`;
+						} else if (isFailedResult(last.result) || reviewVerdict(getResultOutput(last.result)) === "fail") {
+							block = `${block}\n\n${formatCompletionBlock(last.result, config.maxResultLines, ctx.cwd)}`;
+						}
+						sendCompletionGroup([
+							{
+								agent: `auto-fix chain (${last.result.agent})`,
+								block,
 								triggerTurn: true,
-							};
-						});
-						sendCompletionGroup(items);
+							},
+						]);
 						completionBatcher.flush();
 					},
 					() => {
-						// Cancelled before delivery: clean up the retained parent row (each
-						// in-flight chain run was already finished by its launchInLoop path).
+						// Cancelled before delivery: clean up the retained parent row and
+						// every retained chain row (each in-flight chain run was already
+						// finished by its launchInLoop path).
 						runControllers.delete(parentRunId);
+						removeChainGroup(parentGroupId);
 						monitor.removeRun(parentRunId);
 					},
 					(error) => {
 						// A crash inside the chain orchestration (failed runs are caught by
 						// launchInLoop and delivered as part of the chain) must not vanish:
-						// drop the retained parent row, notify, and deliver a failed result
+						// drop the retained rows, notify, and deliver a failed result
 						// so the main agent knows the chain never completed.
 						registerRunResult(parentRunId, initialReviewerResult);
 						runControllers.delete(parentRunId);
+						removeChainGroup(parentGroupId);
 						monitor.removeRun(parentRunId);
 						if (!sessionActive) return;
 						const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1307,7 +1328,10 @@ export default function (pi: ExtensionAPI): void {
 								const usage = formatUsageCompact(r.usage);
 								const tools = r.toolCount ? `${r.toolCount} tool${r.toolCount === 1 ? "" : "s"}` : "";
 								const elapsed = formatElapsed(r, now);
-								const metaParts = [model, usage, tools, elapsed].filter(Boolean);
+								// The round outcome summary leads the metadata so a finished chain
+								// row reads as what it did ("fail · src/index.ts · render()",
+								// "pass", "src/index.ts · tests/monitor.test.ts").
+								const metaParts = [r.summary, model, usage, tools, elapsed].filter(Boolean);
 								// Running is conveyed by the icon + elapsed; spell out the label only for
 								// the other states (ready / done / stopped) so they are unambiguous.
 								if (r.status !== "running") metaParts.push(statusLabel(r.status));

package/src/monitor.ts

@@ -64,6 +64,11 @@ export interface RunView {
 	relationLabel?: string;
 	/** Free-form note shown in the widget next to the status label (e.g. "auto-fix chain running"). */
 	annotation?: string;
+	/** One-line outcome summary of a finished chain run, shown in the widget so
+	 * each auto-fix round reads as what it did: a reviewer reports its verdict
+	 * plus key fragments of what it found ("fail · src/index.ts · render()"), a
+	 * worker the fragments of what it changed. Unset for non-chain runs. */
+	summary?: string;
 	/** True when a finished run is intentionally kept in the widget (e.g. an
 	 * auto-fix chain parent whose chain is still running). beginTurn preserves
 	 * retained runs so they are not swept between turns. */
@@ -472,6 +477,14 @@ export class MonitorStore {
 		this.notify();
 	}
 
+	/** Set the run's one-line outcome summary (what a finished chain round did). */
+	setSummary(id: number, text: string | undefined): void {
+		const run = this.find(id);
+		if (!run) return;
+		run.summary = text;
+		this.notify();
+	}
+
 	/** Mark a run as retained (kept in the widget despite being finished). */
 	setRetained(id: number, retained: boolean): void {
 		const run = this.find(id);
@@ -517,6 +530,7 @@ export class MonitorStore {
 		const usage = formatUsageCompact(run.usage);
 		const parts = [run.agent];
 		if (run.relationLabel) parts.push(run.relationLabel);
+		if (run.summary) parts.push(run.summary);
 		if (run.model) parts.push(run.model);
 		if (run.thinking) parts.push(`thinking ${run.thinking}`);
 		if (usage) parts.push(usage);