@ferris1225/pi-subagents 2.1.0 → 2.2.0

package/README.md

@@ -32,15 +32,23 @@ The common quality loop now runs end to end without waking the main agent betwee
 steps:
 
 ```text
-reviewer (find blockers) → worker (fix) → reviewer (verify) → final PASS/FAIL
+reviewer (find issues) → worker (fix every finding) → reviewer (verify) → final PASS/FAIL
 ```
 
+Reviews use a single flat findings list — no severity triage. Every reported
+finding is fixed before the change is accepted, and each re-review converges on
+an open-finding set: the worker's explicit rejections are adjudicated once, only
+defects a fix round introduced or exposed are added, and resolved items never
+re-open. `maxFixRounds` stays the hard cap, so a chain always settles and wakes
+the main agent with the full picture.
+
 Cleanup stays a separate lifecycle: explicit cleanup intent can dispatch the
 evidence-first `cleaner`; any edits still go through the independent `reviewer`
 gate.
 
-Each chain is delivered as one concise completion group, while full per-run
-reports remain available through `subagent_status`. Its parent stays `running`
+Each chain is delivered as one concise completion group whose footer totals the
+aggregate token usage and cost of every included run, while full per-run reports
+remain available through `subagent_status`. Its parent stays `running`
 until the whole chain settles; completed internal rounds leave active status
 immediately, so no `done` row keeps accumulating elapsed time. Selected-to-main
 model handoffs keep the same retained context, and isolated parallel workers use
@@ -63,12 +71,16 @@ index.
   "go check" step. `subagent_wait` is a **non-blocking** in-turn lookup by default
   (pass `timeoutMs` to block); `subagent_status` inspects runs; `subagent_stop`
   cancels one and delivers its partial output.
-- **Active-only live widget** — each queued or running sub-agent gets one compact
-  width-aware primary line with task, effective model/thinking, and elapsed time;
-  current activity appears only when present on an indented second line:
+- **Active-only live widget, as a tree** — each queued or running sub-agent gets one compact
+  width-aware primary line with task, effective model/thinking, and elapsed time; current
+  activity appears only when present on an indented second line. Auto-fix rounds nest under
+  the triggering reviewer row that owns the chain, so it is always visible who dispatched
+  what; no run ids appear here — the tree and the task label identify each row:
   ```text
-  #7 cleaner · remove dead code in src/cache.ts · claude-sonnet-4-5/high · 42s
-    grep cacheKey
+  ● reviewer · review diff of src/foo.ts · claude-sonnet-4-5/high · 42s
+    ├ ● worker · fix round 1 · src/foo.ts · claude-sonnet-4-5/high · 10s
+    │    grep cacheKey
+    └ ○ reviewer · re-review round 1 · claude-sonnet-4-5/high · 3s
   ```
   Long tasks and activity paths truncate first (preserving a useful path tail when
   possible), groups have no blank rows, and settled/parked runs disappear immediately.
@@ -83,7 +95,10 @@ index.
 - **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.
-  Every round stays in the triggering reviewer's cwd, and chains that target the
+  Every reported finding gets fixed (no severity triage), and re-reviews converge
+  on an open-finding set instead of ping-ponging: worker rejections are adjudicated
+  once, only defects the fix round introduced are added, and resolved items never
+  re-open. Every round stays in the triggering reviewer's cwd, and chains that target the
   same repository are serialized so shared-checkout edits cannot race.
 - **Direct fallback with real thinking capabilities** — each agent has at most
   one selected model. An unavailable selection, rate limit, invalid key, quota,
@@ -98,9 +113,9 @@ index.
   `subagent_control` can steer active work, retarget it after a stable abort,
   park/resume it under the same run id, or fork a parked/settled checkpoint into
   a new independent run. Concurrent resume calls are serialized.
