pi-plans 0.6.0 → 0.7.0

package/tests/multi-run.test.ts

@@ -19,9 +19,7 @@ import { planningWriteBlockReason } from "../src/guard.ts";
 import { executionCandidates, abandonCandidates, runPickerLabel } from "../src/run-picker.ts";
 import { subagentChildEnv } from "../src/subagent.ts";
 import {
-	applyDoneMarkers,
 	getExecution,
-	mirrorDelegateMarkers,
 	startExecution,
 	stopExecution,
 } from "../src/exec.ts";
@@ -68,7 +66,7 @@ describe("run registry (v0.6.0)", () => {
 		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");
+		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");
 
@@ -85,7 +83,7 @@ describe("run registry (v0.6.0)", () => {
 		const workdir = freshWorkdir();
 		initState(workdir);
 		startRun(workdir, { topic: "pointerless", skill: "plan-small", requestText: "x" });
-		const activePath = path.join(workdir, ".git", "pi_plans", "active.json");
+		const activePath = path.join(workdir, ".git", "pi-plans", "active.json");
 		assert.equal(fs.existsSync(activePath), false, "registry workdirs keep no shared pointer");
 	});
 
@@ -103,7 +101,7 @@ describe("run registry (v0.6.0)", () => {
 	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");
+		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");
@@ -129,53 +127,8 @@ describe("run registry (v0.6.0)", () => {
 });
 
 describe("multi-run resolution and guard", () => {
-	it("un-bound fallback prefers the newest non-terminal run; PI_PLANS_RUN_ID pins resolution", () => {
-		const workdir = freshWorkdir();
-		initState(workdir);
-		const older = startRun(workdir, { topic: "older", skill: "plan-small", requestText: "a" }).run;
-		const newer = startRun(workdir, { topic: "newer", skill: "plan-small", requestText: "b" }).run;
-		const ctx = fakeCtx(workdir);
-		assert.equal(resolveActiveRun(ctx.sessionManager, workdir)?.run_id, newer.run_id);
-		process.env.PI_PLANS_RUN_ID = older.run_id;
-		try {
-			assert.equal(resolveActiveRun(ctx.sessionManager, workdir)?.run_id, older.run_id, "env pin wins over registry");
-		} finally {
-			delete process.env.PI_PLANS_RUN_ID;
-		}
-		void older;
-	});
 
-	it("guard no-ops for executor children even when a foreign planning run is newest", () => {
-		const workdir = freshWorkdir();
-		initState(workdir);
-		startRun(workdir, { topic: "foreign-planning", skill: "plan-big", requestText: "z" });
-		const target = path.join(workdir, "src", "thing.ts");
-		const input = { workdir, toolName: "write", rawPath: target };
-		// Sanity: without the marker, the newest planning run blocks the write.
-		assert.notEqual(planningWriteBlockReason(input), null);
-		process.env.PI_PLANS_EXECUTOR = "1";
-		try {
-			assert.equal(planningWriteBlockReason(input), null, "executor children are never guarded");
-		} finally {
-			delete process.env.PI_PLANS_EXECUTOR;
-		}
-	});
 
-	it("PI_PLANS_RUN_ID also unblocks the guard for pinned non-executor children", () => {
-		const workdir = freshWorkdir();
-		initState(workdir);
-		const run = startRun(workdir, { topic: "executing-run", skill: "plan-small", requestText: "e" }).run;
-		setRunStatus(workdir, run.run_id, "executing");
-		startRun(workdir, { topic: "newer-planning", skill: "plan-small", requestText: "n" });
-		const input = { workdir, toolName: "edit", rawPath: path.join(workdir, "src", "a.ts") };
-		assert.notEqual(planningWriteBlockReason(input), null);
-		process.env.PI_PLANS_RUN_ID = run.run_id;
-		try {
-			assert.equal(planningWriteBlockReason(input), null, "pinned executing run does not guard");
-		} finally {
-			delete process.env.PI_PLANS_RUN_ID;
-		}
-	});
 });
 
 describe("run picker candidates", () => {
@@ -220,14 +173,6 @@ describe("subagent child env markers", () => {
 		assert.equal(env.PI_PLANS_RUN_ID, undefined);
 	});
 
-	it("executor sets PI_PLANS_EXECUTOR plus the run-id pin", () => {
-		const env = subagentChildEnv({ envMarker: "executor", runId: "run-42" }, { PI_PLANS_REFINER: "1" });
-		assert.equal(env.PI_PLANS_EXECUTOR, "1");
-		assert.equal(env.PI_PLANS_RUN_ID, "run-42");
-		assert.equal(env.PI_PLANS_REFINER, undefined);
-		const noRun = subagentChildEnv({ envMarker: "executor" }, { PI_PLANS_RUN_ID: "leaked" });
-		assert.equal(noRun.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" });
@@ -237,48 +182,3 @@ describe("subagent child env markers", () => {
 	});
 });
 
-describe("delegated executor marker mirroring", () => {
-	it("mirrors [DONE:VC-xxx] and impl markers from a child's full-text message", async () => {
-		const workdir = freshWorkdir();
-		const pi = { appendEntry: () => {}, sendMessage: () => {} } as any;
-		const ctx = fakeCtx(workdir);
-		await startExecution(pi, ctx, path.join(workdir, "PLAN_v1.md"), [
-			{ id: "VC-001", text: "a", done: false },
-			{ id: "VC-002", text: "b", done: false },
-		] as any, [
-			{ id: "I-001", text: "impl a", dependsOn: [], files: [] },
-		] as any);
-		try {
-			// One streamed full-text message covering both marker kinds.
-			mirrorDelegateMarkers(pi, ctx, "Implemented slice one.\n\n[DONE:VC-001]\n[I-001:implemented]");
-			const execution = getExecution()!;
-			assert.equal(execution.items[0]!.done, true);
-			assert.equal(execution.items[1]!.done, false);
-			assert.equal(execution.implStatus?.["I-001"], "implemented");
-			// A second message repeats nothing new; markers are idempotent.
-			const changed = applyDoneMarkers("[DONE:VC-001]");
-			assert.deepEqual(changed, []);
-		} finally {
-			await stopExecution(pi, ctx, "test");
-		}
-	});
-});
-
-describe("graph-aware executor bypass", () => {
-	it("write/edit wrappers route to native tools when PI_PLANS_EXECUTOR=1 (mode-independent)", async () => {
-		// Direct unit check of the bypass branch marker: the wrapper reads the
-		// env BEFORE resolving graph mode, so even "enabled" mode must not stage.
-		const source = fs.readFileSync(path.resolve("tools/graph-aware-file-tools.ts"), "utf8");
-		for (const tool of ["write", "edit", "read"]) {
-			const pattern = new RegExp(`process\\.env\\.PI_PLANS_EXECUTOR === "1"\\s*\\)?;?\\s*return\\s+(${tool === "write" ? "stage" : tool === "edit" ? "stage" : "native"})\\(null\\)`, "i");
-			void pattern;
-		}
-		// Behavioral proxy: the executor check appears before mode resolution in each tool body.
-		const writeIdx = source.indexOf("const mode: GraphMode = resolveGraphMode(ctx.cwd);");
-		const executorIdx = source.indexOf('if (process.env.PI_PLANS_EXECUTOR === "1") return stage(null);');
-		assert.ok(writeIdx > 0 && executorIdx > 0);
-		assert.ok(executorIdx > writeIdx, "executor bypass exists after mode resolution start");
-		const occurrences = source.match(/PI_PLANS_EXECUTOR === "1"/g) ?? [];
-		assert.equal(occurrences.length, 3, "read + write + edit all carry the bypass");
-	});
-});

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