pi-plans 0.7.0 → 0.8.0

package/src/plan.ts

@@ -503,7 +503,7 @@ export function lintPlanTasks(planText: string): string | null {
 		}
 	}
 	// Covers references must point at known tasks; a check with zero covers
-	// never enters the completion audit — surface that exemption loudly.
+	// never enters the execution review — surface that exemption loudly.
 	for (const item of parseChecklist(planText)) {
 		const covered = extractTaskCoverage(item.text);
 		if (covered.length === 0) {

package/src/refine-ui-state.ts

@@ -1,6 +1,6 @@
 import type { SubagentProgressEvent, SubagentResult } from "./subagent.ts";
 
-export type RefineOverlayRole = "reviewer" | "refs";
+export type RefineOverlayRole = "reviewer" | "refs" | "auditor";
 export type RefineLaneStatus = "queued" | "running" | "complete" | "failed" | "cancelled";
 export type RefineTranscriptEntryType = "assistant-text" | "thinking" | "tool-call" | "tool-result" | "diagnostic";
 

package/src/refine-ui.ts

@@ -135,10 +135,12 @@ function previewTranscriptText(entry: RefineTranscriptEntry, width: number): { l
 	return { lines: lines.slice(-STREAMING_PREVIEW_LINES), truncated: true };
 }
 
-function footerText(laneCount: number, lang: UiLanguage): string {
+function footerText(laneCount: number, lang: UiLanguage, role: RefineOverlayRole = "reviewer"): string {
 	const chrome = refineChrome(lang);
 	const parts = [chrome.close, chrome.scroll, chrome.page];
 	if (laneCount > 1) parts.push(chrome.switchLane);
+	// Auditor overlay only: the reopen shortcut is the way back after ESC.
+	if (role === "auditor") parts.push(chrome.reopen);
 	return parts.join(" · ");
 }
 
@@ -166,7 +168,7 @@ function summaryFor(role: RefineOverlayRole, lanes: RefineLaneState[], modelLabe
 	const complete = lanes.filter((lane) => lane.status === "complete").length;
 	const terminal = lanes.filter((lane) => ["complete", "failed", "cancelled"].includes(lane.status)).length;
 	const running = lanes.filter((lane) => lane.status === "running").length;
-	const title = role === "reviewer" ? "Reviewer" : "Refs";
+	const title = role === "reviewer" ? "Reviewer" : role === "auditor" ? "Execution review" : "Refs";
 	const visibleTitle = modelLabel ? `${title} (${modelLabel})` : title;
 	const state = terminal === lanes.length ? "done" : running > 0 ? `${running} running` : "queued";
 	return `${visibleTitle} · ${complete}/${lanes.length} done · ${state}`;
@@ -250,7 +252,7 @@ export class RefineOverlayComponent implements Component {
 				lines.push(...this.renderPane(this.lanes[index]!, innerWidth, paneHeight, index === this.selectedLane));
 			}
 		}
-		lines.push(renderRow(this.theme, this.theme.fg("dim", footerText(this.lanes.length, this.lang)), innerWidth));
+		lines.push(renderRow(this.theme, this.theme.fg("dim", footerText(this.lanes.length, this.lang, this.role)), innerWidth));
 		lines.push(renderBorderLine(this.theme, innerWidth, "bottom"));
 		return lines.map((line) => fitLine(line, width));
 	}
@@ -352,6 +354,20 @@ export class RefineOverlayController {
 			.catch(() => undefined);
 	}
 
+	/** Repaint without a progress event (the engine mutates lane state directly). */
+	rerender(): void {
+		if (this.closed) return;
+		this.tui?.requestRender();
+	}
+
+	/** Replace the lane with a matching id with engine-held state — used by the
+	 * execution-review reopen path so a fresh controller continues the SAME
+	 * transcript (one-shot controllers can never re-open themselves). */
+	seedLane(state: RefineLaneState): void {
+		const index = this.lanes.findIndex((lane) => lane.id === state.id);
+		if (index >= 0) this.lanes[index] = state;
+	}
+
 	update(laneId: string, event: SubagentProgressEvent): void {
 		if (this.closed) return;
 		const lane = this.lanes.find((candidate) => candidate.id === laneId);

package/src/resume-command.ts

@@ -300,11 +300,21 @@ async function buildBrief(
 			const reverify = load.reverifyAll
 				? `\nThe code state (HEAD) changed since approval: the authorization is KEPT, but every previously closed task was re-opened and must be re-done. Historically verified checks (evidence only): ${doneList}.`
 				: `\nPreviously verified and still valid: ${doneList}.`;
-			const paused = load.pausedReason ? `\nExecution had been paused: ${load.pausedReason} — the pause is cleared by this resume; continue from where it stopped.` : "";
+			// v0.8: a review-cap pause is NOT cleared by this resume — only
+			// /plans-execute (an explicit user confirmation) grants a fresh
+			// five-round budget; ordinary resumes and input keep it paused.
+			const paused = load.pausedReason
+				? load.pausedReason.startsWith("execution review exhausted") || load.pausedReason.startsWith("completion audit exhausted")
+					? `\nExecution had been paused: ${load.pausedReason} — this pause survives the resume; run /plans-execute to grant a fresh five-round review budget.`
+					: `\nExecution had been paused: ${load.pausedReason} — the pause is cleared by this resume; continue from where it stopped.`
+				: "";
 			const legacy = load.legacyPlan ? "\nThis plan parses through the legacy I-### compatibility mapping; upgrade it to the ## Tasks format at the next revision." : "";
+			// v0.8: a verifying run keeps checkpoint phase "executing" but the run
+			// STATUS is verifying — surface which loop owns the run right now.
+			const verifying = run.status === "verifying";
 			return {
-				phaseLabel: "executing",
-				text: `[PI-PLANS RESUME] Execution of run ${runId} continues in this session.\nPlan: ${load.planPath}${reverify}${paused}${legacy}\nFollow the execution-loop contract: work through tasks in wave order, report every task with the plans_update_task tool (status + evidence / skipReason), and let the completion auditor verify the checks. The current wave and remaining tasks are injected each turn.`,
+				phaseLabel: verifying ? "verifying" : "executing",
+				text: `[PI-PLANS RESUME] ${verifying ? "Execution review of" : "Execution of"} run ${runId} continues in this session.\nPlan: ${load.planPath}${reverify}${paused}${legacy}\n${verifying ? "The task tree is terminal and the execution-review loop owns the run: when all tasks are terminal and checks are still owed, a read-only reviewer round runs automatically (status verifying → done when every check passes). If a check fails, its tasks roll back to pending — fix and re-close them with plans_update_task." : "Follow the execution-loop contract: work through tasks in wave order, report every task with the plans_update_task tool (status + evidence / skipReason), and let the execution reviewer verify the checks. The current wave and remaining tasks are injected each turn."}`,
 			};
 		}
 		if (load.legacyDelegate) {

package/src/resume.ts

@@ -27,7 +27,7 @@ export interface ResumeCandidate {
 	updatedAt: string;
 }
 
-const RESUMABLE_RUN_STATUSES = new Set(["planning", "accepted", "executing", "stopped"]);
+const RESUMABLE_RUN_STATUSES = new Set(["planning", "accepted", "executing", "verifying", "stopped"]);
 
 /** Terminal runs are resumable only when unfinished implementation-review evidence exists (D-008). */
 function legacyDoneResumable(run: RunInfo, checkpoint: WorkflowCheckpoint | null): boolean {
@@ -52,6 +52,10 @@ function legacyDoneResumable(run: RunInfo, checkpoint: WorkflowCheckpoint | null
 }
 
 function phaseLabelOf(run: RunInfo, checkpoint: WorkflowCheckpoint | null): string {
+	// A verifying run keeps checkpoint.phase === "executing" (the execution
+	// state machine's phase is unchanged); surface the run status instead so
+	// the resume list never hides the verification loop behind "executing".
+	if (run.status === "verifying") return "verifying";
 	if (checkpoint !== null) return checkpoint.phase;
 	if (run.status === "stopped") return "executing (stopped)";
 	return run.status;

package/src/staleness.ts

@@ -0,0 +1,53 @@
+/**
+ * Stale-extension probe (v0.7.1, extracted).
+ *
+ * pi imports an extension's module graph once per process, so a fix written
+ * to disk while the session is running stays invisible until /reload. Both
+ * /plans (which reports it) and the execution reviewer (which suggests it when
+ * a verdict cannot be read) need the same answer, so the probe lives here
+ * rather than in index.ts -- exec.ts already depends on index.ts's imports and
+ * a back-import would close a cycle.
+ *
+ * index.ts records when its own copy was loaded; this module never holds that
+ * state, so callers pass it in and stay testable.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/** mtime (ms) of the newest .ts file under the extension root, or 0. */
+export function newestSourceMtime(baseDir: string): number {
+	const stack = [baseDir, path.join(baseDir, "src"), path.join(baseDir, "tools")];
+	let newest = 0;
+	while (stack.length) {
+		const dir = stack.pop()!;
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) stack.push(full);
+			else if (entry.isFile() && entry.name.endsWith(".ts")) {
+				const mtime = fs.statSync(full).mtimeMs;
+				if (mtime > newest) newest = mtime;
+			}
+		}
+	}
+	return newest;
+}
+
+/** One line describing whether the loaded copy is current. A clock-skew
+ * tolerance keeps a same-second write from reading as staleness. */
+export function stalenessLine(baseDir: string, loadedAt: Date): string {
+	try {
+		if (newestSourceMtime(baseDir) > loadedAt.getTime() + 2000) {
+			return `⚠ extension code on disk is newer than the loaded copy (loaded ${loadedAt.toISOString()}); run /reload to pick it up`;
+		}
+		return `Extension loaded: ${loadedAt.toISOString()} (up to date)`;
+	} catch {
+		return `Extension loaded: ${loadedAt.toISOString()}`;
+	}
+}
+
+/** Short form for inline hints: the /reload advice, or null when current. */
+export function staleReloadHint(baseDir: string, loadedAt: Date): string | null {
+	const line = stalenessLine(baseDir, loadedAt);
+	return line.startsWith("⚠") ? line : null;
+}

package/src/state.ts

@@ -119,6 +119,7 @@ export const VALID_RUN_STATUSES = new Set([
 	"planning",
 	"accepted",
 	"executing",
+	"verifying",
 	"stopped",
 	"abandoned",
 	"done",

package/src/task-tool.ts

@@ -64,7 +64,7 @@ export function registerTaskStatusTool(ext: ExtensionAPI): void {
 		name: "plans_update_task",
 		label: "Update task",
 		description:
-			'Report execution progress for one task of the accepted plan: set status "complete" (with evidence) or "skipped" (with skipReason). Fails outside pi-plans execution mode. Statuses are immutable once set — the independent completion auditor handles any rollback.',
+			'Report execution progress for one task of the accepted plan: set status "complete" (with evidence) or "skipped" (with skipReason). Fails outside pi-plans execution mode. Statuses are immutable once set — the independent execution reviewer handles any rollback.',
 		promptSnippet: "Report plan task completion",
 		parameters: UpdateTaskParams,
 

package/src/tasks.ts

@@ -2,7 +2,7 @@
  * Task-tree runtime model (v0.6.1): the execution phase tracks plan tasks
  * (`## Tasks`) as the unit of progress. Status flows in exclusively through
  * the task status tool; completion of the whole run is gated by the
- * independent completion auditor over the plan's verification checks.
+ * independent execution reviewer over the plan's verification checks.
  */
 
 import type { CheckItem, PlanTasks, TaskNode, WaveEntry } from "./plan.ts";
@@ -77,11 +77,13 @@ export function allTasksTerminal(tasks: TaskView[]): boolean {
 	return flattenTaskViews(tasks).length > 0 && flattenTaskViews(tasks).every((task) => taskIsTerminal(task));
 }
 
-/** Snapshot of statuses for persistence and stall detection. */
+/** Snapshot of statuses for persistence and stall detection. Every task gets
+ * a record: a rolled-back task must stay visible with the evidence from its
+ * previous attempt, otherwise a rollback erases the run's history and the
+ * agent can no longer tell "done and rolled back" from "never started". */
 export function taskProgressMap(tasks: TaskView[]): TaskProgressMap {
 	const map: TaskProgressMap = {};
 	for (const task of flattenTaskViews(tasks)) {
-		if (task.status === "pending" && task.evidence === undefined && task.skipReason === undefined) continue;
 		map[task.id] = {
 			status: task.status,
 			evidence: task.evidence,
@@ -132,7 +134,13 @@ export function canTransition(task: TaskView, next: TaskStatus): boolean {
 
 /** Rollback set for a failed verification check: every task in its covers
  * clause (parents cascade to their children, skipped tasks reopen too).
- * Returns the ids that actually reopen. */
+ * Returns the ids that actually reopen.
+ *
+ * The task's `evidence` is deliberately kept. It records what the previous
+ * attempt actually did, which is the one thing the agent cannot reconstruct
+ * once it reopens the task; re-reporting overwrites it. `skipReason` is
+ * cleared because it described a deliberate skip that the audit has now
+ * overturned. */
 export function auditRollbackSet(
 	tasks: TaskView[],
 	checklist: CheckItem[],
@@ -146,7 +154,6 @@ export function auditRollbackSet(
 	const reopenNode = (node: TaskView): void => {
 		if (node.status !== "pending") {
 			node.status = "pending";
-			node.evidence = undefined;
 			node.skipReason = undefined;
 			reopen.push(node.id);
 		}
@@ -158,6 +165,33 @@ export function auditRollbackSet(
 	return reopen;
 }
 
+/** Checks that lose their satisfied state because a rollback reopened work
+ * they were verifying. Returns the ids whose `done` flag was cleared.
+ *
+ * A check can be presolved without an audit round (skipped-pass), or affirmed
+ * in an earlier round, and stay `done` while another check's rollback reopens
+ * one of its covered tasks. Left alone it renders as "check passed" next to a
+ * task that is open again with stale evidence. The caller owns this: it runs
+ * after the rollback set is known. */
+export function invalidateChecksForRolledBackTasks(
+	checklist: CheckItem[],
+	tasks: TaskView[],
+	reopenedIds: string[],
+): string[] {
+	if (reopenedIds.length === 0) return [];
+	const reopened = new Set(reopenedIds);
+	const cleared: string[] = [];
+	for (const item of checklist) {
+		if (!item.done) continue;
+		const covered = extractTaskCoverage(item.text);
+		if (covered.some((id) => reopened.has(id))) {
+			item.done = false;
+			cleared.push(item.id);
+		}
+	}
+	return cleared;
+}
+
 /** Verification checks that cover no task are excluded from audit (their
  * pass state cannot be derived from task statuses). */
 export function auditableChecks(checklist: CheckItem[], tasks: TaskView[]): CheckItem[] {

package/src/ui-language.ts

@@ -103,6 +103,8 @@ export interface RefineChrome {
 	scroll: string;
 	page: string;
 	switchLane: string;
+	/** Auditor overlay only (v0.8): the shortcut that reopens the in-flight round. */
+	reopen: string;
 }
 
 const REFINE_CHROME: Record<UiLanguage, RefineChrome> = {
@@ -111,12 +113,14 @@ const REFINE_CHROME: Record<UiLanguage, RefineChrome> = {
 		scroll: "↑/↓ 滚动",
 		page: "PgUp/PgDn 翻页",
 		switchLane: "Tab & Shift + Tab 切换 lane",
+		reopen: "Ctrl+Shift+R 重开评审面板",
 	},
 	en: {
 		close: "Esc close",
 		scroll: "↑/↓ scroll",
 		page: "PgUp/PgDn page",
 		switchLane: "Tab & Shift + Tab switch lane",
+		reopen: "Ctrl+Shift+R reopen review overlay",
 	},
 };
 

package/src/workflow-state.ts

@@ -152,8 +152,12 @@ export interface ExecutionCheckpoint {
 	 * progress record. doneVcIds stays for legacy checkpoints and the final
 	 * audit pass. */
 	tasks?: Record<string, { status: string; evidence?: string; skipReason?: string }>;
+	/** v0.7.1: watchdog round counter. Persisted so a session restart cannot
+	 * silently hand a stalled run a fresh budget; optional so checkpoints
+	 * written before this field keep loading. */
+	stallRounds?: number;
 	/** v0.6.1: completion-audit bookkeeping (rounds, last failed set, pass). */
-	audit?: { rounds: number; lastResult?: string; passed?: boolean };
+	audit?: { rounds: number; lastResult?: string; passed?: boolean; undeterminable?: string[] };
 }
 
 export interface OwnerInfo {
@@ -461,7 +465,7 @@ function asExecution(value: unknown, label: string): ExecutionCheckpoint {
 	const record = asRecord(value, label);
 	rejectExtraKeys(
 		record,
-		new Set(["approval", "doneVcIds", "implStatus", "currentI", "usage", "pausedReason", "reverifyAll", "originWorktree", "delegate", "tasks", "audit"]),
+		new Set(["approval", "doneVcIds", "implStatus", "currentI", "usage", "pausedReason", "reverifyAll", "originWorktree", "delegate", "tasks", "stallRounds", "audit"]),
 		label,
 	);
 	const execution: ExecutionCheckpoint = {
@@ -505,14 +509,20 @@ function asExecution(value: unknown, label: string): ExecutionCheckpoint {
 		}
 		execution.tasks = tasks;
 	}
+	if (record.stallRounds !== undefined && record.stallRounds !== null) {
+		execution.stallRounds = asInt(record.stallRounds, `${label}.stallRounds`, 0);
+	}
 	if (record.audit !== undefined && record.audit !== null) {
 		const audit = asRecord(record.audit, `${label}.audit`);
-		rejectExtraKeys(audit, new Set(["rounds", "lastResult", "passed"]), `${label}.audit`);
-		const parsed: { rounds: number; lastResult?: string; passed?: boolean } = {
+		rejectExtraKeys(audit, new Set(["rounds", "lastResult", "passed", "undeterminable"]), `${label}.audit`);
+		const parsed: { rounds: number; lastResult?: string; passed?: boolean; undeterminable?: string[] } = {
 			rounds: asInt(audit.rounds, `${label}.audit.rounds`, 0),
 		};
 		if (audit.lastResult !== undefined) parsed.lastResult = asString(audit.lastResult, `${label}.audit.lastResult`);
 		if (audit.passed !== undefined) parsed.passed = asBool(audit.passed, `${label}.audit.passed`);
+		if (audit.undeterminable !== undefined) {
+			parsed.undeterminable = asStringArray(audit.undeterminable, `${label}.audit.undeterminable`);
+		}
 		execution.audit = parsed;
 	}
 	return execution;
@@ -1071,7 +1081,9 @@ export interface ExecutionProgressInput {
 	/** v0.6.1: task-tree progress snapshot (authoritative). */
 	tasks?: Record<string, { status: string; evidence?: string; skipReason?: string }>;
 	/** v0.6.1: completion-audit bookkeeping update. */
-	audit?: { rounds: number; lastResult?: string; passed?: boolean };
+	audit?: { rounds: number; lastResult?: string; passed?: boolean; undeterminable?: string[] };
+	/** v0.7.1: watchdog budget counter, so a restart cannot refresh it. */
+	stallRounds?: number;
 }
 
 export function applyExecutionProgress(cp: WorkflowCheckpoint, progress: ExecutionProgressInput): WorkflowCheckpoint {
@@ -1091,6 +1103,7 @@ export function applyExecutionProgress(cp: WorkflowCheckpoint, progress: Executi
 	if (progress.delegate === null) delete execution.delegate;
 	else if (progress.delegate !== undefined) execution.delegate = progress.delegate;
 	if (progress.tasks !== undefined) execution.tasks = progress.tasks;
+	if (progress.stallRounds !== undefined) execution.stallRounds = progress.stallRounds;
 	if (progress.audit !== undefined) execution.audit = progress.audit;
 	return { ...cp, execution };
 }

package/tests/auditor.test.ts

@@ -1,11 +1,17 @@
-/** Tests for the completion auditor (v0.6.1): verdict parsing, rollback
- * boundaries, skipped-pass, and no-cover exclusion. */
+/** Tests for the execution reviewer: tri-state verdict parsing, contract
+ * coverage, rollback boundaries, skipped-pass, and no-cover exclusion. */
 
 import * as assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import type { CheckItem } from "../src/plan.ts";
-import { buildTaskView } from "../src/tasks.ts";
-import { applyAuditOutcome, buildAuditTask, parseAuditReport, presolvedCheckIds } from "../src/auditor.ts";
+import { auditRollbackSet, buildTaskView } from "../src/tasks.ts";
+import {
+	applyAuditOutcome,
+	auditablePendingChecks,
+	buildAuditTask,
+	parseAuditReport,
+	presolvedCheckIds,
+} from "../src/auditor.ts";
 import { parsePlanTasks } from "../src/plan.ts";
 
 const PLAN = `## Tasks
@@ -37,6 +43,8 @@ function view(progress?: Record<string, { status: "complete" | "skipped" }>) {
 	return buildTaskView(parsePlanTasks(PLAN), progress);
 }
 
+const ALL_IDS = ["VC-001", "VC-002", "VC-003", "VC-004"];
+
 describe("auditor parsing", () => {
 	it("parses per-check verdicts and ignores unknown ids", () => {
 		const report = [
@@ -44,48 +52,139 @@ describe("auditor parsing", () => {
 			"- `VC-002` — verdict: fail; evidence: src/c.ts; note: missing",
 			"- `VC-999` — verdict: pass; evidence: n/a",
 		].join("\n");
-		const { passed, failed } = parseAuditReport(report, checks());
+		const { passed, failed, undeterminable } = parseAuditReport(report, ALL_IDS);
 		assert.deepEqual(passed, ["VC-001"]);
 		assert.deepEqual(failed, ["VC-002"]);
+		assert.deepEqual(undeterminable.sort(), ["VC-003", "VC-004"]);
+	});
+
+	it("parses verdicts wrapped in markdown emphasis", () => {
+		// Regression: `verdict: **pass**` used to parse as nothing, and the
+		// caller's fail-closed rule then rolled the entire run back.
+		const report = [
+			"- `VC-001` — verdict: **pass**; evidence: src/a.ts",
+			"- `VC-002` — verdict: **fail**; evidence: src/c.ts",
+			"- `VC-003` — verdict: *pass*; evidence: src/d.ts",
+			"- `VC-004` — verdict: `pass`; evidence: src/e.ts",
+		].join("\n");
+		const { passed, failed, undeterminable } = parseAuditReport(report, ALL_IDS);
+		assert.deepEqual(passed, ["VC-001", "VC-003", "VC-004"]);
+		assert.deepEqual(failed, ["VC-002"]);
+		assert.deepEqual(undeterminable, []);
+	});
+
+	it("does not read a verdict word prefix as a verdict", () => {
+		const report = ["- `VC-001` — verdict: passed; evidence: x", "- `VC-002` — verdict: failing; evidence: y"].join("\n");
+		const { passed, failed, undeterminable } = parseAuditReport(report, ALL_IDS);
+		assert.deepEqual(passed, []);
+		assert.deepEqual(failed, []);
+		assert.deepEqual(undeterminable.sort(), ["VC-001", "VC-002", "VC-003", "VC-004"]);
 	});
 
 	it("conflicting verdicts for one check resolve to fail", () => {
 		const report = "- `VC-001` — verdict: pass; note: a\n- `VC-001` — verdict: fail; note: b";
-		const { passed, failed } = parseAuditReport(report, checks());
+		const { passed, failed } = parseAuditReport(report, ALL_IDS);
 		assert.deepEqual(passed, []);
 		assert.deepEqual(failed, ["VC-001"]);
 	});
 
-	it("builds the brief with the auditable checks only", () => {
+	it("reads an explicit undeterminable verdict", () => {
+		const report = "- `VC-001` — verdict: pass\n- `VC-002` — verdict: undeterminable; evidence: bash not granted";
+		const { passed, failed, undeterminable } = parseAuditReport(report, ALL_IDS);
+		assert.deepEqual(passed, ["VC-001"]);
+		assert.deepEqual(failed, []);
+		assert.deepEqual(undeterminable.sort(), ["VC-002", "VC-003", "VC-004"]);
+	});
+
+	it("treats a reviewer-shaped report as undeterminable, never as failure", () => {
+		// Regression: agents/reviewer.md was the auditor's system prompt and
+		// mandates `## Findings` / `## Questions` with F-### lines and never
+		// says "verdict". Under fail-closed that whole shape read as "every
+		// check failed" and rolled the run back.
+		const report = [
+			"## Findings",
+			"",
+			"- `F-001` — severity: high; affected: VC-001; evidence: src/a.ts; impact: x; recommended fix: y; suggested disposition: accept.",
+			"",
+			"## Questions",
+			"",
+			"None.",
+		].join("\n");
+		const { passed, failed, undeterminable } = parseAuditReport(report, ALL_IDS);
+		assert.deepEqual(passed, []);
+		assert.deepEqual(failed, [], "a reviewer-shaped report is not a failed audit");
+		assert.deepEqual(undeterminable.sort(), ["VC-001", "VC-002", "VC-003", "VC-004"]);
+	});
+
+	it("classifies a partially covered report per check", () => {
+		const report = "- `VC-001` — verdict: pass\n- `VC-003` — verdict: **pass**";
+		const { passed, failed, undeterminable } = parseAuditReport(report, ALL_IDS);
+		assert.deepEqual(passed, ["VC-001", "VC-003"]);
+		assert.deepEqual(failed, []);
+		assert.deepEqual(undeterminable.sort(), ["VC-002", "VC-004"]);
+	});
+
+	it("builds the brief with the auditable pending checks only", () => {
 		const task = buildAuditTask("/tmp/PLAN_v1.md", checks(), view(), 1);
 		assert.match(task, /read-only/i);
 		assert.match(task, /`VC-001`/);
 		assert.doesNotMatch(task, /`VC-999`/);
+		assert.doesNotMatch(task, /`VC-004`/, "a check covering no task is never audited");
+	});
+
+	it("brief states the tri-state contract and forbids fail-for-want-of-evidence", () => {
+		const task = buildAuditTask("/tmp/PLAN_v1.md", checks(), view(), 1);
+		assert.match(task, /verdict: pass \| fail \| undeterminable/);
+		assert.match(task, /never report `fail` for want of evidence/i);
+	});
+
+	it("brief omits checks already done in an earlier round", () => {
+		// Regression: the brief listed every auditable check, so a round-2
+		// auditor that legitimately skipped the satisfied ones looked like a
+		// contract violation -- and, with no rollback to produce progress, the
+		// budget climbed to the cap and the run livelocked.
+		const done = buildAuditTask("/tmp/PLAN_v1.md", checks(["VC-001"]), view(), 2);
+		assert.doesNotMatch(done, /`VC-001`/);
+		assert.match(done, /`VC-002`/);
+		assert.deepEqual(
+			auditablePendingChecks(checks(["VC-001"]), view()).map((item) => item.id),
+			["VC-002", "VC-003"],
+		);
+	});
+
+	it("applyAuditOutcome classifies without touching the checklist or task tree", () => {
+		const checklist = checks();
+		const tasks = view({ "Task-1": { status: "complete" }, "Task-2": { status: "complete" }, "Task-3": { status: "complete" }, "Task-3.1": { status: "complete" } });
+		const parsed = parseAuditReport("- `VC-001` — verdict: pass\n- `VC-002` — verdict: fail", ["VC-001", "VC-002"]);
+		const outcome = applyAuditOutcome(3, parsed, "report text");
+		assert.deepEqual(outcome.passed, ["VC-001"]);
+		assert.deepEqual(outcome.failed, ["VC-002"]);
+		assert.deepEqual(outcome.undeterminable, []);
+		assert.equal(outcome.round, 3);
+		assert.equal(outcome.report, "report text");
+		assert.equal(checklist.every((item) => item.done === false), true, "no done flag written here");
+		assert.equal(tasks.find((t) => t.id === "Task-2")?.status, "complete", "no rollback here");
 	});
 });
 
 describe("audit rollback boundaries", () => {
 	it("failed multi-cover check rolls back every covered task", () => {
 		const tasks = view({ "Task-1": { status: "complete" }, "Task-2": { status: "complete" }, "Task-3": { status: "complete" }, "Task-3.1": { status: "complete" } });
-		const checklist = checks();
-		const outcome = applyAuditOutcome(checklist, tasks, 1, ["VC-001"], ["VC-002"], "report");
-		assert.deepEqual(outcome.rolledBack.sort(), ["Task-2", "Task-3", "Task-3.1"]);
-		// Passed check stays done; its task stays closed.
-		assert.equal(checks().length, 4);
+		const rolledBack = auditRollbackSet(tasks, checks(), "VC-002");
+		assert.deepEqual(rolledBack.sort(), ["Task-2", "Task-3", "Task-3.1"]);
+		// A check that passed keeps its task closed.
 		assert.equal(tasks.find((t) => t.id === "Task-1")?.status, "complete");
 		assert.equal(tasks.find((t) => t.id === "Task-2")?.status, "pending");
 	});
 
 	it("covering the parent cascades to subtasks even when the parent alone is listed", () => {
 		const tasks = view({ "Task-3": { status: "complete" }, "Task-3.1": { status: "complete" } });
-		const outcome = applyAuditOutcome(checks(), tasks, 1, [], ["VC-002"], "report");
-		assert.ok(outcome.rolledBack.includes("Task-3.1"), "subtask reopens with the parent");
+		assert.ok(auditRollbackSet(tasks, checks(), "VC-002").includes("Task-3.1"), "subtask reopens with the parent");
 	});
 
 	it("skipped tasks reopen too (skip state cleared)", () => {
 		const tasks = view({ "Task-2": { status: "skipped" } });
-		const outcome = applyAuditOutcome(checks(), tasks, 1, [], ["VC-002"], "report");
-		assert.ok(outcome.rolledBack.includes("Task-2"));
+		assert.ok(auditRollbackSet(tasks, checks(), "VC-002").includes("Task-2"));
 		assert.equal(tasks.find((t) => t.id === "Task-2")?.skipReason, undefined);
 	});
 
@@ -108,4 +207,4 @@ describe("audit rollback boundaries", () => {
 		assert.ok(presolved.includes("VC-003"));
 		assert.ok(!presolved.includes("VC-002"), "mixed coverage needs the auditor");
 	});
-});
+});