-- **Concise but honest completions** — a clean process that contained failed tool
-  calls adds one short warning with its run id; individual errors stay out of the
-  main context and remain available through `subagent_status`. Actual process,
+- **Concise but honest completions** — group completions end with aggregate token
+  and cost totals across every included run; failed-tool diagnostics stay out of the
+  delivered message and remain one `subagent_status` call away. Actual process,
   model, and integration failures still surface as failures.
 - **Parallel fan-out with filesystem isolation** — independent tasks run up to a
   configurable limit (default 4). Parallel workers default to detached Git
@@ -123,8 +138,9 @@ an undifferentiated child-agent launcher:
   independent reviewer gate;
 - isolated, retained threads that can be steered, parked, resumed, retargeted, or
   forked under stable run ids;
-- the reviewer → worker auto-fix → reviewer loop;
-- compact failed-tool warnings with full diagnostics available by run id;
+- the reviewer → worker auto-fix → reviewer loop, fixing every finding under a
+  convergence contract with a hard round cap;
+- failed-tool diagnostics available by run id through `subagent_status`;
 - direct selected→main fallback plus capability-aware Auto thinking;
 - detached Git worktree isolation for parallel workers and opt-in write-capable
   cleaner runs.
@@ -226,7 +242,8 @@ because they may need to inspect the same images.
 ### Controlling and stopping
 
 Dispatch confirmations, tool result rows, and completion blocks all show the
-stable `#id`, so a thread remains directly controllable after its live UI is gone.
+stable `#id`, so a thread remains directly controllable after its live UI is gone
+(the widget itself identifies rows by tree position and task instead of ids).
 
 - `subagent_control` — `steer`, `retarget`, `park`, `resume`, or `fork` a logical
   thread by stable run id. Resume accepts an optional replacement objective;
@@ -317,7 +334,7 @@ direct-file settings.
 | `proactiveInjection` | Whether to add the delegation directive to the main system prompt. |
 | `agentScope` | `user`, `project`, or `both`; controls which user/project agent directories are discovered. |
 | `maxConcurrency` | Max sub-agent processes running at once (1–16, default 4), and the max tasks one parallel `subagent` call accepts. Extra work waits in the queue. |
-| `maxFixRounds` | Auto-fix rounds when a reviewer returns `REVIEW_FAIL` (default 2; `0` disables the loop). |
+| `maxFixRounds` | Auto-fix rounds when a reviewer returns `REVIEW_FAIL` (default 2; `0` disables the loop). Hard cap: the chain always settles, delivers its condensed summary, and wakes the main agent. |
 | `idleTimeoutSec` | Idle watchdog: a sub-agent whose stdout goes silent for this long is terminated; a selected model then hands to current main. `0` disables it. Default 90. |
 
 ### Model routing and thinking

package/agents/reviewer.md

@@ -42,25 +42,23 @@ Understand the context first, then verify: the fix addresses the root cause, cha
 - Concurrency: shared mutable state, locks held across await, races.
 - Encoding/Unicode: assuming `char*`/files/CLI text is UTF-8; wrong `A` vs `W` Win32 APIs; boundary conversions.
 - Resource leaks; violations of the project's stated conventions.
-- Classify severity honestly. Distinguish blockers from nits; do not pad with style preferences.
+- Every finding you report gets fixed by the auto-fix loop — there are no severity tiers and no optional nits. Report genuine defects and risks only, each defensible with file:line evidence; leave out style preferences and anything you would merely "suggest". Order findings most important first.
 
 ## Collaboration
 - Independent of `worker` by design — your verdict is the gate before commit. Fix nothing yourself; report so the caller can dispatch a worker.
