@ferris1225/pi-subagents 0.10.0 → 0.11.0

package/README.md

@@ -145,7 +145,8 @@ agent's default — its frontmatter `thinking`, else the global default). The gl
   "agentScope": "user",
   "maxConcurrency": 4,
   "maxParallelTasks": 8,
-  "maxSubagentDepth": 1
+  "maxSubagentDepth": 1,
+  "maxFixRounds": 2
 }
 ```
 
@@ -162,6 +163,7 @@ agent's default — its frontmatter `thinking`, else the global default). The gl
 | `maxConcurrency` | How many sub-agent processes run at once (1–16, default 4). Extra work waits in the queue. |
 | `maxParallelTasks` | Maximum tasks accepted by one parallel `subagent` call (1–32, default 8). |
 | `maxSubagentDepth` | Depth at which the `subagent` tool is no longer registered (default 1: the main session delegates, children are leaf processes). `0` disables the tool entirely. Read once at extension load. |
+| `maxFixRounds` | Auto-fix rounds when a reviewer returns `REVIEW_FAIL`: the extension dispatches a `worker` (briefed with the review's concrete findings) then a `reviewer` re-review, repeating up to this many times before waking the main agent with the full chain. `0` disables it (the main agent handles fixes itself). Default 2. The reviewer stays read-only and in its own context; the loop is orchestrated by the extension, not by the reviewer. |
 
 ### Configuration migration
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferris1225/pi-subagents",
-  "version": "0.10.0",
+  "version": "0.11.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/config.ts

@@ -60,6 +60,14 @@ export const MAX_PARALLEL_TASKS_LIMIT = 32;
 export const DEFAULT_MAX_SUBAGENT_DEPTH = 1;
 /** Upper bound accepted for maxSubagentDepth (defensive clamp). */
 export const MAX_SUBAGENT_DEPTH_LIMIT = 4;
+/**
+ * How many automatic worker→reviewer fix rounds run when a reviewer returns
+ * REVIEW_FAIL before waking the main agent. 0 disables the auto-fix loop
+ * (the main agent is woken to dispatch fixes itself). Default: 2.
+ */
+export const DEFAULT_MAX_FIX_ROUNDS = 2;
+/** Upper bound accepted for maxFixRounds (defensive clamp). 0 disables the loop. */
+export const MAX_FIX_ROUNDS_LIMIT = 5;
 
 export interface SubagentsConfig {
 	/** Agent names that are discoverable and injected. Default: explore, worker, reviewer. */
@@ -91,6 +99,14 @@ export interface SubagentsConfig {
 	maxParallelTasks: number;
 	/** Depth at which the subagent tool is no longer registered. Default: 1. */
 	maxSubagentDepth: number;
+	/**
+	 * Auto-fix rounds when a reviewer returns REVIEW_FAIL: the extension dispatches
+	 * a worker (briefed with the review's concrete findings) then a reviewer
+	 * re-review, repeating up to this many times before waking the main agent with
+	 * the full chain. 0 disables it (the main agent handles fixes itself).
+	 * Default: 2.
+	 */
+	maxFixRounds: number;
 }
 
 export const DEFAULT_CONFIG: SubagentsConfig = {
@@ -105,6 +121,7 @@ export const DEFAULT_CONFIG: SubagentsConfig = {
 	maxConcurrency: DEFAULT_MAX_CONCURRENCY,
 	maxParallelTasks: DEFAULT_MAX_PARALLEL_TASKS,
 	maxSubagentDepth: DEFAULT_MAX_SUBAGENT_DEPTH,
+	maxFixRounds: DEFAULT_MAX_FIX_ROUNDS,
 };
 
 export function getConfigPath(agentDir: string = getAgentDir()): string {
@@ -151,6 +168,7 @@ export function normalizeConfig(raw: unknown): SubagentsConfig {
 		maxConcurrency: DEFAULT_CONFIG.maxConcurrency,
 		maxParallelTasks: DEFAULT_CONFIG.maxParallelTasks,
 		maxSubagentDepth: DEFAULT_CONFIG.maxSubagentDepth,
+		maxFixRounds: DEFAULT_CONFIG.maxFixRounds,
 	};
 
 	if (Array.isArray(raw.enabledAgents)) {
@@ -213,6 +231,11 @@ export function normalizeConfig(raw: unknown): SubagentsConfig {
 		config.maxSubagentDepth = Math.max(0, Math.min(MAX_SUBAGENT_DEPTH_LIMIT, Math.round(raw.maxSubagentDepth)));
 	}
 
+	// 0 disables the auto-fix loop (main agent handles fixes itself).
+	if (typeof raw.maxFixRounds === "number" && Number.isFinite(raw.maxFixRounds)) {
+		config.maxFixRounds = Math.max(0, Math.min(MAX_FIX_ROUNDS_LIMIT, Math.round(raw.maxFixRounds)));
+	}
+
 	return config;
 }
 

package/src/fixloop.ts

@@ -0,0 +1,76 @@
+/**
+ * Auto-fix loop: when a reviewer returns REVIEW_FAIL, the extension dispatches a
+ * worker (briefed with the review's concrete findings) and then a reviewer
+ * re-review, repeating up to maxFixRounds times before waking the main agent with
+ * the full chain. The reviewer stays read-only and in its own context; the loop
+ * is orchestrated by the extension layer, not by the reviewer itself, so the
+ * independence guarantee (no self-confirmation bias) is preserved.
+ *
+ * The main agent is never woken mid-loop: the reviewer's FAIL result is intercepted
+ * before delivery, the chain runs in the background, and only the final group
+ * (initial review → worker fixes → re-reviews) is delivered at the end.
+ */
+
+import { getResultOutput, isFailedResult, reviewVerdict, type SingleResult } from "./spawn.ts";
+import type { SubagentsConfig } from "./config.ts";
+
+/**
+ * Whether a completed result should trigger the auto-fix loop instead of being
+ * delivered to the main agent. Only a REVIEW_FAIL verdict from a healthy
+ * reviewer run counts; failed processes and passing reviews are delivered
+ * normally. Loop-internal re-review results never reach this path (they are
+ * awaited inside the loop, not delivered through the completion flow).
+ */
+export function shouldTriggerFixLoop(result: SingleResult, config: SubagentsConfig): boolean {
+	if (config.maxFixRounds <= 0) return false;
+	if (result.agent !== "reviewer") return false;
+	if (isFailedResult(result)) return false;
+	return reviewVerdict(getResultOutput(result)) === "fail";
+}
+
+/**
+ * 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.
+ */
+export function buildFixTaskBrief(reviewerResult: SingleResult, round: number, maxRounds: number): string {
+	const review = getResultOutput(reviewerResult);
+	const remaining = maxRounds - round;
+	return [
+		`Auto-fix round ${round} of ${maxRounds} (triggered by a failed review).`,
+		``,
+		`A reviewer ran in an isolated context and returned REQUEST_CHANGES. Its full report:`,
+		`---`,
+		review,
+		`---`,
+		``,
+		`Fix the concrete blockers the reviewer flagged. Do NOT refactor unrelated code.`,
+		`Address every "Critical" item; address "Warnings" only if they are genuine.`,
+		`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
+			? `A reviewer will re-review your changes automatically after you finish.`
+			: `This is the last auto-fix round; the main agent will be woken with the full chain.`,
+	].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
+ * the original issues.
+ */
+export function buildReReviewBrief(reviewerResult: SingleResult, round: number): string {
+	const review = getResultOutput(reviewerResult);
+	return [
+		`Re-review after auto-fix round ${round}.`,
+		``,
+		`The previous review (REQUEST_CHANGES) found these issues:`,
+		`---`,
+		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.`,
+		`End with your machine-readable verdict line as usual (VERDICT: REVIEW_PASS / REVIEW_FAIL).`,
+	].join("\n");
+}

package/src/index.ts

@@ -34,6 +34,7 @@ import {
 	getFinalOutput,
 	getResultOutput,
 	isFailedResult,
+	reviewVerdict,
 	runSingleAgent,
 	truncateResultOutput,
 	writeResultArtifact,
@@ -42,7 +43,8 @@ import {
 	type SubagentLiveEvent,
 	type UsageStats,
 } from "./spawn.ts";
-import { formatTaskSummary, formatToolActivity, monitor, statusColor, statusIcon, statusLabel } from "./monitor.ts";
+import { buildFixTaskBrief, buildReReviewBrief, shouldTriggerFixLoop } from "./fixloop.ts";
+import { formatTaskSummary, formatToolActivity, monitor, statusColor, statusIcon, statusLabel, type RunChainMeta } from "./monitor.ts";
 
 const NON_BLANK_TASK_OPTIONS = { minLength: 1, pattern: "\\S" } as const;
 
@@ -333,6 +335,95 @@ export default function (pi: ExtensionAPI): void {
 				};
 			}
 
+			/**
+			 * Dispatch one agent inside an auto-fix chain: tracked in the widget with a
+			 * groupId/relationLabel, but NOT delivered through the completion flow — the
+			 * chain owner assembles and delivers the whole group at the end.
+			 */
+			const launchInLoop = async (
+				agentName: string,
+				task: string,
+				signal: AbortSignal,
+				meta: RunChainMeta,
+			): Promise<SingleResult> => {
+				const agent = agents.find((candidate) => candidate.name === agentName);
+				if (!agent) return 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);
+				try {
+					const result = await runSingleAgent({
+						defaultCwd: ctx.cwd,
+						agent,
+						agentName,
+						task,
+						thinkingLevel,
+						signal,
+						onLive,
+						makeDetails: makeDetails("single", true),
+					});
+					finishRun(runId, isFailedResult(result) ? "failed" : "done");
+					return result;
+				} catch (error) {
+					finishRun(runId, "failed");
+					const errorMessage = error instanceof Error ? error.message : String(error);
+					return {
+						...queuedResult(agent, task, thinkingLevel),
+						exitCode: 1,
+						stderr: errorMessage,
+						stopReason: signal.aborted ? "aborted" : "error",
+						errorMessage,
+					};
+				}
+			};
+
+			/**
+			 * Run the auto-fix chain in the background: worker (briefed with the review's
+			 * findings) → reviewer re-review, up to maxFixRounds times. The main agent is
+			 * not woken mid-loop; the full chain is delivered as one group at the end.
+			 * Failures short-circuit: a crashed worker skips its re-review and delivers.
+			 */
+			const startFixLoop = (initialReviewerResult: SingleResult, parentGroupId: string): void => {
+				backgroundQueue.enqueue(
+					async (signal) => {
+						const chain: SingleResult[] = [initialReviewerResult];
+						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, {
+								groupId: parentGroupId,
+								relationLabel: `fix round ${round}`,
+							});
+							chain.push(workerResult);
+							if (!sessionActive || isFailedResult(workerResult)) break;
+							const reReviewBrief = buildReReviewBrief(lastReviewer, round);
+							const reviewResult = await launchInLoop("reviewer", reReviewBrief, signal, {
+								groupId: parentGroupId,
+								relationLabel: `re-review round ${round}`,
+							});
+							chain.push(reviewResult);
+							lastReviewer = reviewResult;
+							if (!sessionActive) break;
+							if (reviewVerdict(getResultOutput(reviewResult)) === "pass") break;
+						}
+						if (!sessionActive) return;
+						// 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).
+						const items: CompletionMessageItem[] = chain.map((r) => ({
+							agent: r.agent,
+							block: formatCompletionBlock(r, config.maxResultLines),
+							triggerTurn: true,
+						}));
+						sendCompletionGroup(items);
+						completionBatcher.flush();
+					},
+					() => {
+						// Cancelled: each in-flight run was already finished by its launchInLoop path.
+					},
+				);
+			};
+
 			const startBackground = (agentName: string, task: string, cwd?: string): SingleResult => {
 				const agent = agents.find((candidate) => candidate.name === agentName);
 				if (!agent) return failedStartResult(agentName, task, `Unknown agent: "${agentName}".`);
@@ -371,6 +462,15 @@ export default function (pi: ExtensionAPI): void {
 						}
 
 						if (!sessionActive) return;
+						// Auto-fix loop: a REVIEW_FAIL from a main-agent-dispatched reviewer
+						// triggers a worker→reviewer chain (up to maxFixRounds) without waking
+						// the main agent. Loop-internal re-reviews never reach here (they are
+						// awaited inside launchInLoop); the initial review is delivered with
+						// the chain at the end.
+						if (shouldTriggerFixLoop(result, config)) {
+							startFixLoop(result, `fix-${runId}`);
+							return;
+						}
 						const failed = isFailedResult(result);
 						const completion: CompletionMessageItem = {
 							agent: result.agent,
@@ -518,7 +618,10 @@ export default function (pi: ExtensionAPI): void {
 						for (const r of runs) {
 							const icon = statusIcon(r.status, theme);
 							const label = theme.fg(statusColor(r.status), statusLabel(r.status));
-							lines.push(truncateToWidth(` ${icon} ${monitor.summarize(r)} · ${label}`, width, ""));
+							// Chain-internal runs (auto-fix worker/reviewer) indent under their
+							// parent reviewer; summarize() already carries the relationLabel.
+							const head = r.groupId ? theme.fg("dim", "  ↳ ") : " ";
+							lines.push(truncateToWidth(`${head}${icon} ${monitor.summarize(r)} · ${label}`, width, ""));
 							if (r.status === "queued" || r.status === "running") {
 								lines.push(truncateToWidth(theme.fg("dim", `     task: ${formatTaskSummary(r.task)}`), width, ""));
 							}

package/src/monitor.ts

@@ -36,6 +36,16 @@ export interface RunView {
 	startedAt?: number;
 	/** Epoch ms when the run finished (set on "done"/"failed"). */
 	endedAt?: number;
+	/** When set, this run belongs to an auto-fix chain (e.g. worker fixing a reviewer's findings). */
+	groupId?: string;
+	/** Human-readable role within a chain, e.g. "fix round 1" or "re-review round 1". */
+	relationLabel?: string;
+}
+
+/** Optional chain metadata for runs spawned by an auto-fix loop. */
+export interface RunChainMeta {
+	groupId?: string;
+	relationLabel?: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -168,7 +178,7 @@ export class MonitorStore {
 		this.notify();
 	}
 
-	addRun(agent: string, task: string, model?: string, thinking?: string): number {
+	addRun(agent: string, task: string, model?: string, thinking?: string, meta?: RunChainMeta): number {
 		const id = this.nextId++;
 		this.runs.push({
 			id,
@@ -178,6 +188,8 @@ export class MonitorStore {
 			thinking,
 			status: "queued",
 			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+			...(meta?.groupId ? { groupId: meta.groupId } : {}),
+			...(meta?.relationLabel ? { relationLabel: meta.relationLabel } : {}),
 		});
 		this.notify();
 		return id;
@@ -233,6 +245,7 @@ export class MonitorStore {
 	summarize(run: RunView): string {
 		const usage = formatUsageCompact(run.usage);
 		const parts = [run.agent];
+		if (run.relationLabel) parts.push(run.relationLabel);
 		if (run.model) parts.push(run.model);
 		if (run.thinking) parts.push(`thinking ${run.thinking}`);
 		if (usage) parts.push(usage);

package/src/setup.ts

@@ -15,6 +15,7 @@ import {
 	DEFAULT_CONFIG,
 	DEFAULT_ENABLED_AGENTS,
 	DEFAULT_MAX_CONCURRENCY,
+	DEFAULT_MAX_FIX_ROUNDS,
 	DEFAULT_MAX_PARALLEL_TASKS,
 	THINKING_LEVEL_VALUES,
 	type AgentScope,
@@ -196,6 +197,8 @@ async function pickInjection(ctx: ExtensionCommandContext, current: boolean): Pr
 /** Preset steps offered for the two numeric limits (selection-only wizard). */
 const CONCURRENCY_STEPS = [1, 2, 3, 4, 6, 8, 12, 16];
 const PARALLEL_TASK_STEPS = [2, 4, 6, 8, 12, 16, 24, 32];
+/** Preset rounds offered for the auto-fix loop (0 disables it). */
+const FIX_ROUNDS_STEPS = [0, 1, 2, 3, 5];
 
 async function pickCount(
 	ctx: ExtensionCommandContext,
@@ -295,9 +298,18 @@ async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, ba
 		base.maxParallelTasks,
 		DEFAULT_MAX_PARALLEL_TASKS,
 	);
-	if (maxParallelTasks === undefined) return notifyCancelled(ctx);
+		if (maxParallelTasks === undefined) return notifyCancelled(ctx);
+
+		const maxFixRounds = await pickCount(
+			ctx,
+			"Auto-fix rounds when a reviewer returns REQUEST_CHANGES? (0 = main agent handles fixes)",
+			FIX_ROUNDS_STEPS,
+			base.maxFixRounds,
+			DEFAULT_MAX_FIX_ROUNDS,
+		);
+		if (maxFixRounds === undefined) return notifyCancelled(ctx);
 
-	const next: SubagentsConfig = {
+		const next: SubagentsConfig = {
 		enabledAgents: enabled,
 		agentModels: repairStaleModels(ctx, picked.models),
 		agentThinkingLevels: picked.strengths,
@@ -309,6 +321,7 @@ async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, ba
 		maxConcurrency,
 		maxParallelTasks,
 		maxSubagentDepth: base.maxSubagentDepth,
+		maxFixRounds,
 	};
 	await saveConfig(next, configPath);
 	ctx.ui.notify(`pi-subagents configured. Saved to ${configPath}`, "info");
@@ -323,6 +336,7 @@ async function runMenu(ctx: ExtensionCommandContext, configPath: string, config:
 		"Change agent scope",
 		"Change max concurrent sub-agents",
 		"Change max parallel tasks",
+		"Change max fix rounds",
 		"Full re-setup",
 	]);
 	if (choice === undefined) return notifyCancelled(ctx);
@@ -384,6 +398,16 @@ async function runMenu(ctx: ExtensionCommandContext, configPath: string, config:
 		);
 		if (maxParallelTasks === undefined) return notifyCancelled(ctx);
 		next.maxParallelTasks = maxParallelTasks;
+	} else if (choice.startsWith("Change max fix")) {
+		const maxFixRounds = await pickCount(
+			ctx,
+			"Auto-fix rounds when a reviewer returns REQUEST_CHANGES? (0 = main agent handles fixes)",
+			FIX_ROUNDS_STEPS,
+			config.maxFixRounds,
+			DEFAULT_MAX_FIX_ROUNDS,
+		);
+		if (maxFixRounds === undefined) return notifyCancelled(ctx);
+		next.maxFixRounds = maxFixRounds;
 	}
 
 	await saveConfig(next, configPath);