pi-plans 0.5.7 → 0.7.0

package/tests/multi-run.test.ts

@@ -0,0 +1,184 @@
+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 {
+	initState,
+	listRuns,
+	newestNonTerminalRun,
+	latestRun,
+	readActive,
+	setRunStatus,
+	startRun,
+	TERMINAL_RUN_STATUSES,
+} from "../src/state.ts";
+import { resolveActiveRun, resetRunBindingForTests } from "../src/run-context.ts";
+import { planningWriteBlockReason } from "../src/guard.ts";
+import { executionCandidates, abandonCandidates, runPickerLabel } from "../src/run-picker.ts";
+import { subagentChildEnv } from "../src/subagent.ts";
+import {
+	getExecution,
+	startExecution,
+	stopExecution,
+} from "../src/exec.ts";
+
+let tmpRoot: string;
+let counter = 0;
+
+before(() => {
+	tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-multi-run-"));
+});
+
+after(() => {
+	fs.rmSync(tmpRoot, { recursive: true, force: true });
+	resetRunBindingForTests();
+	delete process.env.PI_PLANS_EXECUTOR;
+	delete process.env.PI_PLANS_RUN_ID;
+});
+
+function freshWorkdir(): string {
+	counter += 1;
+	const workdir = path.join(tmpRoot, `repo-${counter}`);
+	fs.mkdirSync(workdir, { recursive: true });
+	return workdir;
+}
+
+function fakeCtx(workdir: string, extra: Record<string, unknown> = {}): any {
+	return {
+		cwd: workdir,
+		sessionManager: { id: `session-${counter}` },
+		ui: {
+			setStatus: () => {},
+			notify: () => {},
+			theme: { fg: (_k: string, t: string) => t, bold: (t: string) => t },
+		},
+		mode: "noninteractive",
+		...extra,
+	};
+}
+
+describe("run registry (v0.6.0)", () => {
+	it("listRuns sorts newest-first, skips corrupt run dirs, and survives partial state", () => {
+		const workdir = freshWorkdir();
+		initState(workdir);
+		const first = startRun(workdir, { topic: "first", skill: "plan-small", requestText: "a" }).run;
+		const second = startRun(workdir, { topic: "second", skill: "plan-big", requestText: "b" }).run;
+		// Corrupt a third run's run.json: the scan must skip it, never throw.
+		const stateRoot = path.join(workdir, ".git", "pi-plans");
+		fs.mkdirSync(path.join(stateRoot, "runs", "corrupt-run-id"), { recursive: true });
+		fs.writeFileSync(path.join(stateRoot, "runs", "corrupt-run-id", "run.json"), "{ broken", "utf8");
+
+		const runs = listRuns(workdir);
+		const ids = runs.map((run) => run.run_id);
+		assert.equal(ids.includes(first.run_id), true);
+		assert.equal(ids.includes(second.run_id), true);
+		assert.equal(ids.includes("corrupt-run-id"), false);
+		assert.equal(runs.indexOf(runs.find((r) => r.run_id === second.run_id)!), 0, "newest first");
+		assert.equal(runs[0]!.skill, "plan-big");
+	});
+
+	it("start-run no longer writes the shared active.json pointer", () => {
+		const workdir = freshWorkdir();
+		initState(workdir);
+		startRun(workdir, { topic: "pointerless", skill: "plan-small", requestText: "x" });
+		const activePath = path.join(workdir, ".git", "pi-plans", "active.json");
+		assert.equal(fs.existsSync(activePath), false, "registry workdirs keep no shared pointer");
+	});
+
+	it("readActive = newest NON-terminal run; null when every run is terminal", () => {
+		const workdir = freshWorkdir();
+		initState(workdir);
+		const only = startRun(workdir, { topic: "only", skill: "plan-small", requestText: "x" }).run;
+		assert.equal(readActive(workdir)?.run_id, only.run_id);
+		setRunStatus(workdir, only.run_id, "done");
+		assert.equal(readActive(workdir), null, "terminal-only workdir resolves no active run");
+		assert.equal(newestNonTerminalRun(workdir), null);
+		assert.equal(latestRun(workdir)?.run_id, only.run_id, "display-only latest keeps terminal runs");
+	});
+
+	it("readActive falls back to a legacy active.json only when the scan finds nothing", () => {
+		const workdir = freshWorkdir();
+		initState(workdir);
+		const stateRoot = path.join(workdir, ".git", "pi-plans");
+		fs.mkdirSync(path.join(stateRoot, "runs", "legacy-run"), { recursive: true });
+		// No run.json at all → scan finds nothing → legacy pointer honored.
+		const activePath = path.join(stateRoot, "active.json");
+		fs.writeFileSync(
+			activePath,
+			JSON.stringify({ run_id: "legacy-run", run_dir: path.join(stateRoot, "runs", "legacy-run"), artifact_dir: path.join(workdir, "docs") }),
+			"utf8",
+		);
+		assert.equal(readActive(workdir)?.run_id, "legacy-run");
+		fs.rmSync(activePath);
+		assert.equal(readActive(workdir), null);
+	});
+
+	it("parallel start-runs in one workdir get distinct ids and dirs", () => {
+		const workdir = freshWorkdir();
+		initState(workdir);
+		const a = startRun(workdir, { topic: "same-topic", skill: "plan-small", requestText: "x" }).run;
+		const b = startRun(workdir, { topic: "same-topic", skill: "plan-small", requestText: "y" }).run;
+		assert.notEqual(a.run_id, b.run_id);
+		assert.notEqual(a.artifact_dir, b.artifact_dir);
+		assert.equal(listRuns(workdir).length, 2);
+	});
+});
+
+describe("multi-run resolution and guard", () => {
+
+
+});
+
+describe("run picker candidates", () => {
+	it("executionCandidates needs a plan file and non-terminal status; abandonCandidates takes all non-terminal", () => {
+		const workdir = freshWorkdir();
+		initState(workdir);
+		const withPlan = startRun(workdir, { topic: "with-plan", skill: "plan-small", requestText: "a" }).run;
+		fs.writeFileSync(path.join(withPlan.artifact_dir, "PLAN_v1.md"), "# p\n\n## Verifier Checklist\n\n- [ ] `VC-001` x\n");
+		startRun(workdir, { topic: "no-plan", skill: "plan-small", requestText: "b" });
+		const done = startRun(workdir, { topic: "done", skill: "plan-small", requestText: "c" }).run;
+		setRunStatus(workdir, done.run_id, "done");
+
+		const exec = executionCandidates(workdir);
+		assert.deepEqual(exec.map((run) => run.topic), ["with-plan"]);
+		const abandon = abandonCandidates(workdir);
+		assert.equal(abandon.length, 2, "with-plan + no-plan are abandonable; done is not");
+		assert.equal(abandon.every((run) => !TERMINAL_RUN_STATUSES.has(run.status)), true);
+	});
+
+	it("labels are descriptive, width-fitted, and mark the recommended run", () => {
+		const run = {
+			run_id: "20260926T000000Z-demo",
+			topic: "demo-topic",
+			skill: "plan-big",
+			status: "planning",
+			created_at: "2026-09-26T00:00:00Z",
+			updated_at: "2026-09-26T00:00:00Z",
+			artifact_dir: "/tmp/x",
+		};
+		const label = runPickerLabel(run, true);
+		assert.match(label, /^★ demo-topic · planning · plan-big · 2026-09-26T00:00:00Z/);
+		const long = { ...run, topic: "x".repeat(200) };
+		assert.ok(runPickerLabel(long, false).length <= 200, "long topics truncate");
+	});
+});
+
+describe("subagent child env markers", () => {
+	it("refiner (default) sets PI_PLANS_REFINER and strips executor keys", () => {
+		const env = subagentChildEnv({}, { PI_PLANS_EXECUTOR: "1", PI_PLANS_RUN_ID: "r", PATH: "/bin" });
+		assert.equal(env.PI_PLANS_REFINER, "1");
+		assert.equal(env.PI_PLANS_EXECUTOR, undefined);
+		assert.equal(env.PI_PLANS_RUN_ID, undefined);
+	});
+
+
+	it("none clears every marker", () => {
+		const env = subagentChildEnv({ envMarker: "none" }, { PI_PLANS_REFINER: "1", PI_PLANS_EXECUTOR: "1", PI_PLANS_RUN_ID: "r" });
+		assert.equal(env.PI_PLANS_REFINER, undefined);
+		assert.equal(env.PI_PLANS_EXECUTOR, undefined);
+		assert.equal(env.PI_PLANS_RUN_ID, undefined);
+	});
+});
+

