@ferris1225/pi-subagents 2.0.3 → 2.2.0

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

@@ -1,177 +1,174 @@
-/**
- * Pure formatting/result helpers shared by the subagent tool and the lookup
- * tools (subagent_wait/status): usage rendering, completion blocks, synthetic
- * result constructors, and run-id matching.
- */
-
-import type { AgentConfig } from "./agents.ts";
-import { formatTaskSummary } from "./monitor.ts";
-import { emptyUsage } from "./rpc-run.ts";
-import {
-	getResultOutput,
-	isFailedResult,
-	truncateResultOutput,
-	writeResultArtifact,
-	type SingleResult,
-	type UsageStats,
-} from "./spawn.ts";
-
-export function queuedResult(agent: AgentConfig, task: string, thinking?: string): SingleResult {
-	return {
-		agent: agent.name,
-		task,
-		exitCode: -1,
-		messages: [],
-		stderr: "",
-		usage: emptyUsage(),
-		model: agent.model,
-		...(thinking ? { thinking } : {}),
-	};
-}
-
-export function failedStartResult(agentName: string, task: string, errorMessage: string): SingleResult {
-	return {
-		agent: agentName,
-		task,
-		exitCode: 1,
-		messages: [],
-		stderr: errorMessage,
-		usage: emptyUsage(),
-		errorMessage,
-		dispatchFailed: true,
-	};
-}
-
-/** Failed result for a background task that crashed with an exception (spawn
- * infra, delivery API, ...) instead of returning a normal result. */
-export function dispatchFailedResult(agent: AgentConfig, task: string, error: unknown, thinking?: string): SingleResult {
-	const errorMessage = error instanceof Error ? error.message : String(error);
-	return {
-		...queuedResult(agent, task, thinking),
-		exitCode: 1,
-		stderr: errorMessage,
-		stopReason: "error",
-		errorMessage,
-		dispatchFailed: true,
-	};
-}
-
-function formatTokens(count: number): string {
-	if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
-	if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k`;
-	return String(count);
-}
-
-export function formatUsage(usage: UsageStats): string {
-	const parts: string[] = [];
-	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
-	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
-	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
-	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
-	if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`);
-	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
-	return parts.join(" ");
-}
-
-export interface CompletionFormatOptions {
-	/** Include individual failed-tool errors. Reserved for explicit status lookup. */
-	failedToolDetails?: boolean;
-}
-
-export function formatCompletionBlock(
-	result: SingleResult,
-	maxResultLines: number,
-	cwd?: string,
-	options: CompletionFormatOptions = {},
-): string {
-	const failed = isFailedResult(result);
-	const failedTools = result.failedTools ?? [];
-	const status = failed
-		? "failed"
-		: options.failedToolDetails && failedTools.length > 0
-			? `completed with ${failedTools.length} failed tool call${failedTools.length === 1 ? "" : "s"}`
-			: "completed";
-	const usage = formatUsage(result.usage);
-	const output = getResultOutput(result);
-	const { text, truncated } = truncateResultOutput(output, maxResultLines);
-	const fallbackNote = result.modelFallbackFrom
-		? ` (selected model ${result.modelFallbackFrom} failed → main ${result.model ?? "dynamic default"})`
-		: "";
-	const startupRetryNote = result.startupRetries
-		? ` (recovered after ${result.startupRetries} startup retr${result.startupRetries === 1 ? "y" : "ies"} — concurrent pi startup race)`
-		: "";
-	const relations = [
-		result.forkedFromRunId !== undefined ? `forked from #${result.forkedFromRunId}` : undefined,
-		(result.forkChildRunIds?.length ?? 0) > 0 ? `fork children ${result.forkChildRunIds!.map((id) => `#${id}`).join(", ")}` : undefined,
-	].filter((value): value is string => Boolean(value));
-	const relationNote = relations.length > 0 ? ` · ${relations.join(" · ")}` : "";
-	const runNote = result.runId !== undefined ? ` · run #${result.runId}` : "";
-	const lines = [`### [${result.agent}] ${status}${usage ? ` (${usage})` : ""}${fallbackNote}${startupRetryNote}${runNote}`, "", `Task: ${formatTaskSummary(result.task, 80, false)}`, ""];
-	if (result.isolation === "worktree") {
-		const isolation =
-			result.integrationStatus === "integrated"
-				? "worktree · changes integrated into the original working tree"
-				: result.integrationStatus === "no_changes"
-					? "worktree · no changes; temporary worktree removed"
-					: result.integrationStatus === "retained"
-						? result.integrationApplied
-							? "worktree · changes applied, but cleanup failed; recovery artifacts retained"
-							: "worktree · integration failed; recovery artifacts retained"
-						: "worktree · isolated";
-		lines.push(`Isolation: ${isolation}${relationNote}`);
-		if (result.integrationWorktreePath) lines.push(`Retained worktree: ${result.integrationWorktreePath}`);
-		if (result.integrationPatchPath) lines.push(`Retained patch: ${result.integrationPatchPath}`);
-		if (result.integrationError) lines.push(`Integration error: ${result.integrationError}`);
-		lines.push("");
-	} else if (relations.length > 0) {
-		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.
-	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.
-		lines.push("", `(output truncated to ${maxResultLines} lines; full result: ${writeResultArtifact(output, result.agent, result.projectCwd ?? cwd)})`);
-	}
-	return lines.join("\n");
-}
-
-/** Instruction appended to a model-level failure: the sub-agent's provider never
- * produced usable output (or the run stalled), so the task is handed back to the
- * main window instead of being left as a dead failure. When the run preserved a
- * session with earlier work (and the run id is known), steer the main agent to
- * RESUME it in-context once a model is available, instead of re-dispatching
- * fresh (which would re-scan everything). */
-export function modelLevelTakeoverNote(result: SingleResult, opts?: { runId?: number }): string {
-	const retry = result.modelFallbackFrom ? ", and the current main model also failed" : "";
-	const detail = result.errorMessage?.trim();
-	const cause = detail
-		? `its model/provider call failed (${detail})`
-		: "its model was unavailable or failed (or the run stalled)";
-	const sessionPreserved = Boolean(result.sessionDir && result.sessionId) && opts?.runId !== undefined;
-	const recovery = sessionPreserved
-		? ` The sub-agent's earlier work in this run is preserved. Once a model is available again, call subagent_control with { action: "resume", id: ${opts!.runId} } to CONTINUE it in-context (it keeps the same run id and does not re-scan), or execute the task in the main window with your own tools.`
-		: ` Please execute this task in the main window with your own tools; do not re-dispatch it as a sub-agent.`;
-	return `The sub-agent could not complete this task: ${cause}${retry}.${recovery}`;
-}
-
-/** Resolve a run-id request to actual ids: an exact numeric match always wins
- * (so "1" never fans out to 10, 11, …); only when no exact match exists does a
- * prefix match run, as a convenience for partial ids. Keeps single-digit lookups
- * from returning — or, for subagent_stop, acting on — a whole prefix family. */
-export function matchRunIds(ids: number[], requested: string): number[] {
-	const exact = ids.filter((id) => String(id) === requested);
-	if (exact.length > 0) return exact;
-	return ids.filter((id) => String(id).startsWith(requested));
-}
+/**
+ * Pure formatting/result helpers shared by the subagent tool and the lookup
+ * tools (subagent_wait/status): usage rendering, completion blocks, synthetic
+ * result constructors, and run-id matching.
+ */
+
+import type { AgentConfig } from "./agents.ts";
+import { formatTaskSummary } from "./monitor.ts";
+import { emptyUsage } from "./rpc-run.ts";
+import {
+	getResultOutput,
+	isFailedResult,
+	truncateResultOutput,
+	writeResultArtifact,
+	type SingleResult,
+	type UsageStats,
+} from "./spawn.ts";
+
+export function queuedResult(agent: AgentConfig, task: string, thinking?: string): SingleResult {
+	return {
+		agent: agent.name,
+		task,
+		exitCode: -1,
+		messages: [],
+		stderr: "",
+		usage: emptyUsage(),
+		model: agent.model,
+		...(thinking ? { thinking } : {}),
+	};
+}
+
+export function failedStartResult(agentName: string, task: string, errorMessage: string): SingleResult {
+	return {
+		agent: agentName,
+		task,
+		exitCode: 1,
+		messages: [],
+		stderr: errorMessage,
+		usage: emptyUsage(),
+		errorMessage,
+		dispatchFailed: true,
+	};
+}
+
+/** Failed result for a background task that crashed with an exception (spawn
+ * infra, delivery API, ...) instead of returning a normal result. */
+export function dispatchFailedResult(agent: AgentConfig, task: string, error: unknown, thinking?: string): SingleResult {
+	const errorMessage = error instanceof Error ? error.message : String(error);
+	return {
+		...queuedResult(agent, task, thinking),
+		exitCode: 1,
+		stderr: errorMessage,
+		stopReason: "error",
+		errorMessage,
+		dispatchFailed: true,
+	};
+}
+
+function formatTokens(count: number): string {
+	if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+	if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k`;
+	return String(count);
+}
+
+export function formatUsage(usage: UsageStats): string {
+	const parts: string[] = [];
+	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
+	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
+	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
+	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
+	if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`);
+	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
+	return parts.join(" ");
+}
+
+export interface CompletionFormatOptions {
+	/** Include individual failed-tool errors. Reserved for explicit status lookup. */
+	failedToolDetails?: boolean;
+}
+
+export function formatCompletionBlock(
+	result: SingleResult,
+	maxResultLines: number,
+	cwd?: string,
+	options: CompletionFormatOptions = {},
+): string {
+	const failed = isFailedResult(result);
+	const failedTools = result.failedTools ?? [];
+	const status = failed
+		? "failed"
+		: options.failedToolDetails && failedTools.length > 0
+			? `completed with ${failedTools.length} failed tool call${failedTools.length === 1 ? "" : "s"}`
+			: "completed";
+	const usage = formatUsage(result.usage);
+	const output = getResultOutput(result);
+	const { text, truncated } = truncateResultOutput(output, maxResultLines);
+	const fallbackNote = result.modelFallbackFrom
+		? ` (selected model ${result.modelFallbackFrom} failed → main ${result.model ?? "dynamic default"})`
+		: "";
+	const startupRetryNote = result.startupRetries
+		? ` (recovered after ${result.startupRetries} startup retr${result.startupRetries === 1 ? "y" : "ies"} — concurrent pi startup race)`
+		: "";
+	const relations = [
+		result.forkedFromRunId !== undefined ? `forked from #${result.forkedFromRunId}` : undefined,
+		(result.forkChildRunIds?.length ?? 0) > 0 ? `fork children ${result.forkChildRunIds!.map((id) => `#${id}`).join(", ")}` : undefined,
+	].filter((value): value is string => Boolean(value));
+	const relationNote = relations.length > 0 ? ` · ${relations.join(" · ")}` : "";
+	const runNote = result.runId !== undefined ? ` · run #${result.runId}` : "";
+	const lines = [`### [${result.agent}] ${status}${usage ? ` (${usage})` : ""}${fallbackNote}${startupRetryNote}${runNote}`, "", `Task: ${formatTaskSummary(result.task, 80, false)}`, ""];
+	if (result.isolation === "worktree") {
+		const isolation =
+			result.integrationStatus === "integrated"
+				? "worktree · changes integrated into the original working tree"
+				: result.integrationStatus === "no_changes"
+					? "worktree · no changes; temporary worktree removed"
+					: result.integrationStatus === "retained"
+						? result.integrationApplied
+							? "worktree · changes applied, but cleanup failed; recovery artifacts retained"
+							: "worktree · integration failed; recovery artifacts retained"
+						: "worktree · isolated";
+		lines.push(`Isolation: ${isolation}${relationNote}`);
+		if (result.integrationWorktreePath) lines.push(`Retained worktree: ${result.integrationWorktreePath}`);
+		if (result.integrationPatchPath) lines.push(`Retained patch: ${result.integrationPatchPath}`);
+		if (result.integrationError) lines.push(`Integration error: ${result.integrationError}`);
+		lines.push("");
+	} else if (relations.length > 0) {
+		lines.push(`Relation: ${relations.join(" · ")}`, "");
+	}
+	lines.push(text);
+	// 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)"}`),
+		);
+	}
+	if (truncated) {
+		// The full text lives on disk so the main agent can read it on demand.
+		lines.push("", `(output truncated to ${maxResultLines} lines; full result: ${writeResultArtifact(output, result.agent, result.projectCwd ?? cwd)})`);
+	}
+	return lines.join("\n");
+}
+
+/** Instruction appended to a model-level failure: the sub-agent's provider never
+ * produced usable output (or the run stalled), so the task is handed back to the
+ * main window instead of being left as a dead failure. When the run preserved a
+ * session with earlier work (and the run id is known), steer the main agent to
+ * RESUME it in-context once a model is available, instead of re-dispatching
+ * fresh (which would re-scan everything). */
+export function modelLevelTakeoverNote(result: SingleResult, opts?: { runId?: number }): string {
+	const retry = result.modelFallbackFrom ? ", and the current main model also failed" : "";
+	const detail = result.errorMessage?.trim();
+	const cause = detail
+		? `its model/provider call failed (${detail})`
+		: "its model was unavailable or failed (or the run stalled)";
+	const sessionPreserved = Boolean(result.sessionDir && result.sessionId) && opts?.runId !== undefined;
+	const recovery = sessionPreserved
+		? ` The sub-agent's earlier work in this run is preserved. Once a model is available again, call subagent_control with { action: "resume", id: ${opts!.runId} } to CONTINUE it in-context (it keeps the same run id and does not re-scan), or execute the task in the main window with your own tools.`
+		: ` Please execute this task in the main window with your own tools; do not re-dispatch it as a sub-agent.`;
+	return `The sub-agent could not complete this task: ${cause}${retry}.${recovery}`;
+}
+
+/** Resolve a run-id request to actual ids: an exact numeric match always wins
+ * (so "1" never fans out to 10, 11, …); only when no exact match exists does a
+ * prefix match run, as a convenience for partial ids. Keeps single-digit lookups
+ * from returning — or, for subagent_stop, acting on — a whole prefix family. */
+export function matchRunIds(ids: number[], requested: string): number[] {
+	const exact = ids.filter((id) => String(id) === requested);
+	if (exact.length > 0) return exact;
+	return ids.filter((id) => String(id).startsWith(requested));
+}

package/src/index.ts

@@ -3,8 +3,9 @@
  *
  * Assembly point: builds the shared runtime and registers everything.
  * The heavy lifting lives in focused modules:
- *   - dispatch.ts  — the `subagent` tool (spawn, auto-fix chain, vision model)
- *   - tools.ts     — subagent_control / subagent_wait / status / stop
+ *   - dispatch.ts         — the `subagent` tool contract and auto-fix chain
+ *   - thread-lifecycle.ts — queued generations, resume/fork, isolation settlement
+ *   - tools.ts            — subagent_control / subagent_wait / status / stop
  *   - announcements.ts — session-start recovery, notices, and widget install
  *   - widget.ts        — active-only TUI run status
  *   - runtime.ts       — shared per-session state

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.`;
 }