pi-plans 0.8.0 → 0.8.1

package/src/refine-ui.ts

@@ -183,10 +183,15 @@ export class RefineOverlayComponent implements Component {
 	private readonly modelLabel?: string;
 	/** Chrome language (issue #3); defaults to English for direct construction. */
 	private readonly lang: UiLanguage;
+	/** v0.8.1: pi-tui routes input ONLY to the focused component (no
+	 * bubbling), so an open overlay otherwise swallows every global shortcut
+	 * — including the Ctrl+Shift+T dashboard toggle users expect to work while
+	 * watching a review/refine overlay. Unhandled keys are forwarded here. */
+	private readonly onUnhandledKey?: (data: string) => void;
 	private selectedLane = 0;
 	private disposed = false;
 
-	constructor(theme: Theme, role: RefineOverlayRole, lanes: RefineLaneState[], onCancel: () => void, tui?: TUI, modelLabel?: string, lang: UiLanguage = "en") {
+	constructor(theme: Theme, role: RefineOverlayRole, lanes: RefineLaneState[], onCancel: () => void, tui?: TUI, modelLabel?: string, lang: UiLanguage = "en", onUnhandledKey?: (data: string) => void) {
 		this.theme = theme;
 		this.role = role;
 		this.lanes = lanes;
@@ -194,6 +199,7 @@ export class RefineOverlayComponent implements Component {
 		this.tui = tui;
 		this.modelLabel = modelLabel;
 		this.lang = lang;
+		this.onUnhandledKey = onUnhandledKey;
 		this.tui?.terminal?.write?.("\x1b[?1000h\x1b[?1006h");
 	}
 
@@ -214,7 +220,10 @@ export class RefineOverlayComponent implements Component {
 			return;
 		}
 		const lane = this.lanes[this.selectedLane];
-		if (!lane) return;
+		if (!lane) {
+			this.onUnhandledKey?.(data);
+			return;
+		}
 		const viewport = Math.max(1, lane.viewportHeight ?? 1);
 		if (matchesTerminalKey(data, "up")) lane.scrollOffset -= 1;
 		else if (matchesTerminalKey(data, "down")) lane.scrollOffset += 1;
@@ -222,7 +231,11 @@ export class RefineOverlayComponent implements Component {
 		else if (matchesTerminalKey(data, "pageDown")) lane.scrollOffset += Math.max(1, viewport - 1);
 		else {
 			const mouse = data.match(/^\x1b\[<(\d+);\d+;\d+[Mm]$/);
-			if (!mouse || (Number(mouse[1]) & 64) !== 64) return;
+			if (!mouse || (Number(mouse[1]) & 64) !== 64) {
+				// Not ours: forward instead of swallowing (see onUnhandledKey note).
+				this.onUnhandledKey?.(data);
+				return;
+			}
 			lane.scrollOffset += (Number(mouse[1]) & 1) === 0 ? -3 : 3;
 		}
 		lane.followTranscript = false;
@@ -303,11 +316,14 @@ export class RefineOverlayController {
 	private tui: TUI | undefined;
 	private closed = false;
 	private readonly lang: UiLanguage;
+	/** Forwarded unhandled keys (see RefineOverlayComponent.onUnhandledKey). */
+	private readonly onUnhandledKey?: (data: string) => void;
 
-	constructor(role: RefineOverlayRole, laneIds: Array<{ id: string; label?: string }>, onCancel: () => void, lang: UiLanguage = "en") {
+	constructor(role: RefineOverlayRole, laneIds: Array<{ id: string; label?: string }>, onCancel: () => void, lang: UiLanguage = "en", onUnhandledKey?: (data: string) => void) {
 		this.role = role;
 		this.onCancel = onCancel;
 		this.lang = lang;
+		this.onUnhandledKey = onUnhandledKey;
 		this.lanes = laneIds.map((lane) => ({
 			id: lane.id,
 			label: lane.label ?? lane.id,
@@ -330,7 +346,7 @@ export class RefineOverlayController {
 				(_tui, theme, _keybindings, done) => {
 					this.tui = _tui;
 					this.done = done;
-					this.component = new RefineOverlayComponent(theme, this.role, this.lanes, () => this.cancel(), _tui, modelLabel, this.lang);
+					this.component = new RefineOverlayComponent(theme, this.role, this.lanes, () => this.cancel(), _tui, modelLabel, this.lang, this.onUnhandledKey);
 					if (this.closed) done(undefined);
 					return this.component;
 				},

package/src/resume-command.ts

@@ -309,12 +309,18 @@ async function buildBrief(
 					: `\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.9.1 (F-005): outstanding highs surface in the brief itself, not
+			// only in the per-turn injection.
+			const highs = (load.findings ?? []).filter((f) => f.severity === "high");
+			const highLine = highs.length > 0
+				? `\nUnresolved high-severity findings from review round (stable ids): ${highs.map((f) => `${f.id}${f.taskIds.length ? ` (${f.taskIds.join(", ")})` : ""}: ${f.note}`).join("; ")} — fix them, then re-close the affected tasks.`
+				: "";
 			// 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: 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."}`,
+				text: `[PI-PLANS RESUME] ${verifying ? "Execution review of" : "Execution of"} run ${runId} continues in this session.\nPlan: ${load.planPath}${reverify}${paused}${legacy}${highLine}\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/tasks.ts

@@ -165,6 +165,29 @@ export function auditRollbackSet(
 	return reopen;
 }
 
+/** Rollback set for high-severity findings (v0.9): reopen exactly the named
+ * tasks — parents cascade to their children, skipped tasks reopen too — with
+ * semantics identical to auditRollbackSet, but keyed by task id because
+ * findings carry task ids, not VC ids. Evidence is kept and skipReason
+ * cleared for the same reasons as the VC path. */
+export function findingsRollbackSet(tasks: TaskView[], taskIds: string[]): string[] {
+	const wanted = new Set(taskIds);
+	const flat = flattenTaskViews(tasks);
+	const reopen: string[] = [];
+	const reopenNode = (node: TaskView): void => {
+		if (node.status !== "pending") {
+			node.status = "pending";
+			node.skipReason = undefined;
+			reopen.push(node.id);
+		}
+		for (const child of node.children) reopenNode(child);
+	};
+	for (const node of flat) {
+		if (wanted.has(node.id)) reopenNode(node);
+	}
+	return reopen;
+}
+
 /** Checks that lose their satisfied state because a rollback reopened work
  * they were verifying. Returns the ids whose `done` flag was cleared.
  *

package/src/workflow-state.ts

@@ -156,8 +156,36 @@ export interface ExecutionCheckpoint {
 	 * silently hand a stalled run a fresh budget; optional so checkpoints
 	 * written before this field keep loading. */
 	stallRounds?: number;
+	/** 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 {
@@ -465,7 +493,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", "planAmended", "audit"]),
 		label,
 	);
 	const execution: ExecutionCheckpoint = {
@@ -512,10 +540,19 @@ 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),
+		};
+	}
 	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 +560,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,8 +1135,10 @@ 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;
 }
@@ -1108,6 +1165,23 @@ export function applyExecutionProgress(cp: WorkflowCheckpoint, progress: Executi
 	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\"");

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 });
+		}
+	});
+});

package/tests/dashboard.test.ts

@@ -14,7 +14,7 @@ import * as assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import { visibleWidth } from "@earendil-works/pi-tui";
 import { parsePlanTasks } from "../src/plan.ts";
-import { buildTaskView } from "../src/tasks.ts";
+import { buildTaskView, flattenTaskViews } from "../src/tasks.ts";
 import { visibleWidth as localVisibleWidth } from "../src/refine-ui-helpers.ts";
 import {
 	deriveDashboardModel,
@@ -400,3 +400,69 @@ describe("rolled-back task rendering", () => {
 		}
 	});
 });
+
+describe("findings visibility (v0.9)", () => {
+	const findings = [
+		{ id: "F-001", severity: "high", note: "union rollback missing", taskIds: ["Task-3"] },
+		{ id: "F-002", severity: "medium", note: "polish", taskIds: [] },
+	];
+
+	function withFindings(extra: { auditRounds?: number; reviewRunning?: boolean }) {
+		const tasks = buildTaskView(parsePlanTasks(PLAN), {});
+		const checklist = [
+			{ id: "VC-001", text: "`VC-001` covers `Task-1`; pass condition: x", done: false },
+			{ id: "VC-002", text: "`VC-002` covers `Task-3`; pass condition: y", done: false },
+		];
+		return deriveDashboardModel("demo-run", tasks, checklist, {
+			startedAt: new Date().toISOString(),
+			findings,
+			auditRounds: extra.auditRounds ?? null,
+			reviewRunning: extra.reviewRunning ?? false,
+		});
+	}
+
+	it("summary line shows review round/5 and the high count", () => {
+		const line = formatDashboardSummaryLine(withFindings({ auditRounds: 2 }));
+		assert.match(line, /review r2\/5/);
+		assert.match(line, /1 high/);
+	});
+
+	it("summary line omits the high token when only non-high findings remain", () => {
+		const tasks = buildTaskView(parsePlanTasks(PLAN), {});
+		const m = deriveDashboardModel("demo-run", tasks, [], {
+			startedAt: new Date().toISOString(),
+			findings: [{ id: "F-002", severity: "medium", note: "polish", taskIds: [] }],
+			auditRounds: 3,
+		});
+		const line = formatDashboardSummaryLine(m);
+		assert.match(line, /review r3\/5/);
+		assert.doesNotMatch(line, /high/);
+	});
+
+	it("compact panel renders the high-findings line in BOTH phases", () => {
+		// Non-terminal phase (the executor is repairing): the line must show.
+		const repairing = renderDashboardLines(withFindings({ auditRounds: 1 }), 80);
+		assert.ok(repairing.some((l) => /⚠.*high: F-001/.test(l)), "high findings visible while repairing");
+
+		// Terminal phase: still visible alongside the round counter.
+		const everyId = Object.fromEntries(
+			flattenTaskViews(buildTaskView(parsePlanTasks(PLAN), {})).map((t) => [t.id, { status: "complete" as const }]),
+		);
+		const allDone = buildTaskView(parsePlanTasks(PLAN), everyId);
+		const terminal = deriveDashboardModel("demo-run", allDone, [], {
+			startedAt: new Date().toISOString(),
+			findings,
+			auditRounds: 1,
+		});
+		const lines = renderDashboardLines(terminal, 80);
+		assert.ok(lines.some((l) => /⚠.*high: F-001/.test(l)));
+		assert.ok(lines.some((l) => /high finding\(s\) unresolved/.test(l)));
+	});
+
+	it("tree view lists findings with severity and mapping, and the verdict line names unresolved highs", () => {
+		const lines = renderDashboardTreeLines(withFindings({ auditRounds: 2 }), 100);
+		assert.ok(lines.some((l) => /⚠ F-001 \(high, Task-3\): union rollback missing/.test(l)));
+		assert.ok(lines.some((l) => /· F-002 \(medium\): polish/.test(l)));
+		assert.ok(lines.some((l) => /high findings unresolved: F-001/.test(l)));
+	});
+});