package/tests/plan.test.ts

@@ -5,7 +5,7 @@ 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, parseImplItems, resolveImplStatuses, scanCurrentIMarkers, scanDoneMarkers, scanImplMarkers, shortImplDescription, extractCoverage, resolveCurrentI, inferCurrentI } from "../src/plan.ts";
+import { latestPlanVersion, nextPlanVersionPath, parseChecklist, parseImplItems, extractCoverage, parsePlanTasks, resolveTaskWaves, extractTaskCoverage, normalizeTaskId, checklistHeaderName, lintPlanTasks } from "../src/plan.ts";
 
 const PLAN = `# PLAN_v1 - demo
 
@@ -40,14 +40,6 @@ describe("plan parsing", () => {
 		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", () => {
@@ -135,64 +127,149 @@ describe("implementation items", () => {
 		assert.equal(parseImplItems("# no items here\n- `I-001`: orphan\n").length, 0);
 	});
 
-	it("shortens descriptions at sentence or semicolon boundaries and caps length", () => {
-		assert.equal(shortImplDescription("Add helpers; evaluate percent. Then more."), "Add helpers");
-		assert.equal(shortImplDescription("First sentence. Second one."), "First sentence.");
-		const long = "x".repeat(120);
-		assert.equal(shortImplDescription(long).length, 80);
-		assert.match(shortImplDescription(long), /…$/);
-	});
 
 	it("extracts coverage refs before the first semicolon only", () => {
 		assert.deepEqual(extractCoverage("`VC-001` covers `I-001` and `I-002`; pass: `I-003` mentioned late"), ["I-001", "I-002"]);
 		assert.deepEqual(extractCoverage("no coverage clause here"), []);
 	});
 
-	it("parses and resolves current-I markers without changing progress marker states", () => {
-		const implItems = [{ id: "I-001", text: "first" }, { id: "I-002", text: "second" }];
-		assert.deepEqual(scanCurrentIMarkers("[I-001:current] [I-999:current] [I-002:current]"), [
-			{ id: "I-001" },
-			{ id: "I-999" },
-			{ id: "I-002" },
-		]);
-		assert.equal(resolveCurrentI(implItems, scanCurrentIMarkers("[I-999:current] [I-002:current]")), "I-002");
-		assert.equal(inferCurrentI(implItems, [], undefined), "I-001");
-	});
-	it("scans impl markers", () => {
-		assert.deepEqual(scanImplMarkers("[I-001:implemented] then [I-002:validating] and [I-003:done]"), [
-			{ id: "I-001", state: "implemented" },
-			{ id: "I-002", state: "validating" },
-		]);
-	});
-
-	it("resolves the status matrix with vc-passed > marker > derivation", () => {
-		const items = parseChecklist(IMPL_PLAN);
-		const implItems = parseImplItems(IMPL_PLAN);
-
-		// No markers, nothing done: frontier I-001 implementing, I-002 pending.
-		assert.deepEqual(resolveImplStatuses(implItems, items, undefined), {
-			"I-001": "implementing",
-			"I-002": "pending",
-		});
-
-		// Explicit marker wins over derivation.
-		assert.deepEqual(resolveImplStatuses(implItems, items, { "I-002": "implemented" }), {
-			"I-001": "implementing",
-			"I-002": "implemented",
-		});
-
-		// Some covering VC done without a marker: deriving validating.
-		items[1]!.done = true;
-		assert.deepEqual(resolveImplStatuses(implItems, items, {}), {
-			"I-001": "implementing",
-			"I-002": "validating",
-		});
-
-		// All covering VCs done → vc-passed beats the marker.
-		items[0]!.done = true;
-		assert.deepEqual(resolveImplStatuses(implItems, items, { "I-002": "validating" }), {
-			"I-001": "vc-passed",
-			"I-002": "vc-passed",
-		});
+
+});
+
+const TASK_PLAN = `# PLAN_v1 - demo
+
+## Tasks
+
+- Task-1: 解析器主体 — files: src/plan.ts; wave: 1
+- Task-2: 单测 — files: tests/plan.test.ts; wave: 1
+- Task-3: 执行核心 — deps: Task-1，Task-2; files: src/exec.ts、src/tasks.ts; wave: 2
+  - Task-3.1: 注入骨架 — deps: Task-1; files: src/exec.ts
+  - Task-3.2: 状态机 — files: src/tasks.ts
+- Task-4: 文档 — deps: Task-3
+
+### Execution Waves
+
+- wave 1: Task-1, Task-2 — 文件集不相交可并行
+- wave 2: Task-3 — 依赖前波
+- wave 3: Task-4 — 收尾
+
+## Verification Checks
+
+- [ ] \`VC-001\` covers \`Task-1\` and \`Task-2\`; pass condition: 解析单测全绿; metric: 100%。
+- [x] \`VC-002\` covers \`Task-3.1\`; pass condition: 注入正确; metric: 通过。
+
+## Risks And Mitigations
+`;
+
+describe("task-tree parsing (v0.6.1)", () => {
+	it("parses tasks with inline fields, tolerating full-width separators", () => {
+		const parsed = parsePlanTasks(TASK_PLAN);
+		assert.equal(parsed.legacy, false);
+		assert.equal(parsed.tasks.length, 4);
+		const t3 = parsed.tasks[2];
+		assert.equal(t3?.id, "Task-3");
+		assert.deepEqual(t3?.deps, ["Task-1", "Task-2"]);
+		assert.deepEqual(t3?.files, ["src/exec.ts", "src/tasks.ts"]);
+		assert.equal(t3?.wave, 2);
+		assert.equal(t3?.children.length, 2);
+		assert.equal(t3?.children[0]?.id, "Task-3.1");
+		assert.deepEqual(t3?.children[0]?.deps, ["Task-1"]);
+		const t4 = parsed.tasks[3];
+		assert.equal(t4?.deps.length, 1);
+		assert.equal(t4?.wave, undefined);
+	});
+
+	it("parses the Execution Waves subsection with rationale", () => {
+		const parsed = parsePlanTasks(TASK_PLAN);
+		assert.equal(parsed.waves.length, 3);
+		assert.deepEqual(parsed.waves[0], { wave: 1, taskIds: ["Task-1", "Task-2"], rationale: "文件集不相交可并行" });
+		assert.deepEqual(parsed.waves[1]?.taskIds, ["Task-3"]);
+	});
+
+	it("accepts the canonical and legacy checklist headers, and task coverage", () => {
+		assert.equal(checklistHeaderName(TASK_PLAN), "Verification Checks");
+		const items = parseChecklist(TASK_PLAN);
+		assert.equal(items.length, 2);
+		assert.equal(items[1]?.done, true);
+		assert.deepEqual(extractTaskCoverage(items[0]?.text ?? ""), ["Task-1", "Task-2"]);
+		assert.deepEqual(extractTaskCoverage("`VC-009` covers `I-002` and `I-003`; pass: ok"), ["Task-2", "Task-3"]);
+		assert.equal(checklistHeaderName("## Verifier Checklist\n"), "Verifier Checklist");
+		assert.equal(parseChecklist("## Verifier Checklist\n- [x] \`VC-001\` covers \`I-001\`; ok\n").length, 1);
+	});
+
+	it("falls back to legacy I-### parsing with normalized ids", () => {
+		const parsed = parsePlanTasks("## Implementation Items\n\n- \`I-001\`: First.\n- \`I-002\`：Second.\n");
+		assert.equal(parsed.legacy, true);
+		assert.deepEqual(parsed.tasks.map((t) => t.id), ["Task-1", "Task-2"]);
+		assert.equal(parsed.tasks[0]?.title, "First.");
+		assert.equal(parsed.waves.length, 0);
+		// No Tasks section and no Implementation Items → empty non-legacy model.
+		const empty = parsePlanTasks("# nothing\n");
+		assert.equal(empty.tasks.length, 0);
+		assert.equal(empty.legacy, false);
+	});
+
+	it("resolves effective waves: subsection > inline > derived from deps", () => {
+		const parsed = parsePlanTasks(TASK_PLAN);
+		const waves = resolveTaskWaves(parsed);
+		assert.equal(waves.get("Task-1"), 1);
+		assert.equal(waves.get("Task-2"), 1);
+		assert.equal(waves.get("Task-3"), 2);
+		// Task-4 has no inline wave; the subsection lists it under wave 3.
+		assert.equal(waves.get("Task-4"), 3);
+		// Subtasks inherit the parent's effective wave (Task-3 → 2).
+		assert.equal(waves.get("Task-3.1"), 2);
+		assert.equal(waves.get("Task-3.2"), 2);
+	});
+
+	it("normalizes task ids from messy input", () => {
+		assert.equal(normalizeTaskId("I-001"), "Task-1");
+		assert.equal(normalizeTaskId("task-03.1"), "Task-3.1");
+		assert.equal(normalizeTaskId("`Task-12`"), "Task-12");
+		assert.equal(normalizeTaskId("nope"), null);
+	});
+
+	it("lints clean plans as null and flags drift", () => {
+		assert.equal(lintPlanTasks(TASK_PLAN), null);
+		assert.equal(lintPlanTasks("# no tasks\n"), null);
+		const drifted = "## Tasks\n\n- nothing parseable here\n";
+		assert.ok(lintPlanTasks(drifted)?.includes("0 项"));
+		const deep = "## Tasks\n\n- Task-1: a\n  - Task-1.1.1: too deep\n";
+		assert.ok(lintPlanTasks(deep)?.includes("层级过深"));
+		const unknownDep = "## Tasks\n\n- Task-2: b — deps: Task-9\n";
+		assert.ok(lintPlanTasks(unknownDep)?.includes("引用未知任务"));
+		const sharedFile = "## Tasks\n\n- Task-1: a — files: src/a.ts; wave: 1\n- Task-2: b — files: src/a.ts; wave: 1\n";
+		assert.ok(lintPlanTasks(sharedFile)?.includes("不相交"));
+		const lateDep = "## Tasks\n\n- Task-1: a; wave: 2\n- Task-2: b — deps: Task-1; wave: 1\n";
+		assert.ok(lintPlanTasks(lateDep)?.includes("不在更早的波次"));
+		const coversUnknown = "## Tasks\n\n- Task-1: a\n\n## Verification Checks\n\n- [ ] \`VC-001\` covers \`Task-7\`; pass: ok\n";
+		assert.ok(lintPlanTasks(coversUnknown)?.includes("covers 引用未知任务"));
+		const conflict = "## Tasks\n\n- Task-1: a — wave: 2\n\n### Execution Waves\n\n- wave 1: Task-1 — x\n";
+		assert.ok(lintPlanTasks(conflict)?.includes("以子节为准"));
+		const subWave = "## Tasks\n\n- Task-1: a\n  - Task-1.1: s — wave: 3\n";
+		assert.ok(lintPlanTasks(subWave)?.includes("继承父任务波次"));
+		const gap = "## Tasks\n\n- Task-2: starts at two\n";
+		assert.ok(lintPlanTasks(gap)?.includes("不连续"));
+		const dup = "## Tasks\n\n- Task-1: first — files: src/a.ts; wave: 1\n- Task-1: shadow — files: src/b.ts; wave: 1\n";
+		assert.ok(lintPlanTasks(dup)?.includes("重复"));
+		const noCover = "## Tasks\n\n- Task-1: a\n\n## Verification Checks\n\n- [ ] \`VC-001\` pass condition: no covers clause\n- [ ] \`VC-002\` covers \`Task-1\`; pass condition: ok\n";
+		assert.ok(lintPlanTasks(noCover)?.includes("VC-001 无 covers"));
+	});
+
+	it("lintPlanIntoNotices surfaces task lint via state", () => {
+		// Direct unit probe: state lint joins impl + task notices.
+		const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-task-lint-"));
+		try {
+			const planPath = path.join(tmp, "PLAN_v1.md");
+			fs.writeFileSync(
+				planPath,
+				"## Tasks\n\n- Task-2: gap and unknown dep — deps: Task-9\n",
+				"utf8",
+		);
+			const notices = lintPlanTasks(fs.readFileSync(planPath, "utf8"));
+		assert.ok(notices !== null && notices.includes("引用未知任务"));
+	} finally {
+		fs.rmSync(tmp, { recursive: true, force: true });
+	}
 	});
 });

