pi-plans 0.7.0 → 0.8.0

package/tests/tasks.test.ts

@@ -0,0 +1,142 @@
+/** Tests for the task tree primitives that the execution review drives:
+ * rollback retention, persistence completeness, and done-flag invalidation.
+ */
+
+import * as assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { CheckItem } from "../src/plan.ts";
+import {
+	auditRollbackSet,
+	buildTaskView,
+	invalidateChecksForRolledBackTasks,
+	taskProgressMap,
+	type TaskProgressMap,
+} from "../src/tasks.ts";
+import { parsePlanTasks } from "../src/plan.ts";
+
+const PLAN = `## Tasks
+
+- Task-1: parser — files: src/a.ts; wave: 1
+- Task-2: tool — files: src/b.ts; wave: 1
+- Task-3: core — deps: Task-1, Task-2; files: src/c.ts; wave: 2
+  - Task-3.1: injection — files: src/c.ts
+
+## Verification Checks
+
+- [ ] \`VC-001\` covers \`Task-1\`; pass condition: parser ok
+- [ ] \`VC-002\` covers \`Task-2\` and \`Task-3\`; pass condition: tool+core ok
+- [ ] \`VC-003\` covers \`Task-3.1\`; pass condition: injection ok
+`;
+
+function checks(done: string[] = []): CheckItem[] {
+	const raw = PLAN.split("## Verification Checks")[1] ?? "";
+	const items: CheckItem[] = [];
+	for (const line of raw.split("\n")) {
+		const m = line.match(/^- \[ \] `(VC-\d+)` (.+)$/);
+		if (m) items.push({ id: m[1], text: m[2], done: done.includes(m[1]) });
+	}
+	return items;
+}
+
+function view(progress: TaskProgressMap = {}) {
+	return buildTaskView(parsePlanTasks(PLAN), progress);
+}
+
+const ALL_DONE: TaskProgressMap = {
+	"Task-1": { status: "complete", evidence: "edited src/a.ts" },
+	"Task-2": { status: "complete", evidence: "edited src/b.ts" },
+	"Task-3": { status: "complete", evidence: "edited src/c.ts" },
+	"Task-3.1": { status: "complete", evidence: "injected src/c.ts" },
+};
+
+describe("rollback retention", () => {
+	it("keeps the evidence of a rolled-back complete task", () => {
+		const tasks = view(ALL_DONE);
+		const reopened = auditRollbackSet(tasks, checks(), "VC-001");
+		assert.deepEqual(reopened, ["Task-1"]);
+		const task = tasks[0];
+		assert.equal(task.status, "pending");
+		// Regression: rollback used to clear evidence, so the agent lost the
+		// record of what the previous attempt did and had to re-derive it.
+		assert.equal(task.evidence, "edited src/a.ts");
+	});
+
+	it("keeps evidence but clears the skip reason of a rolled-back skipped task", () => {
+		const tasks = view({ "Task-2": { status: "skipped", skipReason: "covered by Task-3" } });
+		assert.deepEqual(auditRollbackSet(tasks, checks(), "VC-002"), ["Task-2"]);
+		const task = tasks.find((t) => t.id === "Task-2");
+		assert.equal(task.status, "pending");
+		assert.equal(task.skipReason, undefined, "the audit overturned the skip");
+	});
+
+	it("leaves tasks outside the covers clause untouched", () => {
+		const tasks = view(ALL_DONE);
+		auditRollbackSet(tasks, checks(), "VC-001");
+		assert.equal(tasks.find((t) => t.id === "Task-2")?.status, "complete");
+		assert.equal(tasks.find((t) => t.id === "Task-2")?.evidence, "edited src/b.ts");
+	});
+
+	it("does not report a task that is already pending as reopened", () => {
+		const tasks = view({ "Task-1": { status: "pending" } });
+		assert.deepEqual(auditRollbackSet(tasks, checks(), "VC-001"), []);
+	});
+});
+
+describe("progress persistence", () => {
+	it("records every task, including untouched pending ones", () => {
+		// Regression: taskProgressMap skipped pending tasks that had no
+		// evidence, so after a rollback the checkpoint held zero records and
+		// the run's whole history vanished.
+		const tasks = view({ "Task-1": { status: "complete", evidence: "done" } });
+		const map = taskProgressMap(tasks);
+		assert.deepEqual(Object.keys(map).sort(), ["Task-1", "Task-2", "Task-3", "Task-3.1"]);
+		assert.equal(map["Task-1"]?.status, "complete");
+		assert.equal(map["Task-2"]?.status, "pending");
+		assert.equal(map["Task-2"]?.evidence, undefined);
+	});
+
+	it("records a rolled-back task as pending with its retained evidence", () => {
+		const tasks = view(ALL_DONE);
+		auditRollbackSet(tasks, checks(), "VC-001");
+		const map = taskProgressMap(tasks);
+		assert.equal(map["Task-1"]?.status, "pending");
+		assert.equal(map["Task-1"]?.evidence, "edited src/a.ts");
+		assert.equal(map["Task-2"]?.status, "complete");
+	});
+
+	it("round-trips through buildTaskView without loss", () => {
+		const tasks = view(ALL_DONE);
+		auditRollbackSet(tasks, checks(), "VC-001");
+		const rebuilt = buildTaskView(parsePlanTasks(PLAN), taskProgressMap(tasks));
+		assert.equal(rebuilt[0]?.status, "pending");
+		assert.equal(rebuilt[0]?.evidence, "edited src/a.ts");
+	});
+});
+
+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
+		// presolved VC-003 (covering Task-3.1, cascaded open too) must lose
+		// its satisfied state rather than keep claiming the work is verified.
+		const checklist = checks(["VC-001", "VC-003"]);
+		const tasks = view(ALL_DONE);
+		const reopened = auditRollbackSet(tasks, checklist, "VC-002");
+		assert.deepEqual(reopened.sort(), ["Task-2", "Task-3", "Task-3.1"]);
+		const cleared = invalidateChecksForRolledBackTasks(checklist, tasks, reopened);
+		assert.deepEqual(cleared.sort(), ["VC-003"]);
+		assert.equal(checklist.find((c) => c.id === "VC-001")?.done, true, "unaffected check keeps its state");
+	});
+
+	it("clears done on the failing check itself when it is covered by the rollback", () => {
+		const checklist = checks(["VC-002"]);
+		const tasks = view(ALL_DONE);
+		const reopened = auditRollbackSet(tasks, checklist, "VC-002");
+		assert.deepEqual(invalidateChecksForRolledBackTasks(checklist, tasks, reopened).sort(), ["VC-002"]);
+	});
+
+	it("leaves every check done when nothing was reopened", () => {
+		const checklist = checks(["VC-001", "VC-003"]);
+		assert.deepEqual(invalidateChecksForRolledBackTasks(checklist, view(ALL_DONE), []), []);
+		assert.deepEqual(checklist.filter((c) => c.done).map((c) => c.id).sort(), ["VC-001", "VC-003"]);
+	});
+});

