pi-plans 0.1.0

package/tests/exec.test.ts

@@ -0,0 +1,249 @@
+/** Tests for the execution loop: marker tracking, session restore, completion. */
+
+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 { after, before, describe, it } from "node:test";
+import {
+	applyDoneMarkers,
+	completeExecution,
+	consumePendingPanelSync,
+	executionContextMessage,
+	getExecution,
+	isExecutionComplete,
+	restoreFromSession,
+	startExecution,
+	stopExecution,
+	toggleExecutionPanelView,
+} from "../src/exec.ts";
+import type { CheckItem } from "../src/plan.ts";
+
+interface Recorded {
+	entries: { type: string; customType?: string; data?: unknown }[];
+	messages: { customType: string; content: string }[];
+	status: string | undefined;
+	widget?: { key: string; options?: unknown; factory: any };
+	widgetCalls: number;
+}
+
+interface Harness {
+	pi: any;
+	ctx: any;
+	recorded: Recorded;
+}
+
+function makeHarness(workdir: string): Harness {
+	const recorded: Recorded = { entries: [], messages: [], status: undefined, widgetCalls: 0 };
+	const pi = {
+		appendEntry: (customType: string, data: unknown) => {
+			recorded.entries.push({ type: "custom", customType, data });
+		},
+		sendMessage: (message: { customType: string; content: string }) => {
+			recorded.messages.push(message);
+		},
+	};
+	const ui = {
+		setStatus: (_key: string, value: string | undefined) => {
+			recorded.status = value;
+		},
+		setWidget: (key: string, factory: any, options?: unknown) => {
+			recorded.widgetCalls += 1;
+			if (factory === undefined) {
+				recorded.widget = undefined;
+				return;
+			}
+			recorded.widget = { key, options, factory };
+		},
+		theme: {
+			fg: (_color: string, text: string) => text,
+			strikethrough: (text: string) => `~~${text}~~`,
+		},
+	};
+	const ctx = {
+		cwd: workdir,
+		ui,
+		isIdle: () => true,
+	};
+	return { pi, ctx, recorded };
+}
+
+function items(...ids: string[]): CheckItem[] {
+	return ids.map((id) => ({ id, text: `\`${id}\` demo item`, done: false }));
+}
+
+describe("execution loop", () => {
+	let tmpRoot: string;
+	let counter = 0;
+
+	before(() => {
+		tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-exec-"));
+	});
+
+	after(() => {
+		fs.rmSync(tmpRoot, { recursive: true, force: true });
+	});
+
+	function freshWorkdir(): string {
+		counter += 1;
+		const workdir = path.join(tmpRoot, `repo-${counter}`);
+		fs.mkdirSync(workdir, { recursive: true });
+		return workdir;
+	}
+
+	it("tracks done markers and completes", () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		startExecution(pi, ctx, path.join(workdir, "PLAN_v1.md"), items("VC-001", "VC-002"));
+		assert.ok(recorded.widget);
+		assert.equal(recorded.widget?.key, "pi-plans-execution");
+		assert.deepEqual(recorded.widget?.options, { placement: "belowEditor" });
+		const widget = recorded.widget?.factory(
+			{} as any,
+			{ fg: (_color: string, text: string) => text, strikethrough: (text: string) => `~~${text}~~` },
+		);
+		assert.ok(widget);
+		const rendered = widget.render(80);
+		assert.match(rendered[0] ?? "", /alt\+o/);
+		assert.match(rendered[0] ?? "", /📋 plans 0\/2/);
+
+		toggleExecutionPanelView(pi, ctx);
+		assert.ok(recorded.widget);
+		const expandedWidget = recorded.widget?.factory(
+			{} as any,
+			{ fg: (_color: string, text: string) => text, strikethrough: (text: string) => `~~${text}~~` },
+		);
+		assert.ok(expandedWidget);
+		const expandedLines = expandedWidget.render(80);
+		assert.match(expandedLines.join("\n"), /☐/);
+
+		assert.ok(getExecution());
+		assert.match(executionContextMessage()!, /PI-PLANS EXECUTION/);
+		assert.match(executionContextMessage()!, /VC-001/);
+
+		assert.deepEqual(applyDoneMarkers("progress… [DONE:VC-001] done"), ["VC-001"]);
+		assert.equal(isExecutionComplete(), false);
+		assert.deepEqual(applyDoneMarkers("final: [DONE:VC-002]"), ["VC-002"]);
+		assert.equal(isExecutionComplete(), true);
+
+		completeExecution(pi, ctx);
+		assert.equal(getExecution(), null);
+		assert.ok(recorded.messages.some((message) => message.customType === "pi-plans-complete"));
+	});
+
+	it("restores progress from session entries and rescans messages", () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		const snapshot = {
+			planPath: path.join(workdir, "PLAN_v1.md"),
+			items: items("VC-001", "VC-002"),
+			startedAt: "2026-08-25T00:00:00Z",
+			panel: {
+				expanded: true,
+				baseline: { added: 0, removed: 0, files: 0 },
+				lastSnapshot: { added: 1, removed: 0, files: 1 },
+				touchedPaths: ["src/exec.ts"],
+				itemSummaries: {
+					"VC-001": {
+						summary: { added: 1, removed: 0, files: 1, paths: ["src/exec.ts"] },
+					},
+				},
+			},
+		};
+		fs.writeFileSync(snapshot.planPath, "# plan");
+		const entries = [
+			{ type: "custom", customType: "pi-plans-exec", data: snapshot },
+			{
+				type: "message",
+				message: { role: "assistant", content: [{ type: "text", text: "did [DONE:VC-001]" }] },
+			},
+		];
+		restoreFromSession(pi, ctx, entries as any);
+		const execution = getExecution();
+		assert.ok(execution);
+		assert.ok(recorded.widget);
+		const widget = recorded.widget?.factory(
+			{} as any,
+			{ fg: (_color: string, text: string) => text, strikethrough: (text: string) => `~~${text}~~` },
+		);
+		assert.ok(widget);
+		const rendered = widget.render(80);
+		assert.match(rendered.join("\n"), /☑/);
+		assert.match(rendered.join("\n"), /\+1/);
+
+		const clearedEntries = [...entries, { type: "custom", customType: "pi-plans-exec-cleared", data: {} }];
+		restoreFromSession(pi, ctx, clearedEntries as any);
+		assert.equal(getExecution(), null);
+	});
+
+	it("ignores restore when the plan file vanished", () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx } = makeHarness(workdir);
+		const entries = [
+			{
+				type: "custom",
+				customType: "pi-plans-exec",
+				data: {
+					planPath: path.join(workdir, "missing-plan.md"),
+					items: items("VC-001"),
+					startedAt: "2026-08-25T00:00:00Z",
+				},
+			},
+		];
+		restoreFromSession(pi, ctx, entries as any);
+		assert.equal(getExecution(), null);
+	});
+
+	it("stop clears execution", () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx } = makeHarness(workdir);
+		startExecution(pi, ctx, path.join(workdir, "PLAN_v1.md"), items("VC-001"));
+		stopExecution(pi, ctx, "test");
+		assert.equal(getExecution(), null);
+	});
+
+	it("keeps the status bar count-free while executing and points at the panel", () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		startExecution(pi, ctx, path.join(workdir, "PLAN_v2.md"), items("VC-001", "VC-002"));
+
+		// The below-editor panel owns progress; the status item must be cleared,
+		// never carrying a duplicate “📋 plans x/y” count (regression: double display).
+		assert.equal(recorded.status, undefined);
+
+		const start = recorded.messages.find((message) => message.customType === "pi-plans-exec-start");
+		assert.ok(start);
+		assert.match(start.content, /Progress appears below the editor/);
+		assert.doesNotMatch(start.content, /footer/);
+
+		applyDoneMarkers("[DONE:VC-001]");
+		completeExecution(pi, ctx);
+		assert.equal(getExecution(), null);
+	});
+
+	it("defers persistence and widget churn when toggling mid-turn", () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		startExecution(pi, ctx, path.join(workdir, "PLAN_v3.md"), items("VC-001", "VC-002"));
+
+		const entriesBefore = recorded.entries.length;
+		const factoriesBefore = recorded.widgetCalls;
+
+		// Mid-turn: flip must be pure memory — no session writes, no re-register.
+		(ctx as any).isIdle = () => false;
+		assert.equal(toggleExecutionPanelView(pi, ctx), true);
+		assert.equal(recorded.entries.length, entriesBefore, "busy toggle appended a session entry");
+		assert.equal(recorded.widgetCalls, factoriesBefore, "busy toggle re-registered the widget");
+		assert.equal(consumePendingPanelSync(), true, "expected a pending panel sync marker");
+		assert.equal(consumePendingPanelSync(), false, "marker should be consumed exactly once");
+
+		// Back to idle: the next toggle persists and syncs, but still reuses the
+		// already-registered factory (cache-drop instead of teardown).
+		ctx.isIdle = () => true;
+		assert.equal(toggleExecutionPanelView(pi, ctx), false);
+		assert.ok(recorded.entries.length > entriesBefore, "idle toggle did not persist");
+		assert.equal(recorded.widgetCalls, factoriesBefore, "idle toggle replaced the widget factory");
+
+		stopExecution(pi, ctx, "test-done");
+	});
+});