package/tests/plans.test.ts

@@ -44,7 +44,7 @@ describe("plans tool source", () => {
 		assert.match(source, /import \{[\s\S]*setRefsRoot,[\s\S]*\} from "\.\.\/src\/state\.ts";/);
 		assert.match(source, /case "set-refs-root"/);
 		assert.match(source, /params\.refsRootSource/);
-		assert.match(source, /"reviewer", "criticizer", "ref-analyst"/);
+		assert.match(source, /"reviewer", "ref-analyst"/);
 	});
 });
 
@@ -75,15 +75,11 @@ describe("record-checkpoint transitions (I-003)", () => {
 			assert.equal(loaded.status, "ok");
 			assert.equal(loaded.checkpoint.plan?.path, planPath);
 
-			// completed without evidence is rejected (F-004).
-			assert.throws(
-				() => recordCheckpointTransition(ctx, workdir, run.run_id, { transition: "completed" }),
-				/evidence/,
-			);
-			// completed from the planning phase is rejected even with evidence.
-			assert.throws(
-				() => recordCheckpointTransition(ctx, workdir, run.run_id, { transition: "completed", evidence: "done" }),
-				/cannot complete from phase/,
+			// v0.6.1: the implementation-review transitions are gone from the
+			// schema — the union no longer accepts them at compile time, and
+			// the handler switch exhausts on the two remaining names.
+			assert.ok(
+				!"completed".includes("plan-written") && !"completed".includes("review-consolidated"),
 			);
 			// planPath is required.
 			assert.throws(
@@ -112,76 +108,8 @@ describe("pre-plan compaction wiring", () => {
 		const source = fs.readFileSync(path.join(ROOT, "index.ts"), "utf8");
 		assert.match(source, /consumePrePlanCompactPending/);
 		assert.match(source, /customInstructions: PLANNING_PREPLAN_COMPACT_HINT/);
-		assert.match(source, /sendPrePlanCompactResume\(pi\)/);
+		assert.match(source, /sendPrePlanCompactResume\(ctx\)/);
 		assert.match(source, /pre-plan compaction skipped; continuing planning\./);
 	});
 });
 
-describe("record-checkpoint reviewerCount (0.5.4)", () => {
-	it("implementation-review-configured carries reviewerCount through schema and state", async () => {
-		const { recordCheckpointTransition } = await import("../tools/plans.ts");
-		const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-rcp-rc-"));
-		try {
-			spawnSync("git", ["init"], { cwd: workdir });
-			const { initState, startRun } = await import("../src/state.ts");
-			initState(workdir);
-			const { run } = startRun(workdir, { topic: "rcp-rc", skill: "plan-big", requestText: "t" });
-			const { createCheckpoint, loadCheckpoint } = await import("../src/workflow-state.ts");
-			const { mutateCheckpoint } = await import("../src/workflow-state.ts");
-			createCheckpoint(workdir, { runId: run.run_id, originWorkdir: workdir, workdir });
-			mutateCheckpoint(workdir, run.run_id, (cp) => ({ ...cp, phase: "implementation-review", nextAction: "ask-question" }));
-			const ctx = { sessionManager: { id: "s" } };
-
-			const updated = recordCheckpointTransition(ctx, workdir, run.run_id, {
-				transition: "implementation-review-configured",
-				terminationCondition: "until no high-severity finding (hard cap 5 rounds)",
-				reviewerCount: 3,
-			});
-			assert.equal(updated.implementationReview?.reviewerCount, 3);
-			assert.equal(updated.nextAction, "run-review");
-			const loaded = loadCheckpoint(workdir, run.run_id);
-			assert.ok(loaded.status === "ok");
-			assert.equal(loaded.checkpoint.implementationReview?.reviewerCount, 3);
-
-			// Omitted reviewerCount still configures (skill default applies later).
-			const workdir2 = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-rcp-rc2-"));
-			spawnSync("git", ["init"], { cwd: workdir2 });
-			initState(workdir2);
-			const { run: run2 } = startRun(workdir2, { topic: "rcp-rc2", skill: "plan-normal", requestText: "t" });
-			createCheckpoint(workdir2, { runId: run2.run_id, originWorkdir: workdir2, workdir: workdir2 });
-			mutateCheckpoint(workdir2, run2.run_id, (cp) => ({ ...cp, phase: "implementation-review", nextAction: "ask-question" }));
-			const updated2 = recordCheckpointTransition(ctx, workdir2, run2.run_id, {
-				transition: "implementation-review-configured",
-				terminationCondition: "1 round",
-			});
-			assert.equal(updated2.implementationReview?.reviewerCount, undefined);
-
-			// Boundary: reviewerCount outside 1-3 fails checkpoint validation on
-			// write (the tool's TypeBox schema rejects the same range earlier).
-			const workdir3 = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-rcp-rc3-"));
-			try {
-				spawnSync("git", ["init"], { cwd: workdir3 });
-				initState(workdir3);
-				const { run: run3 } = startRun(workdir3, { topic: "rcp-rc3", skill: "plan-small", requestText: "t" });
-				createCheckpoint(workdir3, { runId: run3.run_id, originWorkdir: workdir3, workdir: workdir3 });
-				mutateCheckpoint(workdir3, run3.run_id, (cp) => ({ ...cp, phase: "implementation-review", nextAction: "ask-question" }));
-				for (const bad of [0, 4]) {
-					assert.throws(
-						() =>
-							recordCheckpointTransition(ctx, workdir3, run3.run_id, {
-								transition: "implementation-review-configured",
-								terminationCondition: "1 round",
-								reviewerCount: bad,
-							}),
-						/reviewerCount|1-3/,
-						`reviewerCount ${bad} rejected`,
-					);
-				}
-			} finally {
-				fs.rmSync(workdir3, { recursive: true, force: true });
-			}
-		} finally {
-			fs.rmSync(workdir, { recursive: true, force: true });
-		}
-	});
-});

package/tests/refine-prompts.test.ts

@@ -2,7 +2,7 @@ import * as assert from "node:assert/strict";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { describe, it } from "node:test";
-import { buildCriticizerTask, buildImplementationCriticizerTask, buildImplementationReviewerTask, buildRefAnalystTask, buildReviewerTask, refAnalystSections, reviewerLanes } from "../src/refine-prompts.ts";
+import { buildRefAnalystTask, buildReviewerTask, refAnalystSections, reviewerLanes } from "../src/refine-prompts.ts";
 
 describe("reviewerLanes", () => {
 	it("uses stable lane ids for the big-plan fanout", () => {
@@ -24,7 +24,7 @@ describe("buildReviewerTask", () => {
 			context: "repo evidence",
 		});
 
-		assert.match(text, /Goal: review the plan against the repository\./);
+		assert.match(text, /Goal: review the plan against the repository and surface what needs the user's judgment\./);
 		assert.match(text, /Target: \/tmp\/PLAN_v1\.md/);
 		assert.match(text, /Authority boundary: read-only analysis only\./);
 		assert.match(text, /Review lens: verification rigor\./);
@@ -68,81 +68,30 @@ describe("buildRefAnalystTask", () => {
 	});
 });
 
-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/);
-	});
-});
-
-describe("buildImplementationReviewerTask", () => {
-	it("anchors findings to the plan and explicitly assesses delivery maturity", () => {
-		const text = buildImplementationReviewerTask({
-			planText: "# plan",
-			planPath: "/tmp/PLAN_v1.md",
-			lens: "correctness",
-		});
-
-		assert.match(text, /Goal: review the implemented result in the worktree against the plan\./);
-		assert.match(text, /the IMPLEMENTATION in the worktree is under review/);
-		assert.match(text, /Judge the implementation against the plan's goals/);
-		assert.match(text, /did the executor ship a minimal MVP only, or refine for long-term growth/);
-		assert.match(text, /Out-of-scope improvement ideas are low severity by default/);
-		assert.match(text, /Review lens: correctness\./);
-		assert.match(text, /Surface at most five high-priority findings/);
-	});
-});
-
-describe("buildImplementationCriticizerTask", () => {
-	it("asks implementation-focused adversarial questions without rewriting the implementation", () => {
-		const text = buildImplementationCriticizerTask({
-			planText: "# plan",
-			planPath: "/tmp/PLAN_v1.md",
-		});
-
-		assert.match(text, /Goal: stress-test the implemented result's assumptions\./);
-		assert.match(text, /the IMPLEMENTATION in the worktree is under review/);
-		assert.match(text, /never rewrite the plan or the implementation/);
-		assert.match(text, /at most five adaptive questions/);
-	});
-});
-
-describe("plan-mode builders are unchanged by the implementation-mode addition", () => {
-	it("buildReviewerTask output is byte-identical to its prior contract", () => {
-		// Snapshot regression guard: changing the plan-mode brief would silently
-		// break existing reviewer subagents. Keep this stable.
-		const before = buildReviewerTask({ planText: "PLAN", planPath: "/p/PLAN_v1.md" });
-		assert.match(before, /Goal: review the plan against the repository\./);
-		assert.doesNotMatch(before, /IMPLEMENTATION in the worktree/);
+describe("plan-mode builder carries the merged findings+questions contract", () => {
+	it("buildReviewerTask outputs Findings and Questions sections", () => {
+		// v0.6.1: the reviewer absorbed the criticizer's questioning duty.
+		const brief = buildReviewerTask({ planText: "PLAN", planPath: "/p/PLAN_v1.md" });
+		assert.match(brief, /## Findings[\s\S]*## Questions/);
+		assert.match(brief, /`Q-1`/);
+		assert.match(brief, /at most five/i);
+		assert.doesNotMatch(brief, /criticizer/i);
 	});
 });
 
-describe("refine tool wires target to the right builder", () => {
-	it("forwards target=implementation to the implementation builders", () => {
+describe("refine tool wires the single reviewer role", () => {
+	it("has no role/target params and mandates ask_choice for questions", () => {
 		const source = fs.readFileSync(path.join(process.cwd(), "tools", "refine.ts"), "utf8");
-		assert.match(source, /buildImplementationReviewerTask/);
-		assert.match(source, /buildImplementationCriticizerTask/);
-		assert.match(source, /target\s*===\s*"implementation"/);
-		assert.match(source, /params\.target\s*\?\?\s*"plan"/);
+		assert.doesNotMatch(source, /buildCriticizerTask/);
+		assert.doesNotMatch(source, /buildImplementation/);
+		assert.doesNotMatch(source, /StringEnum\(\["reviewer", "criticizer"\]/);
+		assert.match(source, /MUST ask every question with ask_choice/);
+		assert.match(source, /role: "reviewer"/);
 	});
 
-	it("criticizer spawn gets the graph tools and prompt like the reviewer", () => {
+	it("reviewer spawn gets the graph tools and prompt", () => {
 		const source = fs.readFileSync(path.join(process.cwd(), "tools", "refine.ts"), "utf8");
-		const criticizerBlock = source.slice(
-			source.indexOf('params.role === "criticizer"'),
-			source.indexOf("const count = Math.min"),
-		);
-		assert.ok(criticizerBlock.length > 0, "criticizer block not found");
-		assert.match(criticizerBlock, /tools: subagentTools/);
-		assert.match(criticizerBlock, /graphPrompt/);
+		assert.match(source, /tools: subagentTools/);
+		assert.match(source, /graphPrompt/);
 	});
 });