package/tests/workflow-state.test.ts

@@ -418,3 +418,68 @@ describe("state machine reducers", () => {
 	});
 });
 
+
+describe("blocking budget persistence", () => {
+	function executingCheckpoint(workdir: string, runId: string) {
+		createCheckpoint(workdir, { runId, originWorkdir: workdir, workdir });
+		// planIdentityOf hashes the file, so it has to exist.
+		const planPath = path.join(workdir, "PLAN_v1.md");
+		fs.writeFileSync(planPath, "# PLAN_v1 - 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 applyExecutionProgress(cp, { tasks: { "Task-1": { status: "pending" } } });
+	}
+
+	it("round-trips the watchdog budget and the undeterminable set", () => {
+		// Without this the budget lived only in memory: a session restart
+		// silently handed a stalled run three fresh rounds.
+		const { workdir, runId } = setupRun("budget-roundtrip");
+		const cp = applyExecutionProgress(executingCheckpoint(workdir, runId), {
+			stallRounds: 2,
+			audit: { rounds: 1, undeterminable: ["VC-002", "VC-003"] },
+		});
+		mutateCheckpoint(workdir, runId, () => cp);
+		const loaded = loadCheckpoint(workdir, runId);
+		assert.ok(loaded.status === "ok");
+		assert.equal(loaded.checkpoint.execution?.stallRounds, 2);
+		assert.deepEqual(loaded.checkpoint.execution?.audit?.undeterminable, ["VC-002", "VC-003"]);
+		assert.equal(loaded.checkpoint.execution?.audit?.rounds, 1);
+	});
+
+	it("loads a checkpoint written before either field existed", () => {
+		// Backward compatibility: the loader whitelists keys, so an older
+		// checkpoint lacking stallRounds / undeterminable must still load.
+		const { workdir, runId } = setupRun("budget-legacy");
+		const cp = executingCheckpoint(workdir, runId);
+		mutateCheckpoint(workdir, runId, () => cp);
+		const filePath = checkpointFilePath(workdir, runId)!;
+		const parsed = JSON.parse(fs.readFileSync(filePath, "utf8")) as Record<string, unknown>;
+		delete (parsed.execution as Record<string, unknown>).stallRounds;
+		delete ((parsed.execution as Record<string, unknown>).audit as Record<string, unknown>).undeterminable;
+		fs.writeFileSync(filePath, JSON.stringify(parsed), "utf8");
+		const loaded = loadCheckpoint(workdir, runId);
+		assert.ok(loaded.status === "ok", "legacy checkpoint still loads");
+		assert.equal(loaded.checkpoint.execution?.stallRounds, undefined);
+		assert.equal(loaded.checkpoint.execution?.audit?.undeterminable, undefined);
+		assert.equal(loaded.checkpoint.execution?.audit?.rounds, 0);
+	});
+
+	it("still rejects an unknown execution key", () => {
+		const { workdir, runId } = setupRun("budget-unknown-key");
+		const cp = executingCheckpoint(workdir, runId);
+		mutateCheckpoint(workdir, runId, () => cp);
+		const filePath = checkpointFilePath(workdir, runId)!;
+		const parsed = JSON.parse(fs.readFileSync(filePath, "utf8")) as Record<string, unknown>;
+		(parsed.execution as Record<string, unknown>).mysteryField = 1;
+		fs.writeFileSync(filePath, JSON.stringify(parsed), "utf8");
+		const loaded = loadCheckpoint(workdir, runId);
+		assert.equal(loaded.status, "corrupt", "the closed schema is still enforced");
+	});
+});

package/tools/execute-plan.ts

@@ -2,7 +2,7 @@
  * `execute_plan` tool — the execution handoff (v0.6.1). On explicit user
  * approval (no Auto-complete) the extension enters task-tree execution mode:
  * progress flows through `plans_update_task`, the dashboard tracks every
- * task, and the completion auditor gates the final pass. Legacy I-### plans
+ * task, and the execution reviewer gates the final pass. Legacy I-### plans
  * parse through the fallback with an upgrade notice.
  */
 
@@ -130,7 +130,7 @@ export async function executeHandoff(
 			: "";
 		approved = await ctx.ui.confirm(
 			"Execute this plan now?",
-			`${planPath}\n${items.length} verification check(s) over ${planTasks.tasks.length} task(s):\n${preview}${legacyNote}\n\nExecution mode enables write access; task progress is reported with the plans_update_task tool and gated by the completion auditor.`,
+			`${planPath}\n${items.length} verification check(s) over ${planTasks.tasks.length} task(s):\n${preview}${legacyNote}\n\nExecution mode enables write access; task progress is reported with the plans_update_task tool and gated by the execution reviewer.`,
 		);
 	}
 	if (!approved) {
@@ -148,7 +148,7 @@ export async function executeHandoff(
 		status: "executing",
 		planPath,
 		itemCount: items.length,
-		message: `${autoNote}Execution approved. ${planTasks.tasks.length} task(s) queued in wave order; report progress with the plans_update_task tool (status + evidence); the completion auditor verifies every check before the run completes.${legacyNote}`,
+		message: `${autoNote}Execution approved. ${planTasks.tasks.length} task(s) queued in wave order; report progress with the plans_update_task tool (status + evidence); the execution reviewer verifies every check before the run completes.${legacyNote}`,
 	};
 }
 
@@ -158,11 +158,18 @@ export async function executeCommand(ctx: ExtensionContext, planPathArg?: string
 	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.8 phase-aware response: a verifying run continues its review loop
+		// (this tool is also the ONLY budget-granting surface at a cap 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.";
 		return {
 			status: "executing",
 			planPath,
 			itemCount: activeExecution.items.length,
-			message: resumed ? "Execution resumed; task progress preserved." : "This plan is already executing.",
+			message: resumed ? statusText : "This plan is already executing.",
 		};
 	}
 	return executeHandoff(ctx, planPathArg);
@@ -173,7 +180,7 @@ export function registerExecutePlanTool(ext: ExtensionAPI): void {
 		name: "execute_plan",
 		label: "Execute Plan",
 		description:
-			"Execution handoff for an accepted plan. Asks the user for explicit approval (never auto-completed), then enters task-tree execution mode: every task's progress is reported via the plans_update_task tool (status + evidence), the task dashboard tracks the tree (Ctrl+Shift+T expands it), and an independent completion auditor verifies the verification checks before the run completes. Legacy I-### plans parse through the compatibility mapping with an upgrade notice. When several runs with plans exist, a run-picker form selects the target run first. Only call after the user chose 'Execute this plan now' at the handoff question.",
+			"Execution handoff for an accepted plan. Asks the user for explicit approval (never auto-completed), then enters task-tree execution mode: every task's progress is reported via the plans_update_task tool (status + evidence), the task dashboard tracks the tree (Ctrl+Shift+T expands it), and an independent execution reviewer verifies the verification checks before the run completes. Legacy I-### plans parse through the compatibility mapping with an upgrade notice. When several runs with plans exist, a run-picker form selects the target run first. Only call after the user chose 'Execute this plan now' at the handoff question.",
 		promptSnippet: "Hand an accepted plan off to the tracked execution loop",
 		parameters: ExecutePlanParams,
 

package/tools/plans.ts

@@ -99,7 +99,7 @@ const PlansParams = Type.Object({
 	runId: Type.Optional(Type.String()),
 	status: Type.Optional(
 		StringEnum(
-			["planning", "accepted", "executing", "stopped", "abandoned", "done"] as const,
+			["planning", "accepted", "executing", "verifying", "stopped", "abandoned", "done"] as const,
 			{ description: "set-status: run lifecycle status" },
 		),
 	),