+- Re-reviews converge on an open-finding set: rule on each previously reported finding once (adjudicating the worker's explicit rejections — uphold only with a concrete refutation), add only defects the fix round introduced or exposed, and never re-open an item you verified resolved. Rounds are hard-capped, so padding a re-review with restated findings just burns them.
 
 ## Output format
 ## Files Reviewed
 - `path/to/file.ts`
-## Critical (must fix)
+## Findings
 - `file.ts:42` — concrete issue and why it breaks.
-## Warnings (should fix)
-- `file.ts:10` — issue and suggested direction.
-## Suggestions (consider)
-- Optional improvements.
+(Write "None" when you found nothing; an empty findings list is a valid, honest result.)
 ## Verdict
-One of: APPROVE / APPROVE_WITH_NITS / REQUEST_CHANGES, plus a 2-3 sentence rationale.
-End with exactly one machine-readable line: `VERDICT: REVIEW_PASS` for APPROVE or APPROVE_WITH_NITS; `VERDICT: REVIEW_FAIL` for REQUEST_CHANGES.
+One of: APPROVE / REQUEST_CHANGES, plus a 2-3 sentence rationale.
+End with exactly one machine-readable line: `VERDICT: REVIEW_PASS` for APPROVE; `VERDICT: REVIEW_FAIL` for REQUEST_CHANGES.
 
-REQUEST_CHANGES (or review-blocking concern) on this extension automatically starts an auto-fix loop: a worker is briefed with your findings, then you re-review, up to the configured round limit. Choose REVIEW_PASS when nothing objectively blocks the change (style preferences, optional refactors, or items the caller can knowingly accept are not blockers) — do not force a verdict that would trigger another loop just to hedge.
+REQUEST_CHANGES whenever even one finding remains. On this extension REQUEST_CHANGES automatically starts an auto-fix loop: a worker is briefed with your findings, fixes every one of them, and you re-review, up to the configured round limit. APPROVE means the findings list is empty — or, on a re-review, that every previously reported finding is resolved. Never quietly wave an issue through, and never invent findings to hedge: report each genuine issue once, accurately.
 
 ## Quality standards
 Specific file paths and line numbers. No vague feedback. A clean report means you looked hard, not that you found nothing to say.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferris1225/pi-subagents",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Controllable background sub-agent threads for pi: specialized roles, capability-aware thinking, direct main-model fallback, auto-fix chains, and Git worktree isolation.",
   "type": "module",
   "license": "MIT",

package/src/completion.ts

@@ -8,6 +8,8 @@
  */
 
 import { getResultOutput, isFailedResult, reviewVerdict, type SingleResult } from "./spawn.ts";
+import { formatUsageCompact, sumUsage } from "./monitor.ts";
+import type { UsageStats } from "./rpc-run.ts";
 
 export interface CompletionBatchTimings {
 	debounceMs: number;
@@ -98,14 +100,20 @@ export interface CompletionMessageItem {
 	agent: string;
 	block: string;
 	triggerTurn: boolean;
+	/** Final usage of the underlying run (or chain); aggregated into the group totals. */
+	usage?: UsageStats;
 }
 
-/** Keep the established single-result shape; add a summary only for real groups. */
+/** Keep the established single-result shape; add a group header and an aggregate
+ * token/cost footer only for real groups. */
 export function formatCompletionMessage(items: readonly CompletionMessageItem[]): string {
 	if (items.length === 0) return "";
 	if (items.length === 1) return items[0].block;
 	const agents = items.map((item) => item.agent).join(", ");
-	return `### Subagents completed (${items.length}): ${agents}\n\n${items.map((item) => item.block).join("\n\n")}`;
+	const withUsage = items.filter((item) => item.usage !== undefined);
+	const totals = withUsage.length > 0 ? formatUsageCompact(sumUsage(withUsage.map((item) => item.usage!))) : "";
+	const footer = totals ? `\n\nTotals: ${items.length} runs · ${totals}` : "";
+	return `### Subagents completed (${items.length}): ${agents}\n\n${items.map((item) => item.block).join("\n\n")}${footer}`;
 }
 
 /** A grouped completion wakes the main agent when any member requires a turn. */

package/src/dispatch.ts

@@ -34,6 +34,7 @@ import {
 	formatToolActivity,
 	monitor,
 	statusIcon,
+	sumUsage,
 	type RunChainMeta,
 } from "./monitor.ts";
 import type { SubagentRuntime } from "./runtime.ts";
@@ -423,6 +424,7 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 							const workerStep = await launchInLoop("worker", fixBrief, executionCwd, signal, {
 								groupId: parentGroupId,
 								relationLabel: `fix round ${round}`,
+								parentRunId,
 							}, vision);
 							// Preserve the newest sub-step before checking chain ownership. A
 							// destructive stop invalidates ownsParent() while this child is
@@ -442,10 +444,11 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 							if (!ownsParent()) return;
 							chain.push({ ...workerStep, relation: `fix round ${round}` });
 							if (!runtime.sessionActive || isFailedResult(workerStep.result)) break;
-							const reReviewBrief = buildReReviewBrief(lastReviewer, round);
+							const reReviewBrief = buildReReviewBrief(lastReviewer, round, workerStep.result);
 							const reviewStep = await launchInLoop("reviewer", reReviewBrief, executionCwd, signal, {
 								groupId: parentGroupId,
 								relationLabel: `re-review round ${round}`,
+								parentRunId,
 							}, vision);
 							if (
 								runtime.threads.get(parentRunId) === parentThreadAtStart &&
@@ -527,6 +530,7 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 								agent: `auto-fix chain (${last.result.agent})`,
 								block,
 								triggerTurn: true,
+								usage: sumUsage(chain.map((step) => step.result.usage)),
 							},
 						]);
 						runtime.completionBatcher.flush();
