@ferris1225/pi-subagents 0.24.0 → 0.26.0

package/package.json

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

@@ -1,106 +1,112 @@
-/**
- * Bounded background task scheduler.
- *
- * Tasks get their own AbortSignal rather than inheriting the foreground agent
- * turn's signal. The owning extension cancels all work only on session teardown.
- *
- * Task exceptions are never swallowed: the per-task onError callback receives
- * them (unless the task was cancelled) so callers can surface the failure to
- * the user and the main agent instead of it vanishing into the queue.
- */
-
-export type BackgroundTask = (signal: AbortSignal) => Promise<void>;
-
-interface PendingTask {
-	task: BackgroundTask;
-	controller: AbortController;
-	onCancelled?: () => void;
-	/** Invoked when the task throws and was not cancelled (cancellation is not a
-	 * failure — e.g. session shutdown races must never be reported as errors). */
-	onError?: (error: unknown) => void;
-}
-
-export class BackgroundTaskQueue {
-	private concurrency: number;
-	private readonly pending: PendingTask[] = [];
-	private readonly active = new Set<AbortController>();
-	private stopped = false;
-
-	constructor(concurrency: number) {
-		this.concurrency = Math.max(1, concurrency);
-	}
-
-	/**
-	 * Update the concurrency limit (e.g. after a config change). Raising it
-	 * immediately starts more queued work; lowering it takes effect as running
-	 * tasks finish — already-running tasks are never interrupted.
-	 */
-	setConcurrency(concurrency: number): void {
-		this.concurrency = Math.max(1, concurrency);
-		this.drain();
-	}
-
-	enqueue(task: BackgroundTask, onCancelled?: () => void, onError?: (error: unknown) => void): AbortController {
-		const controller = new AbortController();
-		if (this.stopped) {
-			controller.abort();
-			this.runCancelled(onCancelled);
-			return controller;
-		}
-
-		this.pending.push({ task, controller, onCancelled, onError });
-		this.drain();
-		return controller;
-	}
-
-	/** Stop queued work and request cancellation for running work. */
-	cancelAll(): void {
-		if (this.stopped) return;
-		this.stopped = true;
-
-		for (const entry of this.pending.splice(0)) {
-			entry.controller.abort();
-			this.runCancelled(entry.onCancelled);
-		}
-		for (const controller of this.active) controller.abort();
-	}
-
-	/** Cancellation callbacks are user-supplied: a throw must never break the queue
-	 * (mirrors the try/catch around onError in drain). */
-	private runCancelled(callback: (() => void) | undefined): void {
-		if (!callback) return;
-		try {
-			callback();
-		} catch {
-			/* cancellation callbacks must never break the queue */
-		}
-	}
-
-	private drain(): void {
-		while (!this.stopped && this.active.size < this.concurrency) {
-			const entry = this.pending.shift();
-			if (!entry) return;
-			if (entry.controller.signal.aborted) {
-				this.runCancelled(entry.onCancelled);
-				continue;
-			}
-
-			this.active.add(entry.controller);
-			void entry.task(entry.controller.signal)
-				.catch((error: unknown) => {
-					// Cancellation is not a failure: aborted work (e.g. session
-					// shutdown) must never be reported as an exception.
-					if (entry.controller.signal.aborted) return;
-					try {
-						entry.onError?.(error);
-					} catch {
-						/* error reporting must never break the queue */
-					}
-				})
-				.finally(() => {
-					this.active.delete(entry.controller);
-					this.drain();
-				});
-		}
-	}
-}
+/**
+ * Bounded background task scheduler.
+ *
+ * Tasks get their own AbortSignal rather than inheriting the foreground agent
+ * turn's signal. The owning extension cancels all work only on session teardown.
+ *
+ * Task exceptions are never swallowed: the per-task onError callback receives
+ * them (unless the task was cancelled) so callers can surface the failure to
+ * the user and the main agent instead of it vanishing into the queue.
+ */
+
+export type BackgroundTask = (signal: AbortSignal) => Promise<void>;
+
+interface PendingTask {
+	task: BackgroundTask;
+	controller: AbortController;
+	/** Called when a queued task is aborted before its body ever runs (drain skips
+	 * an already-aborted entry; cancelAll aborts every pending entry), so the
+	 * task body never produces a result. Callers that resolve waiters on a run id
+	 * must register a synthetic result here (or via a stop path) — otherwise a
+	 * waiter resolves via a "removed before its result was recorded" note. Never
+	 * called for a task whose body already started; that path owns its result. */
+	onCancelled?: () => void;
+	/** Invoked when the task throws and was not cancelled (cancellation is not a
+	 * failure — e.g. session shutdown races must never be reported as errors). */
+	onError?: (error: unknown) => void;
+}
+
+export class BackgroundTaskQueue {
+	private concurrency: number;
+	private readonly pending: PendingTask[] = [];
+	private readonly active = new Set<AbortController>();
+	private stopped = false;
+
+	constructor(concurrency: number) {
+		this.concurrency = Math.max(1, concurrency);
+	}
+
+	/**
+	 * Update the concurrency limit (e.g. after a config change). Raising it
+	 * immediately starts more queued work; lowering it takes effect as running
+	 * tasks finish — already-running tasks are never interrupted.
+	 */
+	setConcurrency(concurrency: number): void {
+		this.concurrency = Math.max(1, concurrency);
+		this.drain();
+	}
+
+	enqueue(task: BackgroundTask, onCancelled?: () => void, onError?: (error: unknown) => void): AbortController {
+		const controller = new AbortController();
+		if (this.stopped) {
+			controller.abort();
+			this.runCancelled(onCancelled);
+			return controller;
+		}
+
+		this.pending.push({ task, controller, onCancelled, onError });
+		this.drain();
+		return controller;
+	}
+
+	/** Stop queued work and request cancellation for running work. */
+	cancelAll(): void {
+		if (this.stopped) return;
+		this.stopped = true;
+
+		for (const entry of this.pending.splice(0)) {
+			entry.controller.abort();
+			this.runCancelled(entry.onCancelled);
+		}
+		for (const controller of this.active) controller.abort();
+	}
+
+	/** Cancellation callbacks are user-supplied: a throw must never break the queue
+	 * (mirrors the try/catch around onError in drain). */
+	private runCancelled(callback: (() => void) | undefined): void {
+		if (!callback) return;
+		try {
+			callback();
+		} catch {
+			/* cancellation callbacks must never break the queue */
+		}
+	}
+
+	private drain(): void {
+		while (!this.stopped && this.active.size < this.concurrency) {
+			const entry = this.pending.shift();
+			if (!entry) return;
+			if (entry.controller.signal.aborted) {
+				this.runCancelled(entry.onCancelled);
+				continue;
+			}
+
+			this.active.add(entry.controller);
+			void entry.task(entry.controller.signal)
+				.catch((error: unknown) => {
+					// Cancellation is not a failure: aborted work (e.g. session
+					// shutdown) must never be reported as an exception.
+					if (entry.controller.signal.aborted) return;
+					try {
+						entry.onError?.(error);
+					} catch {
+						/* error reporting must never break the queue */
+					}
+				})
+				.finally(() => {
+					this.active.delete(entry.controller);
+					this.drain();
+				});
+		}
+	}
+}

package/src/fixloop.ts

@@ -1,76 +1,84 @@
-/**
- * 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");
-}
+/**
+ * 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;
+	// A dispatch crash (spawn infra, delivery API, ...) is never a real review
+	// verdict: its output is an error message plus whatever partial text the
+	// child happened to emit, which could end in a stray `VERDICT: REVIEW_FAIL`.
+	// Guard explicitly in addition to isFailedResult so the intent is clear and
+	// a future change to isFailedResult can never let a crashed reviewer start a
+	// phantom auto-fix chain (and re-add a run controller id that was deleted in
+	// the catch path).
+	if (result.dispatchFailed) 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");
+}