package/tests/execution-panel.test.ts

@@ -0,0 +1,198 @@
+import * as assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { after, before, describe, it } from "node:test";
+import {
+	captureRepoSnapshot,
+	completeCompletedItems,
+	createExecutionPanelState,
+	refreshExecutionPanel,
+	restorePanelState,
+	subtractSnapshots,
+	toggleExpanded,
+	truncateAnsi,
+	visibleWidth,
+} from "../src/execution-panel.ts";
+
+function initGitRepo(dir: string): void {
+	fs.mkdirSync(dir, { recursive: true });
+	const git = (args: string[]): void => {
+		const result = spawnSync("git", args, { cwd: dir, stdio: "ignore" });
+		if (result.status !== 0) {
+			throw new Error(`git ${args.join(" ")} failed`);
+		}
+	};
+	git(["init"]);
+	git(["config", "user.name", "Pi Plans Test"]);
+	git(["config", "user.email", "test@example.com"]);
+	fs.writeFileSync(path.join(dir, "tracked.txt"), "line 1\n");
+	git(["add", "tracked.txt"]);
+	git(["commit", "-m", "baseline"]);
+}
+
+describe("execution panel helpers", () => {
+	let tmpRoot: string;
+	let repo: string;
+
+	before(() => {
+		tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-panel-"));
+		repo = path.join(tmpRoot, "repo");
+		initGitRepo(repo);
+	});
+
+	after(() => {
+		fs.rmSync(tmpRoot, { recursive: true, force: true });
+	});
+
+	it("captures diff snapshots and restores panel state", () => {
+		const baseline = captureRepoSnapshot(repo);
+		fs.appendFileSync(path.join(repo, "tracked.txt"), "line 2\n");
+		fs.writeFileSync(path.join(repo, "new.txt"), "new file\n");
+		const current = captureRepoSnapshot(repo);
+		const delta = subtractSnapshots(baseline, current);
+		assert.ok(delta.added >= 1);
+		assert.ok(delta.files >= 1);
+
+		const panel = createExecutionPanelState();
+		panel.expanded = true;
+		panel.baseline = baseline;
+		panel.lastSnapshot = current;
+		panel.touchedPaths = ["tracked.txt", "new.txt"];
+		panel.itemSummaries = {
+			"VC-001": {
+				summary: {
+					added: 1,
+					removed: 0,
+					files: 2,
+					paths: ["tracked.txt", "new.txt"],
+				},
+			},
+		};
+		const restored = restorePanelState(panel);
+		assert.ok(restored);
+		assert.equal(restored?.expanded, true);
+		assert.equal(restored?.baseline?.added, baseline.added);
+		assert.equal(restored?.itemSummaries["VC-001"]?.summary?.files, 2);
+		assert.deepEqual(restored?.touchedPaths, ["tracked.txt", "new.txt"]);
+	});
+
+	it("records completed-item summaries with touched paths", () => {
+		fs.writeFileSync(path.join(repo, "tracked.txt"), "line 1\n");
+		fs.rmSync(path.join(repo, "new.txt"), { force: true });
+		const baseline = captureRepoSnapshot(repo);
+		fs.appendFileSync(path.join(repo, "tracked.txt"), "line 2\n");
+		fs.writeFileSync(path.join(repo, "new.txt"), "new file\n");
+
+		const execution = {
+			planPath: path.join(repo, "PLAN_v1.md"),
+			items: [{ id: "VC-001", text: "`VC-001` demo item", done: true }],
+			panel: createExecutionPanelState(),
+		};
+		execution.panel.baseline = baseline;
+		execution.panel.lastSnapshot = baseline;
+		execution.panel.touchedPaths = ["tracked.txt", "new.txt"];
+
+		const summary = completeCompletedItems(execution as any, repo, ["VC-001"]);
+		assert.ok(summary);
+		assert.ok((summary?.added ?? 0) >= 1);
+		assert.ok((summary?.files ?? 0) >= 1);
+		assert.deepEqual(execution.panel.itemSummaries["VC-001"]?.summary?.paths, ["tracked.txt", "new.txt"]);
+	});
+
+	it("toggles expanded state", () => {
+		const execution = { planPath: path.join(repo, "PLAN_v1.md"), items: [] as any[], panel: createExecutionPanelState() };
+		assert.equal(toggleExpanded(execution), true);
+		assert.equal(toggleExpanded(execution), false);
+	});
+
+	it("reuses one registered widget factory across refreshes", () => {
+		const execution: any = {
+			planPath: "/tmp/PLAN_v1.md",
+			items: [{ id: "VC-001", text: "item", done: false }],
+			panel: createExecutionPanelState(),
+		};
+		const factories: unknown[] = [];
+		const theme = { fg: (_color: string, text: string) => `\u001b[38;5;2m${text}\u001b[39m`, strikethrough: (text: string) => text };
+		const ctx = { ui: { setWidget: (_key: string, factory: any) => void factories.push(factory) } } as any;
+
+		refreshExecutionPanel(ctx, execution);
+		refreshExecutionPanel(ctx, execution); // second pass must only invalidate
+		assert.equal(factories.length, 1, "factory re-registered on refresh");
+
+		const widget = (factories[0] as any)({}, theme);
+		assert.equal(widget.render(80).length, 1, "collapsed render should be a single line");
+
+		toggleExpanded(execution);
+		refreshExecutionPanel(ctx, execution);
+		assert.equal(factories.length, 1);
+		assert.ok(widget.render(80).length > 1, "invalidate did not pick up expanded state");
+
+		// Clearing releases the slot so a future run registers afresh.
+		refreshExecutionPanel(ctx, null);
+		refreshExecutionPanel(ctx, execution);
+		assert.equal(factories.length, 3); // #2 was the explicit clear (undefined)
+	});
+});
+
+describe("execution panel width safety", () => {
+	const styledTheme = {
+		fg: (_color: string, text: string) => `\u001b[38;5;2m${text}\u001b[39m`,
+		strikethrough: (text: string) => text,
+	};
+
+	it("measures CJK code points as double width and zero-width runs as none", () => {
+		assert.equal(visibleWidth("新的"), 4);
+		assert.equal(visibleWidth("菜单配置"), 8);
+		assert.equal(visibleWidth("\uFF46\uFF55\uFF4C\uFF4C"), 8); // fullwidth “full”
+		assert.equal(visibleWidth("e\u0301"), 1); // combining acute
+		assert.equal(visibleWidth("\u2764\uFE0F"), 1); // variation selector
+		assert.equal(visibleWidth("a\u001b[31mbc\u001b[0m"), 3); // ANSI ignored
+	});
+
+	it("truncates styled CJK lines within the requested width", () => {
+		const cjk = "新的 Nemotron AIME 配置和批量入口能验证 seed vector、model pin、arm set 和 500 budget；" +
+			"evidence: pr… 后续还有很长的中文描述需要被安全截断。".repeat(6);
+		for (const width of [20, 40, 138]) {
+			const line = truncateAnsi(styledTheme.fg("accent", cjk), width);
+			assert.ok(
+				visibleWidth(line) <= width,
+				`width ${width}: rendered ${visibleWidth(line)} columns`,
+			);
+		}
+	});
+
+	it("renders every expanded checklist line inside the terminal width", () => {
+		const execution: any = {
+			planPath: "/tmp/PLAN_v1.md",
+			items: [
+				{
+					id: "VC-001",
+					// Mirrors the crash-log line that rendered at 155 columns in a 138-column terminal.
+					text: "`VC-001` covers `I-001` 和 `I-003`；pass condition: 新的 Nemotron AIME 配置和批量入口能验证 seed vector、model pin、arm set 和 500 budget；evidence: pr…",
+					done: false,
+				},
+				{ id: "VC-002", text: "`VC-002` plain ascii item that is also far too long to fit one line ".repeat(4), done: false },
+			],
+			panel: createExecutionPanelState(),
+		};
+		toggleExpanded(execution);
+
+		let factory: ((tui: unknown, theme: unknown) => any) | undefined;
+		refreshExecutionPanel({ ui: { setWidget: (_key: string, f: any) => void (factory = f) } } as any, execution);
+		const widget = factory!({}, styledTheme);
+
+		let sawEllipsis = false;
+		for (const width of [20, 40, 80, 138]) {
+			for (const line of widget.render(width)) {
+				if (line.endsWith("…") || line.includes("…\u001b[0m")) sawEllipsis = true;
+				assert.ok(
+					visibleWidth(line) <= width,
+					`width ${width}: rendered ${visibleWidth(line)} columns: ${JSON.stringify(line.slice(0, 60))}`,
+				);
+			}
+		}
+		assert.ok(sawEllipsis, "expected at least one truncated line with an ellipsis");
+	});
+});