@@ -570,6 +574,7 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 									agent: initialReviewerResult.agent,
 									block: `${formatCompletionBlock(initialReviewerResult, config.maxResultLines, executionCwd)}\n\nAuto-fix chain crashed before completion: ${errorMessage}. The planned fix rounds did not run; the review above is the triggering reviewer's full output.`,
 									triggerTurn: true,
+									usage: initialReviewerResult.usage,
 								},
 							]);
 							runtime.completionBatcher.flush();

package/src/fixloop.ts

@@ -12,7 +12,7 @@
  */
 
 import { getResultOutput, isFailedResult, reviewVerdict, type SingleResult } from "./spawn.ts";
-import { extractKeyFragments, formatUsageCompact } from "./monitor.ts";
+import { extractKeyFragments, formatUsageCompact, sumUsage } from "./monitor.ts";
 import type { SubagentsConfig } from "./config.ts";
 
 /**
@@ -40,7 +40,7 @@ export function shouldTriggerFixLoop(result: SingleResult, config: SubagentsConf
 /**
  * Build the worker task brief for one fix round from a reviewer's findings.
  * The worker gets the full review text so it can address concrete file:line
- * issues, with instructions to fix only blockers and self-verify.
+ * issues, with instructions to fix every reported finding and self-verify.
  */
 export function buildFixTaskBrief(reviewerResult: SingleResult, round: number, maxRounds: number): string {
 	const review = getResultOutput(reviewerResult);
@@ -53,8 +53,9 @@ export function buildFixTaskBrief(reviewerResult: SingleResult, round: number, m
 		review,
 		`---`,
 		``,
-		`Fix the concrete blockers the reviewer flagged. Do NOT refactor unrelated code.`,
-		`Address every "Critical" item; address "Warnings" only if they are genuine.`,
+		`Fix EVERY finding in the reviewer's findings list — there is no severity triage; all of them get fixed.`,
+		`If a finding is factually wrong or clearly out of scope, say so explicitly instead of fixing it.`,
+		`Do NOT refactor unrelated code beyond what the findings require.`,
 		`After editing, run the project's format/build/tests when they exist and report`,
 		`exactly what you changed (paths + short rationale) so a reviewer can verify.`,
 		remaining > 0
@@ -120,18 +121,7 @@ export function formatChainSummary(steps: readonly ChainStep[]): string {
 		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 total = sumUsage(steps.map((step) => step.result.usage));
 	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}`);
@@ -141,11 +131,14 @@ export function formatChainSummary(steps: readonly ChainStep[]): string {
 
 /**
  * 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
- * the original issues.
+ * the prior review AND the worker's report so the reviewer can adjudicate
+ * rejections instead of restating findings. The convergence contract keeps
+ * rounds from ping-ponging: rule on the open findings once, add only defects
+ * this round's edits introduced, never re-open a verified resolution.
  */
-export function buildReReviewBrief(reviewerResult: SingleResult, round: number): string {
+export function buildReReviewBrief(reviewerResult: SingleResult, round: number, workerResult: SingleResult): string {
 	const review = getResultOutput(reviewerResult);
+	const workerReport = getResultOutput(workerResult);
 	return [
 		`Re-review after auto-fix round ${round}.`,
 		``,
@@ -154,8 +147,18 @@ export function buildReReviewBrief(reviewerResult: SingleResult, round: number):
 		review,
 		`---`,
 		``,
-		`Verify the worker's fixes address each blocker. Run \`git diff\` to see what changed.`,
-		`Classify honestly: APPROVE if blockers are resolved, REQUEST_CHANGES if not.`,
+		`The worker's report (what it changed, plus any finding it rejected as factually wrong or out of scope):`,
+		`---`,
+		workerReport,
+		`---`,
+		``,
+		`Rule on EVERY previous finding: resolved, or still open. A finding the worker rejected must be`,
+		`adjudicated ONCE — accept the rejection unless you can concretely refute the worker's reasoning;`,
+		`never simply restate the finding for another round.`,
+		`Run \`git diff\` to see what changed, then add NEW findings only when they are defects this round's`,
+		`edits introduced or exposed (or a load-bearing issue the earlier review genuinely missed).`,
+		`Do NOT re-open a finding you verified as resolved.`,
+		`REQUEST_CHANGES only while an open finding remains; otherwise APPROVE.`,
 		`End with your machine-readable verdict line as usual (VERDICT: REVIEW_PASS / REVIEW_FAIL).`,
 	].join("\n");
 }

