pi-plans 0.8.0 → 0.8.2

package/src/workflow-state.ts

@@ -29,6 +29,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "
 import * as path from "node:path";
 import { StateError, atomicWriteJson, resolveStateRootOrNull, runGit, runDirPath, utcNow } from "./state.ts";
 import { assertOwnership, heldOwnershipRecord } from "./run-ownership.ts";
+import type { NoProgressState, ReviewBudget } from "./review-budget.ts";
 
 // ---------------------------------------------------------------------------
 // Schema
@@ -133,6 +134,21 @@ export interface ExecutionApproval {
 	approvedAt: string;
 }
 
+/** v0.9.2: the newest failed execution-review round's rollback set plus the
+ * tasks among it that are still open. Captured when the round commits (the
+ * reopen helpers mutate the tree and report only flipped nodes, so a later
+ * re-derivation cannot rebuild this set) and persisted so wakes, the pause
+ * reason, the dashboard, and resume briefs can name the blocker after a
+ * restart. `escalatedRounds` counts consecutive blocked wakes — the escalation
+ * ladder must not ride `stallRounds`, which any successful tool call resets. */
+export interface ExecutionBlocked {
+	rolledBack: string[];
+	tasks: string[];
+	round: number;
+	escalatedRounds: number;
+	since: string;
+}
+
 export interface ExecutionCheckpoint {
 	approval: ExecutionApproval | null;
 	doneVcIds: string[];
@@ -156,8 +172,59 @@ export interface ExecutionCheckpoint {
 	 * silently hand a stalled run a fresh budget; optional so checkpoints
 	 * written before this field keep loading. */
 	stallRounds?: number;
+	/** v0.9.2: outstanding blocker from the newest failed review round (see
+	 * `ExecutionBlocked`); absent = nothing blocks the review. Optional on
+	 * read so checkpoints written before it keep loading. */
+	blocked?: ExecutionBlocked | null;
+	/** v0.9.3: the per-run execution-review budget (committed rounds, or
+	 * `"unlimited"`). Absent = not decided yet (the picker runs before round
+	 * 1) OR written by a pre-v0.9.3 build, in which case a checkpoint that
+	 * already spent rounds keeps the legacy 5-round bound
+	 * (`resolveStoredBudget` in ./review-budget.ts). */
+	reviewBudget?: ReviewBudget;
+	/** v0.9.3: the budget above was the no-UI fallback, not a user pick — the
+	 * dashboard/resume brief annotate it `(default)`. Optional on read. */
+	reviewBudgetDefaulted?: boolean;
+	/** v0.9.3: committed review rounds across the WHOLE run (never reset by a
+	 * grant) — bounds the unlimited budget together with `reviewCapExtension`. */
+	reviewRoundsTotal?: number;
+	/** v0.9.3: explicit `/plans-execute` grants lifted the unlimited hard cap
+	 * by this many rounds (each grant that lands on `unlimited` adds
+	 * `UNLIMITED_HARD_CAP`). */
+	reviewCapExtension?: number;
+	/** v0.9.3: no-progress valve state for the unlimited budget (signature of
+	 * the last committed round's outcome plus its consecutive streak). */
+	reviewNoProgress?: NoProgressState | null;
+	/** v0.9.1 (F-002): set when the execution-review loop mechanically
+	 * appended finding tasks to the approved plan. The checkpoint's plan
+	 * identity is re-stamped at that moment so /resume-plans accepts the
+	 * amended plan; the approval record keeps the ORIGINAL digest as
+	 * evidence of what the user actually approved. */
+	planAmended?: { sha256: string; amendedAt: string; round: number };
 	/** v0.6.1: completion-audit bookkeeping (rounds, last failed set, pass). */
-	audit?: { rounds: number; lastResult?: string; passed?: boolean; undeterminable?: string[] };
+	audit?: {
+		rounds: number;
+		lastResult?: string;
+		passed?: boolean;
+		undeterminable?: string[];
+		/** v0.9: unresolved implementation findings from the newest committed
+		 * review round (stable F-### ids). Optional so pre-v0.9 checkpoints
+		 * keep loading as "no findings". */
+		findings?: ReviewFindingRecord[];
+	};
+}
+
+/** Serializable shape of one review finding (v0.9). Structurally identical to
+ * auditor.ts's ReviewFinding; declared here so the checkpoint layer does not
+ * import the auditor. */
+export interface ReviewFindingRecord {
+	id: string;
+	severity: string;
+	taskIds: string[];
+	proposedTask?: string;
+	note: string;
+	evidence: string;
+	raw: string;
 }
 
 export interface OwnerInfo {
@@ -269,6 +336,13 @@ function asInt(value: unknown, label: string, min: number): number {
 	return value;
 }
 
+/** v0.9.3: a positive integer round count or the literal "unlimited". */
+function asReviewBudget(value: unknown, label: string): ReviewBudget {
+	if (value === "unlimited") return "unlimited";
+	if (typeof value === "number" && Number.isSafeInteger(value) && value >= 1) return value;
+	throw new CheckpointValidationError(`${label}: expected a positive integer or "unlimited"`);
+}
+
 function asEnum<T extends string>(value: unknown, allowed: Set<T>, label: string): T {
 	const text = asString(value, label);
 	if (!allowed.has(text as T)) {
@@ -465,7 +539,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", "stallRounds", "audit"]),
+		new Set(["approval", "doneVcIds", "implStatus", "currentI", "usage", "pausedReason", "reverifyAll", "originWorktree", "delegate", "tasks", "stallRounds", "blocked", "planAmended", "audit", "reviewBudget", "reviewBudgetDefaulted", "reviewRoundsTotal", "reviewCapExtension", "reviewNoProgress"]),
 		label,
 	);
 	const execution: ExecutionCheckpoint = {
@@ -485,6 +559,17 @@ function asExecution(value: unknown, label: string): ExecutionCheckpoint {
 	};
 	if (record.currentI !== undefined) execution.currentI = asString(record.currentI, `${label}.currentI`);
 	if (record.pausedReason !== undefined) execution.pausedReason = asString(record.pausedReason, `${label}.pausedReason`);
+	if (record.blocked !== undefined && record.blocked !== null) {
+		const blocked = asRecord(record.blocked, `${label}.blocked`);
+		rejectExtraKeys(blocked, new Set(["rolledBack", "tasks", "round", "escalatedRounds", "since"]), `${label}.blocked`);
+		execution.blocked = {
+			rolledBack: asStringArray(blocked.rolledBack, `${label}.blocked.rolledBack`),
+			tasks: asStringArray(blocked.tasks, `${label}.blocked.tasks`),
+			round: asInt(blocked.round, `${label}.blocked.round`, 0),
+			escalatedRounds: asInt(blocked.escalatedRounds, `${label}.blocked.escalatedRounds`, 0),
+			since: asTimestamp(blocked.since, `${label}.blocked.since`),
+		};
+	}
 	if (record.reverifyAll !== undefined) execution.reverifyAll = asBool(record.reverifyAll, `${label}.reverifyAll`);
 	if (record.originWorktree !== undefined) execution.originWorktree = asString(record.originWorktree, `${label}.originWorktree`);
 	if (record.delegate !== undefined && record.delegate !== null) {
@@ -512,10 +597,43 @@ function asExecution(value: unknown, label: string): ExecutionCheckpoint {
 	if (record.stallRounds !== undefined && record.stallRounds !== null) {
 		execution.stallRounds = asInt(record.stallRounds, `${label}.stallRounds`, 0);
 	}
+	if (record.planAmended !== undefined && record.planAmended !== null) {
+		const rec = asRecord(record.planAmended, `${label}.planAmended`);
+		rejectExtraKeys(rec, new Set(["sha256", "amendedAt", "round"]), `${label}.planAmended`);
+		execution.planAmended = {
+			sha256: asString(rec.sha256, `${label}.planAmended.sha256`),
+			amendedAt: asString(rec.amendedAt, `${label}.planAmended.amendedAt`),
+			round: asInt(rec.round, `${label}.planAmended.round`, 0),
+		};
+	}
+	// v0.9.3 review budget. `reviewBudget` accepts a positive integer or the
+	// literal "unlimited"; the counters are non-negative integers; the
+	// no-progress record is a small fixed shape. All optional on read so
+	// pre-feature checkpoints keep loading.
+	if (record.reviewBudget !== undefined && record.reviewBudget !== null) {
+		execution.reviewBudget = asReviewBudget(record.reviewBudget, `${label}.reviewBudget`);
+	}
+	if (record.reviewBudgetDefaulted !== undefined) {
+		execution.reviewBudgetDefaulted = asBool(record.reviewBudgetDefaulted, `${label}.reviewBudgetDefaulted`);
+	}
+	if (record.reviewRoundsTotal !== undefined && record.reviewRoundsTotal !== null) {
+		execution.reviewRoundsTotal = asInt(record.reviewRoundsTotal, `${label}.reviewRoundsTotal`, 0);
+	}
+	if (record.reviewCapExtension !== undefined && record.reviewCapExtension !== null) {
+		execution.reviewCapExtension = asInt(record.reviewCapExtension, `${label}.reviewCapExtension`, 0);
+	}
+	if (record.reviewNoProgress !== undefined && record.reviewNoProgress !== null) {
+		const np = asRecord(record.reviewNoProgress, `${label}.reviewNoProgress`);
+		rejectExtraKeys(np, new Set(["key", "streak"]), `${label}.reviewNoProgress`);
+		execution.reviewNoProgress = {
+			key: asString(np.key, `${label}.reviewNoProgress.key`),
+			streak: asInt(np.streak, `${label}.reviewNoProgress.streak`, 0),
+		};
+	}
 	if (record.audit !== undefined && record.audit !== null) {
 		const audit = asRecord(record.audit, `${label}.audit`);
-		rejectExtraKeys(audit, new Set(["rounds", "lastResult", "passed", "undeterminable"]), `${label}.audit`);
-		const parsed: { rounds: number; lastResult?: string; passed?: boolean; undeterminable?: string[] } = {
+		rejectExtraKeys(audit, new Set(["rounds", "lastResult", "passed", "undeterminable", "findings"]), `${label}.audit`);
+		const parsed: { rounds: number; lastResult?: string; passed?: boolean; undeterminable?: string[]; findings?: ReviewFindingRecord[] } = {
 			rounds: asInt(audit.rounds, `${label}.audit.rounds`, 0),
 		};
 		if (audit.lastResult !== undefined) parsed.lastResult = asString(audit.lastResult, `${label}.audit.lastResult`);
@@ -523,6 +641,24 @@ function asExecution(value: unknown, label: string): ExecutionCheckpoint {
 		if (audit.undeterminable !== undefined) {
 			parsed.undeterminable = asStringArray(audit.undeterminable, `${label}.audit.undeterminable`);
 		}
+		if (audit.findings !== undefined && audit.findings !== null) {
+			const arr = Array.isArray(audit.findings) ? audit.findings : null;
+			if (!arr) throw new CheckpointValidationError(`${label}.audit.findings must be an array`);
+			parsed.findings = arr.map((entry, i) => {
+				const rec = asRecord(entry, `${label}.audit.findings.${i}`);
+				rejectExtraKeys(rec, new Set(["id", "severity", "taskIds", "proposedTask", "note", "evidence", "raw"]), `${label}.audit.findings.${i}`);
+				const out: ReviewFindingRecord = {
+					id: asString(rec.id, `${label}.audit.findings.${i}.id`),
+					severity: asString(rec.severity, `${label}.audit.findings.${i}.severity`),
+					taskIds: rec.taskIds === undefined ? [] : asStringArray(rec.taskIds, `${label}.audit.findings.${i}.taskIds`),
+					note: rec.note === undefined ? "" : asString(rec.note, `${label}.audit.findings.${i}.note`),
+					evidence: rec.evidence === undefined ? "" : asString(rec.evidence, `${label}.audit.findings.${i}.evidence`),
+					raw: rec.raw === undefined ? "" : asString(rec.raw, `${label}.audit.findings.${i}.raw`),
+				};
+				if (rec.proposedTask !== undefined) out.proposedTask = asString(rec.proposedTask, `${label}.audit.findings.${i}.proposedTask`);
+				return out;
+			});
+		}
 		execution.audit = parsed;
 	}
 	return execution;
@@ -1080,10 +1216,26 @@ export interface ExecutionProgressInput {
 	delegate?: { modelSelector: string; startedAt: string } | null;
 	/** 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; undeterminable?: string[] };
+	/** v0.6.1: completion-audit bookkeeping update. v0.9: findings rides the
+	 * same replace-semantics slot — callers that must preserve findings (e.g.
+	 * budget renewal) pass them through explicitly. */
+	audit?: { rounds: number; lastResult?: string; passed?: boolean; undeterminable?: string[]; findings?: ReviewFindingRecord[] };
 	/** v0.7.1: watchdog budget counter, so a restart cannot refresh it. */
 	stallRounds?: number;
+	/** v0.9.2: blocker record; null clears it (delete-on-null, like
+	 * `pausedReason`/`delegate`). */
+	blocked?: ExecutionBlocked | null;
+	/** v0.9.3: per-run execution-review budget; null clears it (delete-on-null,
+	 * used by the stop/complete cleanup paths). */
+	reviewBudget?: ReviewBudget | null;
+	/** v0.9.3: whether `reviewBudget` came from the no-UI fallback. */
+	reviewBudgetDefaulted?: boolean | null;
+	/** v0.9.3: committed rounds across the whole run (monotonic). */
+	reviewRoundsTotal?: number;
+	/** v0.9.3: explicit unlimited-cap extension accumulated by grants. */
+	reviewCapExtension?: number;
+	/** v0.9.3: no-progress valve state; null clears it (delete-on-null). */
+	reviewNoProgress?: NoProgressState | null;
 }
 
 export function applyExecutionProgress(cp: WorkflowCheckpoint, progress: ExecutionProgressInput): WorkflowCheckpoint {
@@ -1104,10 +1256,37 @@ export function applyExecutionProgress(cp: WorkflowCheckpoint, progress: Executi
 	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.blocked === null) delete execution.blocked;
+	else if (progress.blocked !== undefined) execution.blocked = progress.blocked;
+	if (progress.reviewBudget === null) delete execution.reviewBudget;
+	else if (progress.reviewBudget !== undefined) execution.reviewBudget = progress.reviewBudget;
+	if (progress.reviewBudgetDefaulted === null) delete execution.reviewBudgetDefaulted;
+	else if (progress.reviewBudgetDefaulted !== undefined) execution.reviewBudgetDefaulted = progress.reviewBudgetDefaulted;
+	if (progress.reviewRoundsTotal !== undefined) execution.reviewRoundsTotal = progress.reviewRoundsTotal;
+	if (progress.reviewCapExtension !== undefined) execution.reviewCapExtension = progress.reviewCapExtension;
+	if (progress.reviewNoProgress === null) delete execution.reviewNoProgress;
+	else if (progress.reviewNoProgress !== undefined) execution.reviewNoProgress = progress.reviewNoProgress;
 	if (progress.audit !== undefined) execution.audit = progress.audit;
 	return { ...cp, execution };
 }
 
+/** v0.9.1 (F-002): the execution-review loop appended finding tasks to the
+ * approved plan file; re-stamp the checkpoint's plan identity to the amended
+ * digest so a later /resume-plans does not reject the run as plan-mismatch.
+ * The approval record is untouched — it keeps the digest the user actually
+ * approved, and planAmended records when and why the identity moved. */
+export function applyExecutionPlanAmended(cp: WorkflowCheckpoint, plan: PlanIdentity, round: number): WorkflowCheckpoint {
+	if (cp.phase !== "executing" || !cp.execution) throw new StateError("requires phase \"executing\"");
+	return {
+		...cp,
+		plan,
+		execution: {
+			...cp.execution,
+			planAmended: { sha256: plan.sha256, amendedAt: utcNow(), round },
+		},
+	};
+}
+
 /** D-011/F-001: code state changed under an unchanged plan — keep authorization, re-verify first. */
 export function applyExecutionHeadChanged(cp: WorkflowCheckpoint): WorkflowCheckpoint {
 	if (cp.phase !== "executing" || !cp.execution) throw new StateError("requires phase \"executing\"");
@@ -1118,14 +1297,25 @@ export function applyExecutionCompleted(cp: WorkflowCheckpoint): WorkflowCheckpo
 	if (cp.phase !== "executing" || !cp.execution) throw new StateError("requires phase \"executing\"");
 	// v0.6.1 (D-018): the post-execution amelioration loop is gone; a
 	// completed audit passes the run straight to the terminal phase.
+	// v0.9.3: the review budget (and its valve state) describes a review that
+	// no longer runs — completed runs do not carry it.
+	const {
+		reviewBudget: _reviewBudget,
+		reviewBudgetDefaulted: _reviewBudgetDefaulted,
+		reviewRoundsTotal: _reviewRoundsTotal,
+		reviewCapExtension: _reviewCapExtension,
+		reviewNoProgress: _reviewNoProgress,
+		...execution
+	} = cp.execution;
 	return {
 		...cp,
 		phase: "completed",
 		nextAction: "none",
 		execution: {
-			...cp.execution,
+			...execution,
 			pausedReason: undefined,
 			delegate: undefined,
+			blocked: undefined,
 			audit: { ...(cp.execution.audit ?? { rounds: 0 }), passed: true },
 		},
 	};
@@ -1156,6 +1346,14 @@ export function applyMigration(
 				// migration (same rule as VC validity).
 				tasks: {},
 				audit: { rounds: 0 },
+				// v0.9.3 (F-005): the review budget and its counters ARE carried
+				// across a migration — they describe the user's choice and the
+				// run's cumulative spend, not the (invalidated) code state.
+				reviewBudget: cp.execution.reviewBudget,
+				reviewBudgetDefaulted: cp.execution.reviewBudgetDefaulted,
+				reviewRoundsTotal: cp.execution.reviewRoundsTotal,
+				reviewCapExtension: cp.execution.reviewCapExtension,
+				reviewNoProgress: cp.execution.reviewNoProgress ?? undefined,
 			}
 			: undefined,
 		implementationReview: cp.implementationReview
@@ -1179,7 +1377,18 @@ function migrationNextAction(cp: WorkflowCheckpoint): NextAction {
 /** Mark a paused stop without erasing the last phase (D-008). */
 export function applyExecutionStopped(cp: WorkflowCheckpoint, reason: string): WorkflowCheckpoint {
 	if (cp.phase !== "executing" || !cp.execution) throw new StateError("requires phase \"executing\"");
-	const { delegate: _delegate, ...execution } = cp.execution;
+	// v0.9.3: a stop also drops the review budget and its valve state — the
+	// next execution of this plan picks its own budget.
+	const {
+		delegate: _delegate,
+		blocked: _blocked,
+		reviewBudget: _reviewBudget,
+		reviewBudgetDefaulted: _reviewBudgetDefaulted,
+		reviewRoundsTotal: _reviewRoundsTotal,
+		reviewCapExtension: _reviewCapExtension,
+		reviewNoProgress: _reviewNoProgress,
+		...execution
+	} = cp.execution;
 	// A stop also revokes any outstanding audit-rollback authorization.
 	const audit = execution.audit ? { ...execution.audit } : undefined;
 	return { ...cp, execution: { ...execution, audit, pausedReason: reason } };

package/tests/analyze-refs.test.ts

@@ -303,7 +303,7 @@ describe("analyze_refs fanout", () => {
 
 	it("pins the per-batch overlay lifecycle (open before spawn, close in finally, cap 3)", () => {
 		const source = fs.readFileSync(path.join(ROOT, "tools", "analyze-refs.ts"), "utf8");
-		assert.equal((source.match(/new RefineOverlayController\("refs"/g) ?? []).length, 1, "controller must be constructed per batch inside the loop");
+		assert.equal((source.match(/new RefineOverlayController\(\s*"refs"/g) ?? []).length, 1, "controller must be constructed per batch inside the loop");
 		assert.match(source, /overlay\?\.open\(refineOverlayContext\(ctx\), modelLabel\)/);
 		assert.match(source, /await overlay\?\.close\(\);/);
 		assert.match(source, /const BATCH_SIZE = 3;/);

package/tests/auditor.test.ts

@@ -2,6 +2,9 @@
  * coverage, rollback boundaries, skipped-pass, and no-cover exclusion. */
 
 import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import { describe, it } from "node:test";
 import type { CheckItem } from "../src/plan.ts";
 import { auditRollbackSet, buildTaskView } from "../src/tasks.ts";
@@ -207,4 +210,185 @@ describe("audit rollback boundaries", () => {
 		assert.ok(presolved.includes("VC-003"));
 		assert.ok(!presolved.includes("VC-002"), "mixed coverage needs the auditor");
 	});
-});
+});
+describe("findings parsing (v0.9)", () => {
+	const GOOD = [
+		"- `VC-001` — verdict: pass; evidence: ok",
+		"",
+		"- `F-001` — severity: high; tasks: Task-3, task-4; note: union rollback missing; evidence: src/exec.ts:1290",
+		"- `F-002` — severity: medium; tasks: none; proposed-task: cap retry backoff at 60s; note: unbounded; evidence: src/client.ts:12",
+	].join("\n");
+
+	it("parses well-formed findings with id/task normalization", () => {
+		const { findings } = parseAuditReport(GOOD, ALL_IDS);
+		assert.equal(findings.length, 2);
+		const f1 = findings[0];
+		assert.equal(f1.id, "F-001");
+		assert.equal(f1.severity, "high");
+		assert.deepEqual(f1.taskIds, ["Task-3", "Task-4"]);
+		assert.equal(f1.note, "union rollback missing");
+		assert.equal(f1.evidence, "src/exec.ts:1290");
+		const f2 = findings[1];
+		assert.equal(f2.severity, "medium");
+		assert.deepEqual(f2.taskIds, []);
+		assert.equal(f2.proposedTask, "cap retry backoff at 60s");
+	});
+
+	it("tolerates emphasis markers on severity", () => {
+		const { findings } = parseAuditReport("- `F-001` — severity: **high**; tasks: Task-1; note: n; evidence: e", ALL_IDS);
+		assert.equal(findings[0]?.severity, "high");
+		const { findings: f2 } = parseAuditReport("- `F-002` — severity: `medium`; tasks: none; note: n", ALL_IDS);
+		assert.equal(f2[0]?.severity, "medium");
+	});
+
+	it("degrades unreadable severity to a recorded non-blocking entry (never a rollback driver)", () => {
+		const { findings } = parseAuditReport("- `F-003` — tasks: whatever; note: no severity field", ALL_IDS);
+		assert.equal(findings[0]?.severity, "malformed");
+		assert.deepEqual(findings[0]?.taskIds, []);
+	});
+
+	it("degrades a missing mandatory tasks field", () => {
+		const { findings } = parseAuditReport("- `F-004` — severity: high; note: tasks field absent", ALL_IDS);
+		assert.equal(findings[0]?.severity, "malformed");
+	});
+
+	it("resolves duplicate ids to the first bullet", () => {
+		const report = [
+			"- `F-001` — severity: high; tasks: Task-1; note: first",
+			"- `F-001` — severity: low; tasks: none; note: second",
+		].join("\n");
+		const { findings } = parseAuditReport(report, ALL_IDS);
+		assert.equal(findings.length, 1);
+		assert.equal(findings[0].note, "first");
+	});
+
+	it("a finding bullet citing a VC verdict never registers that verdict", () => {
+		const report = "- `F-005` — severity: high; tasks: Task-1; note: cites VC-004 verdict: pass; evidence: z";
+		const { passed, failed } = parseAuditReport(report, ALL_IDS);
+		assert.equal(passed.length + failed.length, 0);
+	});
+
+	it("prose mentioning F-### outside a bullet is ignored", () => {
+		const { findings } = parseAuditReport("also prose mentions F-009 not a bullet\n- `F-001` — severity: low; tasks: none; note: real", ALL_IDS);
+		assert.deepEqual(findings.map((f) => f.id), ["F-001"]);
+	});
+
+	it("applyAuditOutcome carries findings through to the outcome", () => {
+		const parsed = parseAuditReport(GOOD, ["VC-001"]);
+		const outcome = applyAuditOutcome(1, parsed, GOOD);
+		assert.equal(outcome.findings?.length, 2);
+	});
+});
+
+describe("section-aware verdict parsing (v0.9.1 F-011)", () => {
+	it("parses heading-style sections: id heading + verdict on its own line below", () => {
+		const report = [
+			"## 1. Verification verdicts",
+			"",
+			"### VC-001",
+			"- verdict: pass; evidence: src/a.ts",
+			"",
+			"### VC-002",
+			"- verdict: **fail**; evidence: src/c.ts",
+			"",
+			"### VC-003",
+			"verdict: undeterminable",
+		].join("\n");
+		const { passed, failed, undeterminable } = parseAuditReport(report, ["VC-001", "VC-002", "VC-003"]);
+		assert.deepEqual(passed, ["VC-001"]);
+		assert.deepEqual(failed, ["VC-002"]);
+		assert.deepEqual(undeterminable, ["VC-003"]);
+	});
+
+	it("a bare verdict with no open section is ignored (never misattributed)", () => {
+		const report = "Some preamble mentioning verdict: pass with no section above\n### VC-001\n- verdict: fail";
+		const { passed, failed } = parseAuditReport(report, ["VC-001"]);
+		assert.deepEqual(passed, []);
+		assert.deepEqual(failed, ["VC-001"]);
+	});
+
+	it("an unknown section id does not capture later bare verdicts", () => {
+		const report = ["### VC-999", "- verdict: pass", "### VC-002", "- verdict: pass"].join("\n");
+		const { passed, undeterminable } = parseAuditReport(report, ["VC-002"]);
+		assert.deepEqual(passed, ["VC-002"]);
+		assert.deepEqual(undeterminable, []);
+	});
+
+	it("finding bullets never open a verdict section", () => {
+		const report = [
+			"### VC-001",
+			"- `F-005` — severity: high; tasks: Task-1; note: cites verdict: pass inside a note; evidence: e",
+			"- verdict: fail",
+		].join("\n");
+		const { passed, failed } = parseAuditReport(report, ["VC-001"]);
+		assert.deepEqual(passed, []);
+		assert.deepEqual(failed, ["VC-001"]);
+		assert.equal(parseAuditReport(report, ["VC-001"]).findings[0]?.severity, "high");
+	});
+
+	it("knownTaskIds filters finding mappings to plan tasks (F-003)", () => {
+		const report = "- `F-001` — severity: high; tasks: Task-1, VC-007, bogus; note: n; evidence: e";
+		const { findings } = parseAuditReport(report, [], new Set(["Task-1"]));
+		assert.deepEqual(findings[0]?.taskIds, ["Task-1"]);
+	});
+});
+
+describe("review brief dual-output contract (v0.9)", () => {
+	it("demands both sections: verdicts and findings grammar", () => {
+		const task = buildAuditTask("/tmp/PLAN_v1.md", checks(), view(), 1);
+		assert.match(task, /1\. Verification verdicts/);
+		assert.match(task, /2\. Implementation findings/);
+		assert.match(task, /severity: high \| medium \| low/);
+		assert.match(task, /proposed-task:/);
+	});
+
+	it("lists plan tasks as the valid mapping domain", () => {
+		const task = buildAuditTask("/tmp/PLAN_v1.md", checks(), view(), 1);
+		assert.match(task, /Plan tasks \(the only ids valid in a finding's tasks field\):/);
+		assert.match(task, /`Task-3\.1`: injection/);
+	});
+
+	it("injects prior unresolved findings with the stable-id reuse instruction", () => {
+		const prior = [{
+			id: "F-001", severity: "high" as const, taskIds: ["Task-2"], note: "still broken",
+			evidence: "src/b.ts", raw: "- `F-001` — severity: high; tasks: Task-2; note: still broken",
+		}];
+		const task = buildAuditTask("/tmp/PLAN_v1.md", checks(), view(), 3, prior);
+		assert.match(task, /reuse these exact ids while the problem persists/);
+		assert.match(task, /`F-001` — severity: high; tasks: Task-2/);
+	});
+
+	it("marks the first findings round when no prior list exists", () => {
+		const task = buildAuditTask("/tmp/PLAN_v1.md", checks(), view(), 1);
+		assert.match(task, /first round with findings in scope/);
+	});
+});
+
+describe("review round report findings lines (v0.9)", () => {
+	it("emits the high-findings line and per-finding detail", async () => {
+		const { writeReviewRoundReport } = await import("../src/auditor.ts");
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-round-report-"));
+		try {
+			const file = writeReviewRoundReport(dir, {
+				budgetRound: 2,
+				attempt: 1,
+				outcome: "failed",
+				passed: ["VC-001"],
+				failed: [],
+				undeterminable: [],
+				findings: [
+					{ id: "F-001", severity: "high", taskIds: ["Task-2"], note: "broken", evidence: "e", raw: "raw" },
+					{ id: "F-002", severity: "medium", taskIds: [], proposedTask: "tidy up", note: "polish", evidence: "e", raw: "raw" },
+				],
+				coveredTaskIds: ["Task-1", "Task-2"],
+				report: "## Report\nbody",
+			});
+			assert.ok(file);
+			const text = fs.readFileSync(file, "utf8");
+			assert.match(text, /- high findings: F-001/);
+			assert.match(text, /F-002 \(medium; proposed: tidy up\)/);
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});