package/tests/guard.test.ts

@@ -0,0 +1,70 @@
+/** Tests for the planning write guard. */
+
+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 { after, before, describe, it } from "node:test";
+import { planningWriteBlockReason } from "../src/guard.ts";
+import { initState, setRunStatus, startRun } from "../src/state.ts";
+
+let tmpRoot: string;
+
+before(() => {
+	tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-guard-"));
+});
+
+after(() => {
+	fs.rmSync(tmpRoot, { recursive: true, force: true });
+});
+
+describe("planning write guard", () => {
+	it("blocks source writes during planning, allows artifacts, lifts after handoff", () => {
+		const workdir = path.join(tmpRoot, "repo");
+		fs.mkdirSync(workdir);
+		initState(workdir);
+		const { run } = startRun(workdir, {
+			topic: "guard check",
+			skill: "plan-small",
+			requestText: "x",
+		});
+
+		const block = planningWriteBlockReason({ workdir, toolName: "write", rawPath: "src/main.ts" });
+		assert.ok(block);
+		assert.ok(block.includes("read-only outside planning artifacts"));
+
+		// Artifact writes are allowed (absolute artifact_dir and relative path into it).
+		assert.equal(
+			planningWriteBlockReason({ workdir, toolName: "write", rawPath: path.join(run.artifact_dir, "PLAN_v1.md") }),
+			null,
+		);
+		const relArtifact = path.join(path.relative(workdir, run.artifact_dir), "DECISIONS.md");
+		assert.equal(
+			planningWriteBlockReason({ workdir, toolName: "edit", rawPath: relArtifact }),
+			null,
+		);
+		// Another run's artifact directory is still blocked (per-run boundary).
+		assert.ok(planningWriteBlockReason({ workdir, toolName: "write", rawPath: "./docs/pi-plans/other-run/PLAN_v1.md" }));
+
+		// State dir writes are allowed; @-prefixed paths are normalized.
+		assert.equal(
+			planningWriteBlockReason({ workdir, toolName: "write", rawPath: ".git/pi_plans/tmp/note" }),
+			null,
+		);
+		assert.ok(planningWriteBlockReason({ workdir, toolName: "write", rawPath: "@/src/main.ts" }));
+
+		// Read tools are never guarded.
+		assert.equal(planningWriteBlockReason({ workdir, toolName: "read", rawPath: "src/main.ts" }), null);
+
+		// Once the run leaves planning/accepted, the guard lifts.
+		setRunStatus(workdir, run.run_id, "executing");
+		assert.equal(planningWriteBlockReason({ workdir, toolName: "write", rawPath: "src/main.ts" }), null);
+	});
+
+	it("is inactive without an active run", () => {
+		const workdir = path.join(tmpRoot, "no-run");
+		fs.mkdirSync(workdir);
+		initState(workdir);
+		assert.equal(planningWriteBlockReason({ workdir, toolName: "write", rawPath: "src/main.ts" }), null);
+	});
+});