package/src/format.ts

@@ -127,18 +127,15 @@ export function formatCompletionBlock(
 		lines.push(`Relation: ${relations.join(" · ")}`, "");
 	}
 	lines.push(text);
-	// Explicit status always exposes every retained diagnostic, including when
-	// the overall run failed or was aborted. Automatic delivery adds only a
-	// compact pointer for otherwise-clean runs.
+	// Failed-tool diagnostics are deliberate opt-in via subagent_status: agents
+	// report their own verification in the output above, and a transient failed
+	// call (no-match grep, rejected edit) is noise in an automatic delivery.
 	if (options.failedToolDetails && failedTools.length > 0) {
 		lines.push(
 			"",
 			`⚠ ${failedTools.length} failed tool call${failedTools.length === 1 ? "" : "s"}:`,
 			...failedTools.map((tool) => `- ${tool.toolName}: ${tool.error.trim() || "(no output)"}`),
 		);
-	} else if (!failed && failedTools.length > 0) {
-		const lookup = result.runId !== undefined ? ` · details: subagent_status #${result.runId}` : "";
-		lines.push("", `⚠ ${failedTools.length} failed tool call${failedTools.length === 1 ? "" : "s"}${lookup}`);
 	}
 	if (truncated) {
 		// The full text lives on disk so the main agent can read it on demand.

package/src/monitor.ts

@@ -53,12 +53,15 @@ export interface RunView {
 	groupId?: string;
 	/** Human-readable role within a chain, e.g. "fix round 1" or "re-review round 1". */
 	relationLabel?: string;
+	/** Owning run for chain children: the triggering reviewer whose row represents the chain. */
+	parentRunId?: number;
 }
 
 /** Optional chain metadata for runs spawned by an auto-fix loop. */
 export interface RunChainMeta {
 	groupId?: string;
 	relationLabel?: string;
+	parentRunId?: number;
 	isolation?: IsolationMode;
 	forkedFromRunId?: number;
 }
@@ -248,6 +251,21 @@ export function formatUsageCompact(usage: UsageStats): string {
 	return parts.join(" ");
 }
 
+/** Aggregate usage across several runs (chain steps or a completion group). */
+export function sumUsage(parts: readonly UsageStats[]): UsageStats {
+	const total: UsageStats = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 };
+	for (const part of parts) {
+		total.input += part.input;
+		total.output += part.output;
+		total.cacheRead += part.cacheRead;
+		total.cacheWrite += part.cacheWrite;
+		total.cost += part.cost;
+		total.contextTokens += part.contextTokens;
+		total.turns += part.turns;
+	}
+	return total;
+}
+
 export function formatDuration(ms: number): string {
 	const totalSeconds = Math.max(0, Math.floor(ms / 1000));
 	if (totalSeconds < 60) return `${totalSeconds}s`;
@@ -393,6 +411,7 @@ export class MonitorStore {
 			usage: emptyUsage(),
 			...(meta?.groupId ? { groupId: meta.groupId } : {}),
 			...(meta?.relationLabel ? { relationLabel: meta.relationLabel } : {}),
+			...(meta?.parentRunId !== undefined ? { parentRunId: meta.parentRunId } : {}),
 			...(meta?.isolation ? { isolation: meta.isolation, integrationStatus: meta.isolation === "worktree" ? "pending" : undefined } : {}),
 			...(meta?.forkedFromRunId !== undefined ? { forkedFromRunId: meta.forkedFromRunId } : {}),
 		});

