pi-plans 0.8.0 → 0.8.2

package/tests/tasks.test.ts

@@ -7,7 +7,9 @@ import { describe, it } from "node:test";
 import type { CheckItem } from "../src/plan.ts";
 import {
 	auditRollbackSet,
+	blockedReviewTasks,
 	buildTaskView,
+	rollbackCoverageIds,
 	invalidateChecksForRolledBackTasks,
 	taskProgressMap,
 	type TaskProgressMap,
@@ -113,6 +115,49 @@ describe("progress persistence", () => {
 	});
 });
 
+describe("blocked review tasks", () => {
+	it("reports every non-terminal member of the authoritative rollback set in tree order", () => {
+		// Task-3 is complete but its child is open, so the parent is not
+		// terminal either; both must surface as blockers.
+		const tasks = view({ "Task-1": { status: "complete" }, "Task-3": { status: "complete" } });
+		assert.deepEqual(
+			blockedReviewTasks(tasks, ["Task-1", "Task-2", "Task-3", "Task-3.1"]),
+			["Task-2", "Task-3", "Task-3.1"],
+		);
+	});
+
+	it("reports a task that was already pending, unlike the flip-reporting rollback helper", () => {
+		// The rollback helpers report only nodes they flipped; a task that was
+		// pending before the round must still count as blocking work.
+		const tasks = view({ "Task-1": { status: "pending" } });
+		assert.deepEqual(auditRollbackSet(tasks, checks(), "VC-001"), []);
+		assert.deepEqual(blockedReviewTasks(tasks, ["Task-1"]), ["Task-1"]);
+	});
+
+	it("ignores terminal tasks and ids outside the rollback set", () => {
+		const tasks = view(ALL_DONE);
+		assert.deepEqual(blockedReviewTasks(tasks, ["Task-1", "Task-3"]), []);
+		assert.deepEqual(blockedReviewTasks(tasks, []), []);
+	});
+
+	it("computes a failed round's coverage (pre-feature backfill) without mutating the tree", () => {
+		// VC-002 covers Task-2 and Task-3; the cascade pulls Task-3.1 in.
+		const tasks = view(ALL_DONE);
+		const before = JSON.stringify(tasks);
+		assert.deepEqual(rollbackCoverageIds(tasks, checks(), ["VC-002"]), ["Task-2", "Task-3", "Task-3.1"]);
+		assert.deepEqual(rollbackCoverageIds(tasks, checks(), ["VC-003"]), ["Task-3.1"]);
+		assert.deepEqual(rollbackCoverageIds(tasks, checks(), ["VC-999"]), []);
+		assert.equal(JSON.stringify(tasks), before, "coverage computation never reopens anything");
+	});
+
+	it("never mutates status, evidence, or skipReason", () => {
+		const tasks = view({ "Task-2": { status: "pending", evidence: "previous attempt" }, "Task-3": { status: "skipped", skipReason: "covered by Task-2" } });
+		const before = JSON.stringify(tasks);
+		blockedReviewTasks(tasks, ["Task-1", "Task-2", "Task-3", "Task-3.1"]);
+		assert.equal(JSON.stringify(tasks), before);
+	});
+});
+
 describe("done-flag invalidation", () => {
 	it("clears done on checks whose covered tasks were reopened", () => {
 		// VC-002 covers Task-2 and Task-3; its rollback reopens those, so a

package/tests/workflow-state.test.ts

@@ -482,4 +482,231 @@ describe("blocking budget persistence", () => {
 		const loaded = loadCheckpoint(workdir, runId);
 		assert.equal(loaded.status, "corrupt", "the closed schema is still enforced");
 	});
+	// v0.9: findings ride the same audit slot — same persistence rules.
+
+	it("round-trips findings through the checkpoint validator", () => {
+		const { workdir, runId } = setupRun("findings-roundtrip");
+		const cp = applyExecutionProgress(executingCheckpoint(workdir, runId), {
+			audit: {
+				rounds: 2,
+				lastResult: "highs: F-001",
+				findings: [
+					{ id: "F-001", severity: "high", taskIds: ["Task-2"], note: "broken", evidence: "src/b.ts", raw: "raw line" },
+					{ id: "F-002", severity: "medium", taskIds: [], proposedTask: "tidy", note: "polish", evidence: "e", raw: "r" },
+				],
+			},
+		});
+		mutateCheckpoint(workdir, runId, () => cp);
+		const loaded = loadCheckpoint(workdir, runId);
+		assert.ok(loaded.status === "ok");
+		assert.deepEqual(loaded.checkpoint.execution?.audit?.findings, [
+			{ id: "F-001", severity: "high", taskIds: ["Task-2"], note: "broken", evidence: "src/b.ts", raw: "raw line" },
+			{ id: "F-002", severity: "medium", taskIds: [], proposedTask: "tidy", note: "polish", evidence: "e", raw: "r" },
+		]);
+	});
+
+	it("loads a checkpoint written before findings existed (absent, not corrupt)", () => {
+		const { workdir, runId } = setupRun("findings-legacy");
+		const cp = applyExecutionProgress(executingCheckpoint(workdir, runId), { audit: { rounds: 1, lastResult: "VC-001" } });
+		mutateCheckpoint(workdir, runId, () => cp);
+		const loaded = loadCheckpoint(workdir, runId);
+		assert.ok(loaded.status === "ok", "legacy checkpoint still loads");
+		assert.equal(loaded.checkpoint.execution?.audit?.findings, undefined);
+	});
+
+	it("rejects unknown keys inside a findings record", () => {
+		const { workdir, runId } = setupRun("findings-bad-record");
+		const cp = applyExecutionProgress(executingCheckpoint(workdir, runId), {
+			audit: { rounds: 1, findings: [{ id: "F-001", severity: "high", taskIds: [], note: "n", evidence: "e", raw: "r", bogus: true } as never] },
+		});
+		// Validation runs at write: a malformed findings record never lands.
+		assert.throws(() => mutateCheckpoint(workdir, runId, () => cp), /findings\.0: unexpected key/);
+	});
+});
+
+describe("blocked-point persistence (v0.9.2)", () => {
+	function executingCheckpoint(workdir: string, runId: string) {
+		createCheckpoint(workdir, { runId, originWorkdir: workdir, workdir });
+		const planPath = path.join(workdir, "PLAN_v1.md");
+		fs.writeFileSync(planPath, "# PLAN_v1 - blocked demo\n", "utf8");
+		const plan = planIdentityOf(planPath, 1);
+		let cp = applyPlanWritten(baseCheckpoint(workdir, runId), plan);
+		cp = { ...cp, nextAction: "accept-execute" };
+		cp = applyExecutionApproved(cp, { plan, worktree: cp.worktreeRoot, headAtApproval: null, approvedAt: cp.updatedAt });
+		return cp;
+	}
+
+	const BLOCKED = {
+		rolledBack: ["Task-2", "Task-2.1", "Task-7"],
+		tasks: ["Task-2"],
+		round: 1,
+		escalatedRounds: 0,
+		since: "2026-10-02T10:32:00Z",
+	};
+
+	it("round-trips the blocker and its escalation counter", () => {
+		const { workdir, runId } = setupRun("blocked-roundtrip");
+		const cp = applyExecutionProgress(executingCheckpoint(workdir, runId), { blocked: BLOCKED });
+		mutateCheckpoint(workdir, runId, () => cp);
+		const loaded = loadCheckpoint(workdir, runId);
+		assert.ok(loaded.status === "ok");
+		assert.deepEqual(loaded.checkpoint.execution?.blocked, BLOCKED);
+	});
+
+	it("null clears the blocker (delete-on-null, like pausedReason)", () => {
+		const { workdir, runId } = setupRun("blocked-null");
+		let cp = applyExecutionProgress(executingCheckpoint(workdir, runId), { blocked: BLOCKED });
+		cp = applyExecutionProgress(cp, { blocked: null });
+		assert.equal(cp.execution?.blocked, undefined);
+		mutateCheckpoint(workdir, runId, () => cp);
+		const loaded = loadCheckpoint(workdir, runId);
+		assert.ok(loaded.status === "ok");
+		assert.equal(loaded.checkpoint.execution?.blocked, undefined);
+	});
+
+	it("loads a checkpoint written before the field existed", () => {
+		const { workdir, runId } = setupRun("blocked-legacy");
+		const cp = executingCheckpoint(workdir, runId);
+		mutateCheckpoint(workdir, runId, () => cp);
+		const loaded = loadCheckpoint(workdir, runId);
+		assert.ok(loaded.status === "ok", "legacy checkpoint still loads");
+		assert.equal(loaded.checkpoint.execution?.blocked, undefined);
+	});
+
+	it("rejects unknown keys inside the blocker record", () => {
+		const { workdir, runId } = setupRun("blocked-bad-record");
+		const cp = applyExecutionProgress(executingCheckpoint(workdir, runId), {
+			blocked: { ...BLOCKED, bogus: true } as never,
+		});
+		assert.throws(() => mutateCheckpoint(workdir, runId, () => cp), /blocked: unexpected key/);
+	});
+
+	it("a stop revokes the blocker (stale rollback authorization)", () => {
+		const { workdir, runId } = setupRun("blocked-stopped");
+		const cp = applyExecutionProgress(executingCheckpoint(workdir, runId), { blocked: BLOCKED });
+		const stopped = applyExecutionStopped(cp, "user stop");
+		assert.equal(stopped.execution?.blocked, undefined);
+		assert.equal(stopped.execution?.pausedReason, "user stop");
+	});
+
+	it("completion clears the blocker", () => {
+		const { workdir, runId } = setupRun("blocked-completed");
+		const cp = applyExecutionProgress(executingCheckpoint(workdir, runId), { blocked: BLOCKED });
+		assert.equal(applyExecutionCompleted(cp).execution?.blocked, undefined);
+	});
+});
+
+describe("review-budget persistence (v0.9.3)", () => {
+	function executingCheckpoint(workdir: string, runId: string) {
+		createCheckpoint(workdir, { runId, originWorkdir: workdir, workdir });
+		const planPath = path.join(workdir, "PLAN_v1.md");
+		fs.writeFileSync(planPath, "# PLAN_v1 - budget demo\n", "utf8");
+		const plan = planIdentityOf(planPath, 1);
+		let cp = applyPlanWritten(baseCheckpoint(workdir, runId), plan);
+		cp = { ...cp, nextAction: "accept-execute" };
+		cp = applyExecutionApproved(cp, { plan, worktree: cp.worktreeRoot, headAtApproval: null, approvedAt: cp.updatedAt });
+		return cp;
+	}
+
+	const BUDGET = {
+		reviewBudget: "unlimited" as const,
+		reviewBudgetDefaulted: true,
+		reviewRoundsTotal: 7,
+		reviewCapExtension: 50,
+		reviewNoProgress: { key: "VC-002|VC-001|F-001", streak: 2 },
+	};
+
+	it("round-trips the budget, its counters, and the no-progress state", () => {
+		const { workdir, runId } = setupRun("budget-roundtrip");
+		const cp = applyExecutionProgress(executingCheckpoint(workdir, runId), BUDGET);
+		mutateCheckpoint(workdir, runId, () => cp);
+		const loaded = loadCheckpoint(workdir, runId);
+		assert.ok(loaded.status === "ok");
+		assert.equal(loaded.checkpoint.execution?.reviewBudget, "unlimited");
+		assert.equal(loaded.checkpoint.execution?.reviewBudgetDefaulted, true);
+		assert.equal(loaded.checkpoint.execution?.reviewRoundsTotal, 7);
+		assert.equal(loaded.checkpoint.execution?.reviewCapExtension, 50);
+		assert.deepEqual(loaded.checkpoint.execution?.reviewNoProgress, { key: "VC-002|VC-001|F-001", streak: 2 });
+	});
+
+	it("accepts a numeric budget and rejects malformed values with the key name", () => {
+		const { workdir, runId } = setupRun("budget-validation");
+		const base = executingCheckpoint(workdir, runId);
+		assert.equal(applyExecutionProgress(base, { reviewBudget: 1 }).execution?.reviewBudget, 1);
+		// The write path stores what it is given (like every other progress
+		// field); the READ path validates and names the offending key.
+		for (const bad of [0, -1, 2.5, true, { rounds: 3 }]) {
+			const cp = applyExecutionProgress(base, { reviewBudget: bad as never });
+			assert.throws(
+				() => mutateCheckpoint(workdir, runId, () => cp),
+				/reviewBudget/,
+				`reviewBudget ${JSON.stringify(bad)} rejected`,
+			);
+		}
+		assert.throws(() => mutateCheckpoint(workdir, runId, () => applyExecutionProgress(base, { reviewBudget: "infinite" as never })), /reviewBudget/);
+		assert.throws(() => mutateCheckpoint(workdir, runId, () => applyExecutionProgress(base, { reviewRoundsTotal: -1 })), /reviewRoundsTotal/);
+		assert.throws(() => mutateCheckpoint(workdir, runId, () => applyExecutionProgress(base, { reviewCapExtension: -3 })), /reviewCapExtension/);
+		assert.throws(
+			() => mutateCheckpoint(workdir, runId, () => applyExecutionProgress(base, { reviewNoProgress: { key: "x" } as never })),
+			/reviewNoProgress/,
+		);
+		assert.throws(
+			() => mutateCheckpoint(workdir, runId, () => applyExecutionProgress(base, { reviewNoProgress: { key: "x", streak: -1 } })),
+			/reviewNoProgress.streak/,
+		);
+	});
+
+	it("null clears the budget and the valve state (delete-on-null)", () => {
+		const { workdir, runId } = setupRun("budget-null");
+		let cp = applyExecutionProgress(executingCheckpoint(workdir, runId), BUDGET);
+		cp = applyExecutionProgress(cp, { reviewBudget: null, reviewBudgetDefaulted: null, reviewNoProgress: null });
+		assert.equal(cp.execution?.reviewBudget, undefined);
+		assert.equal(cp.execution?.reviewBudgetDefaulted, undefined);
+		assert.equal(cp.execution?.reviewNoProgress, undefined);
+		mutateCheckpoint(workdir, runId, () => cp);
+		const loaded = loadCheckpoint(workdir, runId);
+		assert.ok(loaded.status === "ok");
+		assert.equal(loaded.checkpoint.execution?.reviewBudget, undefined);
+		assert.equal(loaded.checkpoint.execution?.reviewNoProgress, undefined);
+	});
+
+	it("loads a checkpoint written before the fields existed (absent, not corrupt)", () => {
+		const { workdir, runId } = setupRun("budget-legacy");
+		const cp = applyExecutionProgress(executingCheckpoint(workdir, runId), { reviewBudget: null });
+		mutateCheckpoint(workdir, runId, () => cp);
+		const raw = JSON.parse(fs.readFileSync(checkpointFilePath(workdir, runId), "utf8"));
+		assert.equal(raw.execution.reviewBudget, undefined);
+		const loaded = loadCheckpoint(workdir, runId);
+		assert.ok(loaded.status === "ok");
+		assert.equal(loaded.checkpoint.execution?.reviewBudget, undefined);
+		// The live state resolves a legacy shape to the 5-round bound; that
+		// resolution is exercised in tests/review-budget.test.ts.
+	});
+
+	it("a stop and a completion both drop the budget and its valve state", () => {
+		const { workdir, runId } = setupRun("budget-cleanup");
+		const withBudget = applyExecutionProgress(executingCheckpoint(workdir, runId), BUDGET);
+		const stopped = applyExecutionStopped(withBudget, "user stop");
+		assert.equal(stopped.execution?.reviewBudget, undefined);
+		assert.equal(stopped.execution?.reviewRoundsTotal, undefined);
+		assert.equal(stopped.execution?.reviewCapExtension, undefined);
+		assert.equal(stopped.execution?.reviewNoProgress, undefined);
+		const completed = applyExecutionCompleted(withBudget);
+		assert.equal(completed.execution?.reviewBudget, undefined);
+		assert.equal(completed.execution?.reviewRoundsTotal, undefined);
+		assert.equal(completed.execution?.reviewNoProgress, undefined);
+	});
+
+	it("a migration preserves the budget but resets the invalidated execution state", () => {
+		const { workdir, runId } = setupRun("budget-migration");
+		const migrated = applyMigration(applyExecutionProgress(executingCheckpoint(workdir, runId), BUDGET), {
+			workdir,
+			worktreeRoot: workdir,
+			commonDir: path.join(workdir, ".git"),
+		});
+		assert.equal(migrated.execution?.reviewBudget, "unlimited");
+		assert.equal(migrated.execution?.reviewRoundsTotal, 7);
+		assert.deepEqual(migrated.execution?.tasks, {}, "task progress still does not migrate");
+		assert.equal(migrated.execution?.audit?.rounds, 0, "audit rounds still restart at 0");
+	});
 });

package/tools/analyze-refs.ts

@@ -15,7 +15,6 @@
 
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { truncateHead } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import * as fs from "node:fs";
@@ -37,6 +36,8 @@ import { resolveActiveRun } from "../src/run-context.ts";
 import { buildRefAnalystTask, type RefAnalystTaskInput } from "../src/refine-prompts.ts";
 import { runPiSubagent, stripFrontmatter } from "../src/subagent.ts";
 import { RefineOverlayController, refineOverlayContext } from "../src/refine-ui.ts";
+import { matchesTerminalKey } from "../src/terminal-keys.ts";
+import { toggleDashboardExpanded } from "../src/exec.ts";
 import { resolveUiLanguage } from "../src/ui-language.ts";
 
 const BATCH_SIZE = 3;
@@ -80,7 +81,7 @@ async function ensureRefAnalystModelReady(
 ): Promise<{ mode: string; model_selector: string | null; thinking_level: string | null; confirmed_at: string | null; name_prefix: string }> {
 	if (role.confirmed_at !== null && role.model_selector !== null) return role as never;
 	let outcome = await runFirstUseFlow(host, role.thinking_level);
-	if (outcome.status === "confirmed" && outcome.model_selector !== null && availableModels(host).length > 0 && findModel(host, outcome.model_selector) === null) {
+	if (outcome.status === "confirmed" && availableModels(host).length > 0 && findModel(host, outcome.modelSelector) === null) {
 		// F-008: a manually entered selector that the registry does not know —
 		// one re-pick, then let spawn-side errors surface precisely.
 		outcome = await runFirstUseFlow(host, outcome.role.thinking_level);
@@ -226,7 +227,16 @@ export function registerAnalyzeRefsTool(ext: ExtensionAPI, baseDir: string): voi
 
 				const overlay =
 					ctx.mode === "tui"
-						? new RefineOverlayController("refs", batch.map((job) => ({ id: job.laneId, label: job.laneId })), relayAbort, resolveUiLanguage(workdir))
+						? new RefineOverlayController(
+							"refs",
+							batch.map((job) => ({ id: job.laneId, label: job.laneId })),
+							relayAbort,
+							resolveUiLanguage(workdir),
+							// Forward the dashboard toggle (no key bubbling in pi-tui).
+							(data) => {
+								if (matchesTerminalKey(data, "ctrl+shift+t")) toggleDashboardExpanded(ctx);
+							},
+						)
 						: undefined;
 				overlay?.open(refineOverlayContext(ctx), modelLabel);
 				try {
@@ -264,9 +274,10 @@ export function registerAnalyzeRefsTool(ext: ExtensionAPI, baseDir: string): voi
 			}
 
 			const combined = sections.join("\n\n---\n\n");
-			const truncation = truncateHead(combined, { maxLines: 2000, maxBytes: 50 * 1024 });
-			let text = truncation.content;
-			if (truncation.truncated) text += `\n\n[Output truncated; full outputs remain in this tool result's details.]`;
+			// v0.8.1: no head-truncation — the full combined analysis flows into the
+		// tool result (and REF_ANALYSIS.md) verbatim; the previous 2000-line/
+		// 50KB cap silently dropped the tail of large reference analyses.
+			const text = combined;
 
 			return {
 				content: [

package/tools/execute-plan.ts

@@ -157,19 +157,26 @@ export async function executeCommand(ctx: ExtensionContext, planPathArg?: string
 	const activeExecution = getExecution();
 	const planPath = planPathArg ? path.resolve(ctx.cwd, planPathArg.replace(/^@/, "")) : activeExecution?.planPath;
 	if (activeExecution && planPath && path.resolve(activeExecution.planPath) === path.resolve(planPath)) {
-		const resumed = resumeActiveExecution(ctx);
+		// v0.9.3: the resume is async because a review-pause grant re-opens the
+		// budget picker; the message below is produced AFTER that panel resolves.
+		const resumed = await resumeActiveExecution(ctx);
 		// v0.8 phase-aware response: a verifying run continues its review loop
-		// (this tool is also the ONLY budget-granting surface at a cap pause).
+		// (this tool is also the ONLY budget-granting surface at a review pause).
 		const statusText = activeExecution.review?.inFlight
 			? "Execution review in progress (status verifying); the reviewer round runs in the overlay."
 			: (getExecution()?.stall.paused ?? false)
-				? "Execution review paused at the round cap — this confirmation granted a fresh five-round budget; the review resumes now."
-				: "Execution resumed; task progress preserved.";
+				? "Execution review paused — run /plans-execute and pick a round budget to continue."
+				: resumed.grantedBudget !== undefined
+					? `Review budget granted (${resumed.grantedBudget === "unlimited" ? "unlimited" : `${resumed.grantedBudget} rounds`}); the review resumes now.`
+					: "Execution resumed; task progress preserved.";
+		const declined = resumed.budgetDeclined === true;
 		return {
 			status: "executing",
 			planPath,
 			itemCount: activeExecution.items.length,
-			message: resumed ? statusText : "This plan is already executing.",
+			message: declined
+				? "Review budget unchanged — the run stays paused. Call /plans-execute again and pick a round count to continue."
+				: resumed.resumed ? statusText : "This plan is already executing.",
 		};
 	}
 	return executeHandoff(ctx, planPathArg);

package/tools/refine.ts

@@ -44,6 +44,8 @@ import { buildReviewerTask, reviewerLanes } from "../src/refine-prompts.ts";
 import { graphBlockForRefiner } from "../src/code-graph/prompts.ts";
 import { runPiSubagent, stripFrontmatter } from "../src/subagent.ts";
 import { RefineOverlayController, refineOverlayContext } from "../src/refine-ui.ts";
+import { matchesTerminalKey } from "../src/terminal-keys.ts";
+import { toggleDashboardExpanded } from "../src/exec.ts";
 
 
 const RefineParams = Type.Object({
@@ -90,10 +92,15 @@ async function ensureReviewerReady(
 ): Promise<{ mode: string; model_selector: string | null; thinking_level: string | null; confirmed_at: string | null; name_prefix: string }> {
 	if (role.mode === "current-session" || reviewerReady(role as never)) return role as never;
 	let outcome: FirstUseOutcome = await runFirstUseFlow(host, role.thinking_level);
-	if (outcome.status === "confirmed" && outcome.model_selector !== null) {
+	if (outcome.status === "confirmed") {
 		// F-008: validate the freshly chosen selector against the registry when
 		// one is present, so a typo'd manual entry fails here, not at spawn.
-		if (availableModels(host).length > 0 && findModel(host, outcome.model_selector) === null) {
+		// (v0.8.1 field-drift fix: the outcome's top-level field is camelCase
+		// `modelSelector` — reading snake_case `model_selector` yielded
+		// undefined, passed the old `!== null` guard, and crashed findModel
+		// with "Cannot read properties of undefined (reading 'indexOf')"
+		// right after the first-use panel confirmed.)
+		if (availableModels(host).length > 0 && findModel(host, outcome.modelSelector) === null) {
 			outcome = await runFirstUseFlow(host, outcome.role.thinking_level);
 		}
 	}
@@ -117,7 +124,19 @@ function setupRefinementExecution(
 	if (parentSignal?.aborted) controller.abort();
 	else parentSignal?.addEventListener("abort", relayAbort, { once: true });
 
-	const overlay = ctx.mode === "tui" ? new RefineOverlayController("reviewer", lanes, relayAbort, lang) : undefined;
+	const overlay = ctx.mode === "tui"
+		? new RefineOverlayController(
+			"reviewer",
+			lanes,
+			relayAbort,
+			lang,
+			// pi-tui has no key bubbling: forward the dashboard toggle so
+			// Ctrl+Shift+T keeps working while the refine overlay holds focus.
+			(data) => {
+				if (matchesTerminalKey(data, "ctrl+shift+t")) toggleDashboardExpanded(ctx);
+			},
+		)
+		: undefined;
 	overlay?.open(refineOverlayContext(ctx), modelLabel);
 
 	return {