package/tests/plan.test.ts

@@ -0,0 +1,105 @@
+/** Tests for plan artifact parsing (verifier checklist + done markers). */
+
+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 { after, before, describe, it } from "node:test";
+import { latestPlanVersion, nextPlanVersionPath, parseChecklist, scanDoneMarkers } from "../src/plan.ts";
+
+const PLAN = `# PLAN_v1 - demo
+
+## Goals
+
+- \`G-001\`: Ship it.
+
+## Verifier Checklist
+
+- [ ] \`VC-001\` covers \`I-001\`; pass condition: tests green; evidence: pytest output; metric: 100% pass.
+- [x] \`VC-002\` covers \`I-002\`; pass condition: no lint errors; evidence: run ruff; metric: zero findings.
+- not a checklist line
+- [ ] \`VC-003\` covers \`I-003\`; pass condition: manual check; metric: not quantified.
+
+## Risks And Mitigations
+
+- \`Risk-001\`: something.
+`;
+
+describe("plan parsing", () => {
+	it("parses checklist items with ids and done state", () => {
+		const items = parseChecklist(PLAN);
+		assert.equal(items.length, 3);
+		assert.equal(items[0]?.id, "VC-001");
+		assert.equal(items[0]?.done, false);
+		assert.equal(items[1]?.id, "VC-002");
+		assert.equal(items[1]?.done, true);
+		assert.equal(items[2]?.id, "VC-003");
+	});
+
+	it("returns empty without a checklist section", () => {
+		assert.equal(parseChecklist("# no checklist here\n\n- [ ] `VC-001` orphan\n").length, 0);
+	});
+
+	it("scans done markers", () => {
+		assert.deepEqual(scanDoneMarkers("done [DONE:VC-001] and [DONE:VC-003], plus [DONE:VC-001] again"), [
+			"VC-001",
+			"VC-003",
+			"VC-001",
+		]);
+		assert.deepEqual(scanDoneMarkers("nothing here"), []);
+	});
+});
+
+describe("latestPlanVersion", () => {
+	let dir: string;
+
+	before(() => {
+		dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-plan-"));
+		fs.writeFileSync(path.join(dir, "PLAN_v1.md"), "v1");
+		fs.writeFileSync(path.join(dir, "PLAN_v10.md"), "v10");
+		fs.writeFileSync(path.join(dir, "PLAN_v2.md"), "v2");
+		fs.writeFileSync(path.join(dir, "notes.md"), "notes");
+	});
+
+	after(() => {
+		fs.rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("picks the highest version numerically", () => {
+		const latest = latestPlanVersion(dir);
+		assert.equal(latest?.version, 10);
+		assert.equal(latest?.path, path.join(dir, "PLAN_v10.md"));
+	});
+
+	it("returns null for missing dirs", () => {
+		assert.equal(latestPlanVersion(path.join(dir, "nope")), null);
+	});
+});
+
+describe("nextPlanVersionPath", () => {
+	let dir: string;
+
+	before(() => {
+		dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-next-"));
+	});
+
+	after(() => {
+		fs.rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("increments from the highest existing version", () => {
+		fs.writeFileSync(path.join(dir, "PLAN_v1.md"), "v1");
+		fs.writeFileSync(path.join(dir, "PLAN_v4.md"), "v4");
+		const next = nextPlanVersionPath(dir);
+		assert.equal(next.version, 5);
+		assert.equal(next.path, path.join(dir, "PLAN_v5.md"));
+	});
+
+	it("starts at v1 for empty dirs", () => {
+		const empty = path.join(dir, "empty");
+		fs.mkdirSync(empty, { recursive: true });
+		const next = nextPlanVersionPath(empty);
+		assert.equal(next.version, 1);
+		assert.equal(next.path, path.join(empty, "PLAN_v1.md"));
+	});
+});

package/tests/refine-prompts.test.ts

@@ -0,0 +1,49 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { buildCriticizerTask, buildReviewerTask, reviewerLanes } from "../src/refine-prompts.ts";
+
+describe("reviewerLanes", () => {
+	it("uses stable lane ids for the big-plan fanout", () => {
+		assert.deepEqual(reviewerLanes(3).map((lane) => lane.id), ["correctness", "ordering", "verification"]);
+	});
+
+	it("falls back to a general lane for one-off review passes", () => {
+		assert.deepEqual(reviewerLanes(1), [{ id: "general", lens: null }]);
+	});
+});
+
+describe("buildReviewerTask", () => {
+	it("includes a compact read-only contract and lane emphasis", () => {
+		const text = buildReviewerTask({
+			planText: "# plan",
+			planPath: "/tmp/PLAN_v1.md",
+			lens: "verification rigor",
+			focus: "check the checklist",
+			context: "repo evidence",
+		});
+
+		assert.match(text, /Goal: review the plan against the repository\./);
+		assert.match(text, /Target: \/tmp\/PLAN_v1\.md/);
+		assert.match(text, /Authority boundary: read-only analysis only\./);
+		assert.match(text, /Review lens: verification rigor\./);
+		assert.match(text, /Specific concerns from the main agent: check the checklist/);
+		assert.match(text, /Context: repo evidence/);
+		assert.match(text, /Surface at most five high-priority findings/);
+	});
+});
+
+describe("buildCriticizerTask", () => {
+	it("asks for short adversarial questions only", () => {
+		const text = buildCriticizerTask({
+			planText: "# plan",
+			planPath: "/tmp/PLAN_v1.md",
+			focus: "challenge the deployment step",
+		});
+
+		assert.match(text, /Goal: stress-test the plan's assumptions\./);
+		assert.match(text, /Authority boundary: read-only analysis only\./);
+		assert.match(text, /Specific concerns from the main agent: challenge the deployment step/);
+		assert.match(text, /at most five adaptive questions/);
+		assert.match(text, /never rewrite the plan/);
+	});
+});