package/src/prompt.ts

@@ -78,7 +78,7 @@ Result handoff (do not re-state):
 
 Review & verification:
 - Never report an unrun check as passed; report it as unavailable or as a pre-existing failure.
-${hasReviewer ? `- For non-trivial diffs${hasCleaner ? " (including cleaner edits)" : ""}, run one fresh read-only \`reviewer\` sub-agent before reporting done. Fix only concrete blockers and re-review at most once.
+${hasReviewer ? `- For non-trivial diffs${hasCleaner ? " (including cleaner edits)" : ""}, run one fresh read-only \`reviewer\` sub-agent before reporting done. Fix every finding the reviewer reports and re-review at most once.
 - Use multi-model cross-review only when explicitly requested or for genuinely high-risk changes (security, unsafe/FFI, persistence-migration, concurrency). Reviewers are read-only; only the main agent edits.
-` : ""}- Commit or push only when explicitly requested, applicable checks pass, and no accepted blockers remain.`;
+` : ""}- Commit or push only when explicitly requested, applicable checks pass, and no unresolved review findings remain.`;
 }

package/src/thread-lifecycle.ts

@@ -966,6 +966,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 							? `${formatCompletionBlock(result, runConfig.maxResultLines, result.projectCwd ?? originalCwd)}\n\n${modelLevelTakeoverNote(result, { runId })}`
 							: formatCompletionBlock(result, runConfig.maxResultLines, result.projectCwd ?? originalCwd),
 						triggerTurn: completionTriggersTurn(result, runConfig.notifyOnReviewPass),
+						usage: result.usage,
 					};
 					if (modelLevel) {
 						const detail = result.errorMessage?.trim() || "model unavailable or broken";
@@ -1040,6 +1041,7 @@ export function createBackgroundDispatcher(options: BackgroundDispatcherOptions)
 								agent: agent.name,
 								block: formatCompletionBlock(crashed, runConfig.maxResultLines, crashed.projectCwd ?? originalCwd),
 								triggerTurn: true,
+								usage: crashed.usage,
 							},
 						]);
 						runtime.completionBatcher.flush();

package/src/tools.ts

@@ -695,6 +695,7 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 					agent: result.agent,
 					block: formatCompletionBlock(result, maxResultLines, result.projectCwd ?? ctx.cwd),
 					triggerTurn: true,
+					usage: result.usage,
 				})));
 				runtime.completionBatcher.flush();
 			}

package/src/widget.ts

@@ -29,65 +29,107 @@ function compactLine(left: string, right: string, width: number): string {
  * activity line. The primary line reserves effective model/thinking and elapsed
  * width before truncating the task. Settled and parked threads never appear, so
  * elapsed time cannot keep ticking beside a terminal status. */
+function runPrimaryLine(
+	run: RunView,
+	theme: Theme,
+	width: number,
+	now: number,
+	prefix: string,
+): string {
+	const dim = (text: string): string => theme.fg("dim", text);
+	const icon = statusIcon(run.status, theme);
+	const name = theme.fg("accent", theme.bold(run.agent));
+	const identity = `${prefix}${icon} ${name}`;
+	const elapsed = formatElapsed(run, now);
+	// Render only the resolved model id plus thinking level. Provider auth and
+	// other configuration never enter monitor state or this line.
+	const modelId = run.model?.split("/").at(-1);
+	const modelSource = formatTaskSummary(
+		modelId ? `${modelId}${run.thinking ? `/${run.thinking}` : ""}` : run.thinking ? `thinking:${run.thinking}` : "",
+		64,
+		false,
+	);
+	// A chain child shows its role in the chain plus a task-derived label; the
+	// templated fix brief itself would only repeat the parent review's content.
+	const taskSource = run.parentRunId !== undefined
+		? [run.relationLabel, run.label].filter((part): part is string => Boolean(part)).join(" · ")
+		: formatTaskSummary(run.task, 64);
+	const primaryPartCount = 2 + (modelSource ? 1 : 0) + (elapsed ? 1 : 0);
+	const contentWidth = Math.max(
+		0,
+		width -
+			visibleWidth(identity) -
+			visibleWidth(elapsed) -
+			(primaryPartCount - 1) * visibleWidth(" · "),
+	);
+	const modelDesired = visibleWidth(modelSource);
+	const modelFloor = Math.min(modelDesired, Math.min(12, contentWidth));
+	let modelWidth = modelSource
+		? Math.min(modelDesired, Math.max(modelFloor, contentWidth - 8))
+		: 0;
+	let taskWidth = contentWidth - modelWidth;
+	if (visibleWidth(taskSource) < taskWidth) {
+		modelWidth = Math.min(modelDesired, modelWidth + taskWidth - visibleWidth(taskSource));
+		taskWidth = contentWidth - modelWidth;
+	}
+	const task = taskWidth > 0 ? formatTaskSummary(taskSource, taskWidth, run.parentRunId === undefined) : "";
+	const modelThinking = modelWidth > 0 ? formatTaskSummary(modelSource, modelWidth, false) : "";
+	const primaryLeft = [
+		identity,
+		task ? dim(task) : undefined,
+		modelThinking ? dim(modelThinking) : undefined,
+	].filter((part): part is string => Boolean(part)).join(" · ");
+	return compactLine(primaryLeft, elapsed ? dim(`· ${elapsed}`) : "", width);
+}
+
+function runActivityLine(run: RunView, theme: Theme, width: number, indent: string): string[] {
+	const dim = (text: string): string => theme.fg("dim", text);
+	const activity = run.activity?.trim();
+	if (!activity) return [];
+	const activityWidth = width - visibleWidth(indent);
+	if (activityWidth <= 0) return [];
+	const activitySummary = formatTaskSummary(activity, activityWidth);
+	if (!activitySummary) return [];
+	return [truncateToWidth(`${indent}${dim(activitySummary)}`, width, "")];
+}
+
+/** Render active runs as a tree: main-agent dispatches are roots, auto-fix chain
+ * rounds nest under the triggering reviewer row that owns the chain. No run ids
+ * appear here — the tree and the task label say what each row is, and ids stay
+ * available through subagent_status when a thread must be controlled. */
 export function formatActiveRunLines(
 	runs: readonly RunView[],
 	theme: Theme,
 	width: number,
 	now: number = Date.now(),
 ): string[] {
-	const dim = (text: string): string => theme.fg("dim", text);
-	return runs
-		.filter((run) => isRunActiveStatus(run.status))
-		.flatMap((run) => {
-			const icon = statusIcon(run.status, theme);
-			const name = theme.fg("accent", theme.bold(run.agent));
-			const identity = `${icon} ${dim(`#${run.id}`)} ${name}`;
-			const elapsed = formatElapsed(run, now);
-			// Render only the resolved model id plus thinking level. Provider auth and
-			// other configuration never enter monitor state or this line.
-			const modelId = run.model?.split("/").at(-1);
-			const modelSource = formatTaskSummary(
-				modelId ? `${modelId}${run.thinking ? `/${run.thinking}` : ""}` : run.thinking ? `thinking:${run.thinking}` : "",
-				64,
-				false,
-			);
-			const taskSource = formatTaskSummary(run.task, 64);
-			const primaryPartCount = 2 + (modelSource ? 1 : 0) + (elapsed ? 1 : 0);
-			const contentWidth = Math.max(
-				0,
-				width -
-					visibleWidth(identity) -
-					visibleWidth(elapsed) -
-					(primaryPartCount - 1) * visibleWidth(" · "),
-			);
-			const modelDesired = visibleWidth(modelSource);
-			const modelFloor = Math.min(modelDesired, Math.min(12, contentWidth));
-			let modelWidth = modelSource
-				? Math.min(modelDesired, Math.max(modelFloor, contentWidth - 8))
-				: 0;
-			let taskWidth = contentWidth - modelWidth;
-			if (visibleWidth(taskSource) < taskWidth) {
-				modelWidth = Math.min(modelDesired, modelWidth + taskWidth - visibleWidth(taskSource));
-				taskWidth = contentWidth - modelWidth;
-			}
-			const task = taskWidth > 0 ? formatTaskSummary(taskSource, taskWidth) : "";
-			const modelThinking = modelWidth > 0 ? formatTaskSummary(modelSource, modelWidth, false) : "";
-			const primaryLeft = [
-				identity,
-				task ? dim(task) : undefined,
-				modelThinking ? dim(modelThinking) : undefined,
-			].filter((part): part is string => Boolean(part)).join(" · ");
-			const primary = compactLine(primaryLeft, elapsed ? dim(`· ${elapsed}`) : "", width);
-
-			const activity = run.activity?.trim();
-			if (!activity) return [primary];
-			const activityIndent = "  ";
-			const activityWidth = width - visibleWidth(activityIndent);
-			if (activityWidth <= 0) return [primary];
-			const activitySummary = formatTaskSummary(activity, activityWidth);
-			if (!activitySummary) return [primary];
-			return [primary, truncateToWidth(`${activityIndent}${dim(activitySummary)}`, width, "")];
+	const active = runs.filter((run) => isRunActiveStatus(run.status));
+	const activeIds = new Set(active.map((run) => run.id));
+	const childrenOf = new Map<number, RunView[]>();
+	const roots: RunView[] = [];
+	for (const run of active) {
+		if (run.parentRunId !== undefined && activeIds.has(run.parentRunId)) {
+			const siblings = childrenOf.get(run.parentRunId);
+			if (siblings) siblings.push(run);
+			else childrenOf.set(run.parentRunId, [run]);
+		} else {
+			roots.push(run);
+		}
+	}
+	const lines: string[] = [];
+	for (const root of roots) {
+		const children = childrenOf.get(root.id) ?? [];
+		lines.push(runPrimaryLine(root, theme, width, now, ""));
+		// The parent's "auto-fix chain running" placeholder is redundant while its
+		// child rows show live progress; keep it only between rounds.
+		if (children.length === 0) lines.push(...runActivityLine(root, theme, width, "  "));
+		children.forEach((child, index) => {
+			const connector = index === children.length - 1 ? "└ " : "├ ";
+			lines.push(runPrimaryLine(child, theme, width, now, theme.fg("dim", `  ${connector}`)));
+			lines.push(...runActivityLine(child, theme, width, "      "));
 		});
+	}
+	return lines;
 }
 
 function hasTickingRun(): boolean {