pi-plans 0.5.7 → 0.7.0

package/tests/refine-resume.test.ts

@@ -7,7 +7,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { after, before, describe, it } from "node:test";
 import {
-	applyImplementationReviewConfigured,
+
 	applyLaneResult,
 	applyReviewConsolidated,
 	createCheckpoint,
@@ -19,8 +19,11 @@ import {
 	startReviewRound,
 } from "../src/workflow-state.ts";
 import { initState, startRun } from "../src/state.ts";
+import { setMessagingApi } from "../src/messaging.ts";
 
 let tmpRoot: string;
+let globalDir: string;
+let previousGlobalDir: string | undefined;
 
 function setupRun(name: string): { workdir: string; runId: string; artifactDir: string } {
 	const workdir = path.join(tmpRoot, name);
@@ -35,9 +38,17 @@ function setupRun(name: string): { workdir: string; runId: string; artifactDir:
 
 before(() => {
 	tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-rr-"));
+	// Isolate the global reviewer config (F-002): setRole writes the global
+	// file; tests must never touch the developer's ~/.pi/pi-plans.
+	previousGlobalDir = process.env.PI_PLANS_GLOBAL_DIR;
+	globalDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-global-rr-"));
+	process.env.PI_PLANS_GLOBAL_DIR = globalDir;
 });
 
 after(() => {
+	if (previousGlobalDir === undefined) delete process.env.PI_PLANS_GLOBAL_DIR;
+	else process.env.PI_PLANS_GLOBAL_DIR = previousGlobalDir;
+	fs.rmSync(globalDir, { recursive: true, force: true });
 	fs.rmSync(tmpRoot, { recursive: true, force: true });
 });
 
@@ -194,6 +205,7 @@ describe("implementation-review round 1 fixes", () => {
 			hasUI: false,
 			ui: { notify: () => {}, setStatus: () => {}, theme: { fg: (_c: string, t: string) => t } },
 		};
+		setMessagingApi({ appendEntry: () => {}, sendMessage: () => {}, sendUserMessage: async () => {} });
 		const result = await tool!.execute("t1", { role: "reviewer", planPath, reviewers: 2 }, undefined, undefined, ctx);
 		assert.match(result.content[0]?.text ?? "", /current-session/);
 		// The durable round exists WITH lanes — the pre-fix crash site.
@@ -236,9 +248,9 @@ describe("implementation-review round 1 fixes", () => {
 		// Edit the plan in place — same path, different bytes.
 		fs.writeFileSync(planPath, "# plan (edited)\n\n## Verifier Checklist\n\n- [ ] `VC-001` covers `I-001`; pass condition: x.\n", "utf8");
 		const { loadExecutionFromCheckpoint } = await import("../src/exec.ts");
-		const pi = { appendEntry: () => {}, sendMessage: () => {} } as never;
 		const ctx = { cwd: workdir, sessionManager: {}, ui: { setStatus: () => {}, theme: { fg: (_c: string, t: string) => t } } };
-		const load = loadExecutionFromCheckpoint(pi, ctx, run.run_id);
+		setMessagingApi({ appendEntry: () => {}, sendMessage: () => {}, sendUserMessage: async () => {} });
+		const load = loadExecutionFromCheckpoint(ctx as never, run.run_id);
 		assert.equal(load.status, "plan-mismatch");
 		assert.match((load as { error?: string }).error ?? "", /changed since the approval/);
 	});
@@ -266,9 +278,9 @@ describe("implementation-review round 1 fixes", () => {
 		});
 		mutateCheckpoint(workdir, run.run_id, (cp) => applyExecutionProgress(cp, { doneVcIds: ["VC-001"] }));
 		const { loadExecutionFromCheckpoint } = await import("../src/exec.ts");
-		const pi = { appendEntry: () => {}, sendMessage: () => {} } as never;
 		const ctx = { cwd: workdir, sessionManager: {}, ui: { setStatus: () => {}, theme: { fg: (_c: string, t: string) => t } } };
-		const load = loadExecutionFromCheckpoint(pi, ctx, run.run_id);
+		setMessagingApi({ appendEntry: () => {}, sendMessage: () => {}, sendUserMessage: async () => {} });
+		const load = loadExecutionFromCheckpoint(ctx as never, run.run_id);
 		assert.equal(load.status, "loaded");
 		assert.equal((load as { reverifyAll?: boolean }).reverifyAll, true, "unverifiable HEAD re-verifies");
 	});
@@ -285,7 +297,7 @@ describe("implementation-review round 1 fixes", () => {
 		const owner = acquireOwnership(workdir, run.run_id);
 		// Another process takes over (fabricated record with a reused/dead pid).
 		fs.writeFileSync(
-			path.join(workdir, ".git", "pi_plans", "runs", run.run_id, "owner.json"),
+			path.join(workdir, ".git", "pi-plans", "runs", run.run_id, "owner.json"),
 			JSON.stringify({ ...owner, pid: process.pid, pidStart: "bogus-start", processToken: "someone-else", generation: owner.generation + 1 }),
 			"utf8",
 		);
@@ -323,7 +335,7 @@ describe("implementation-review round 1 fixes", () => {
 	});
 });
 
-describe("implementation-review reviewer-count fallback (0.5.4, D-4)", () => {
+describe("plan-review reviewer-count defaults (v0.6.1 single-reviewer)", () => {
 	async function setupLoopRun(name: string, skill: string, reviewerCount?: number) {
 		const workdir = path.join(tmpRoot, name);
 		fs.mkdirSync(workdir, { recursive: true });
@@ -336,16 +348,6 @@ describe("implementation-review reviewer-count fallback (0.5.4, D-4)", () => {
 		fs.mkdirSync(run.artifact_dir, { recursive: true });
 		const planPath = path.join(run.artifact_dir, "PLAN_v1.md");
 		fs.writeFileSync(planPath, "# plan\n\n## Verifier Checklist\n\n- [ ] `VC-001` covers `I-001`; pass condition: x.\n", "utf8");
-		// refine's round-start guard requires a recorded termination condition
-		// before any implementation round, so the loop is always configured;
-		// reviewerCount may legitimately be absent (skill default applies).
-		mutateCheckpoint(workdir, run.run_id, (cp) =>
-			applyImplementationReviewConfigured(
-				{ ...cp, phase: "implementation-review", nextAction: "ask-question" },
-				"1 round",
-				reviewerCount,
-			),
-		);
 		return { workdir, runId: run.run_id, planPath };
 	}
 
@@ -373,13 +375,14 @@ describe("implementation-review reviewer-count fallback (0.5.4, D-4)", () => {
 			hasUI: false,
 			ui: { notify: () => {}, setStatus: () => {}, theme: { fg: (_c: string, t: string) => t } },
 		};
-		const result = await tool.execute("t1", { role: "reviewer", target: "implementation", planPath }, undefined, undefined, ctx);
+		setMessagingApi({ appendEntry: () => {}, sendMessage: () => {}, sendUserMessage: async () => {} });
+		const result = await tool.execute("t1", { planPath, reviewers: 3 }, undefined, undefined, ctx);
 		assert.match(result.content[0]?.text ?? "", /current-session/);
 		const loaded = loadCheckpoint(workdir, runId);
 		assert.ok(loaded.status === "ok");
 		const round = loaded.checkpoint.reviewRounds.at(-1);
 		assert.ok(round, "round recorded");
-		assert.equal(round!.reviewers, 3, "configured reviewerCount used as fallback");
+		assert.equal(round!.reviewers, 3, "explicit reviewers=3 honored");
 		assert.equal(round!.lanes.length, 3, "three lanes spawned");
 	});
 
@@ -394,7 +397,8 @@ describe("implementation-review reviewer-count fallback (0.5.4, D-4)", () => {
 			hasUI: false,
 			ui: { notify: () => {}, setStatus: () => {}, theme: { fg: (_c: string, t: string) => t } },
 		};
-		await tool.execute("t1", { role: "reviewer", target: "implementation", planPath, reviewers: 1 }, undefined, undefined, ctx);
+		setMessagingApi({ appendEntry: () => {}, sendMessage: () => {}, sendUserMessage: async () => {} });
+		await tool.execute("t1", { planPath, reviewers: 1 }, undefined, undefined, ctx);
 		const loaded = loadCheckpoint(workdir, runId);
 		assert.ok(loaded.status === "ok");
 		const round = loaded.checkpoint.reviewRounds.at(-1);
@@ -413,11 +417,12 @@ describe("implementation-review reviewer-count fallback (0.5.4, D-4)", () => {
 			hasUI: false,
 			ui: { notify: () => {}, setStatus: () => {}, theme: { fg: (_c: string, t: string) => t } },
 		};
-		await tool.execute("t1", { role: "reviewer", target: "implementation", planPath }, undefined, undefined, ctx);
+		setMessagingApi({ appendEntry: () => {}, sendMessage: () => {}, sendUserMessage: async () => {} });
+		await tool.execute("t1", { planPath }, undefined, undefined, ctx);
 		const loaded = loadCheckpoint(workdir, runId);
 		assert.ok(loaded.status === "ok");
 		const round = loaded.checkpoint.reviewRounds.at(-1);
-		assert.equal(round!.lanes.length, 1, "no configuration and no param → 1 lane");
+		assert.equal(round!.lanes.length, 1, "no param → 1 lane default");
 	});
 
 	it("count=2 consolidation text carries the source-reviewer contract (D-7)", async () => {

package/tests/refine-ui.test.ts

@@ -151,15 +151,6 @@ describe("refine overlay viewport", () => {
 		);
 		assert.ok(reviewer.render(120).some((line) => line.includes("Reviewer (m1)")));
 
-		const criticizer = new RefineOverlayComponent(
-			fakeTheme,
-			"criticizer",
-			[readyLane("lane-1", "criticizer", "ok")],
-			() => {},
-			undefined,
-			"m2",
-		);
-		assert.ok(criticizer.render(120).some((line) => line.includes("Criticizer (m2)")));
 	});
 
 	it("renders model-aware titles and footer hints", () => {
@@ -230,14 +221,14 @@ describe("refine overlay viewport", () => {
 		const linesText = ["line 1", "line 2", "line 3", "line 4", "line 5"].join("\n");
 		const component = new RefineOverlayComponent(
 			fakeTheme,
-			"criticizer",
-			[streamingToolLane("lane-1", "criticizer", linesText)],
+			"reviewer",
+			[streamingToolLane("lane-1", "reviewer", linesText)],
 			() => {},
 			undefined,
 			"singularity-gpt/gpt-5.5:xhigh",
 		);
 		const lines = component.render(90);
-		assert.ok(lines.some((line) => line.includes("Criticizer (singularity-gpt/gpt-5.5:xhigh)")));
+		assert.ok(lines.some((line) => line.includes("Reviewer (singularity-gpt/gpt-5.5:xhigh)")));
 		assert.ok(lines.some((line) => line.includes("…")));
 		assert.ok(lines.some((line) => line.includes("line 3")));
 		assert.ok(lines.some((line) => line.includes("line 4")));
@@ -269,8 +260,8 @@ describe("refine overlay viewport", () => {
 	it("renders a single pane with pi-btw-style transcript badges", () => {
 		const component = new RefineOverlayComponent(
 			fakeTheme,
-			"criticizer",
-			[readyLane("lane-1", "criticizer", "assistant output")],
+			"refs",
+			[readyLane("lane-1", "refs", "assistant output")],
 			() => {},
 		);
 		const lines = component.render(90);
@@ -340,7 +331,7 @@ describe("refine overlay wiring", () => {
 	it("threads the chrome language through both overlay construction sites (issue #3, VC-007)", () => {
 		const refineSource = fs.readFileSync(path.join(process.cwd(), "tools", "refine.ts"), "utf8");
 		assert.match(refineSource, /const overlayLang = uiLanguageFromTag\(config\.language\.tag\)/);
-		assert.match(refineSource, /new RefineOverlayController\(role, lanes, relayAbort, lang\)/);
+		assert.match(refineSource, /new RefineOverlayController\("reviewer", lanes, relayAbort, lang\)/);
 		assert.match(refineSource, /modelLabel,\s*\n\s*overlayLang,/);
 		const refsSource = fs.readFileSync(path.join(process.cwd(), "tools", "analyze-refs.ts"), "utf8");
 		assert.match(

package/tests/resume-lifecycle.test.ts

@@ -25,7 +25,7 @@ import { startExecution } from "../src/exec.ts";
 import { resetRunBindingForTests } from "../src/run-context.ts";
 import { processStartOf } from "../src/run-ownership.ts";
 import { createCheckpoint, loadCheckpoint, mutateCheckpoint, applyQuestionAsked } from "../src/workflow-state.ts";
-import { getRun, initState, startRun } from "../src/state.ts";
+import { DEFAULT_CONFIG, getRun, initState, resolveArtifactRoot, startRun } from "../src/state.ts";
 
 initTheme("dark", false);
 const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-resume-life-"));
@@ -34,10 +34,15 @@ let serial = 0;
 
 const PLAN_TEXT = `# Plan
 
-## Verifier Checklist
+## Tasks
 
-- [ ] \`VC-001\` covers \`I-001\`; pass condition: first.
-- [ ] \`VC-002\` covers \`I-002\`; pass condition: second.
+- Task-1: first — files: src/a.ts; wave: 1
+- Task-2: second — files: src/b.ts; wave: 1
+
+## Verification Checks
+
+- [ ] \`VC-001\` covers \`Task-1\`; pass condition: first.
+- [ ] \`VC-002\` covers \`Task-2\`; pass condition: second.
 `;
 
 interface Fixture {
@@ -173,6 +178,9 @@ function setupRun(name: string): { cwd: string; runId: string; artifactDir: stri
 	createCheckpoint(cwd, { runId: run.run_id, originWorkdir: cwd, workdir: cwd });
 	fs.mkdirSync(run.artifact_dir, { recursive: true });
 	fs.writeFileSync(path.join(run.artifact_dir, "PLAN_v1.md"), PLAN_TEXT, "utf8");
+	// The artifact dir lives under .git/ and is never tracked; seed a root file so
+	// the "seed" commit exists and resolveHeadAt() yields the approval evidence HEAD.
+	fs.writeFileSync(path.join(cwd, "WORKTREE.md"), "seed worktree marker\n", "utf8");
 	spawnSync("git", ["add", "-A"], { cwd });
 	spawnSync("git", ["commit", "-m", "seed"], { cwd });
 	return { cwd, runId: run.run_id, artifactDir: run.artifact_dir };
@@ -185,12 +193,10 @@ describe("/resume-plans on the real Pi host", () => {
 		async () => {
 			resetRunBindingForTests();
 			const { cwd, runId } = setupRun("cross-session");
-			// Session 1: execution starts, VC-001 lands, then the session ends.
+			// Session 1: execution starts, Task-1 closes via the task tool,
+			// then the session ends.
 			const fixture1: Fixture = {
-				script: [
-					{ kind: "tool" },
-					{ kind: "text", text: "[DONE:VC-001] Partial progress; stopping here." },
-				],
+				script: [{ kind: "text", text: "Partial progress; stopping here." }],
 				calls: [],
 			};
 			const session1 = await makeSession({
@@ -200,10 +206,18 @@ describe("/resume-plans on the real Pi host", () => {
 				extraExtension: ((pi: never) => {
 					const realPi = pi as unknown as import("@earendil-works/pi-coding-agent").ExtensionAPI;
 					realPi.on("session_start", async (_event: unknown, ctx: never) => {
-						await startExecution(realPi, ctx as never, path.join(artifactDirRelative(cwd), "PLAN_v1.md"), [
-							{ id: "VC-001", text: "first", done: false },
-							{ id: "VC-002", text: "second", done: false },
-						]);
+						const planPath = path.join(artifactDirRelative(cwd), "PLAN_v1.md");
+						const planText = fs.readFileSync(planPath, "utf8");
+						const { parsePlanTasks, parseChecklist } = await import("../src/plan.ts");
+						await startExecution(ctx as never, {
+							planPath,
+							planTasks: parsePlanTasks(planText),
+							items: parseChecklist(planText),
+						});
+						const { applyTaskUpdate } = await import("../src/task-tool.ts");
+						const { getExecution, persistTaskProgress } = await import("../src/exec.ts");
+						applyTaskUpdate(getExecution()!.tasks, "Task-1", "complete", "first tests green");
+						persistTaskProgress(ctx as never);
 					});
 				}) as never,
 			});
@@ -214,7 +228,7 @@ describe("/resume-plans on the real Pi host", () => {
 				const mid = loadCheckpoint(cwd, runId);
 				assert.equal(mid.status, "ok");
 				if (mid.status === "ok") {
-					assert.deepEqual(mid.checkpoint.execution?.doneVcIds, ["VC-001"], "progress persisted by session 1");
+					assert.equal(mid.checkpoint.execution?.tasks?.["Task-1"]?.status, "complete", "task progress persisted by session 1");
 					assert.ok(mid.checkpoint.execution?.approval?.headAtApproval, "approval evidence persisted");
 				}
 			} finally {
@@ -225,7 +239,7 @@ describe("/resume-plans on the real Pi host", () => {
 
 			// Session 2: fresh session, resume via the command.
 			const fixture2: Fixture = {
-				script: [{ kind: "text", text: "[DONE:VC-002] All items verified." }],
+				script: [{ kind: "text", text: "Resumed; continuing the remaining task." }],
 				calls: [],
 			};
 			const notifies: string[] = [];
@@ -238,16 +252,15 @@ describe("/resume-plans on the real Pi host", () => {
 				assert.ok(fixture2.calls.length >= 1);
 				const firstPayload = JSON.stringify(fixture2.calls[0]);
 				assert.match(firstPayload, /PI-PLANS RESUME/);
-				assert.match(firstPayload, /VC-001/);
+				assert.match(firstPayload, /plans_update_task/);
 				assert.ok(notifies.some((message) => /Resumed/.test(message)), "resume notification shown");
-				// Both VCs are done; the run advanced to the review phase.
+				// Task-1 stays complete across the session boundary.
 				const final = loadCheckpoint(cwd, runId);
 				assert.equal(final.status, "ok");
 				if (final.status === "ok") {
-					assert.deepEqual(final.checkpoint.execution?.doneVcIds.sort(), ["VC-001", "VC-002"]);
-					assert.equal(final.checkpoint.phase, "implementation-review");
+					assert.equal(final.checkpoint.execution?.tasks?.["Task-1"]?.status, "complete");
+					assert.equal(final.checkpoint.execution?.tasks?.["Task-2"]?.status, undefined);
 				}
-				assert.equal(getRun(cwd, runId)?.status, "done");
 			} finally {
 				session2.session.dispose();
 			}
@@ -313,7 +326,7 @@ describe("/resume-plans on the real Pi host", () => {
 			const child = spawn("sleep", ["30"], { stdio: "ignore" });
 			try {
 				fs.writeFileSync(
-					path.join(cwd, ".git", "pi_plans", "runs", runId, "owner.json"),
+					path.join(cwd, ".git", "pi-plans", "runs", runId, "owner.json"),
 					JSON.stringify({
 						schema: 1,
 						host: os.hostname(),
@@ -369,7 +382,9 @@ describe("/resume-plans on the real Pi host", () => {
 });
 
 function artifactDirRelative(cwd: string): string {
-	const root = path.join(cwd, "docs", "pi-plans");
+	// Resolve through the real default so this fixture follows the configured
+	// artifact root (inside the state dir by default) instead of hardcoding it.
+	const root = resolveArtifactRoot(cwd, DEFAULT_CONFIG.artifact_root);
 	return path.join(root, fs.readdirSync(root)[0]!);
 }
 

package/tests/resume.test.ts

@@ -11,7 +11,8 @@ import { migrateRunIntoCurrentWorktree, resumePlansCommand } from "../src/resume
 import { createCheckpoint, loadCheckpoint, mutateCheckpoint, applyQuestionAsked, applyQuestionAnswered } from "../src/workflow-state.ts";
 import { acquireOwnership, processStartOf } from "../src/run-ownership.ts";
 import { resetRunBindingForTests } from "../src/run-context.ts";
-import { initState, setRunStatus, startRun, StateError } from "../src/state.ts";
+import { initState, setArtifactRoot, setRunStatus, startRun, StateError } from "../src/state.ts";
+import { setMessagingApi } from "../src/messaging.ts";
 
 let tmpRoot: string;
 
@@ -63,7 +64,7 @@ function makeCtx(cwd: string, overrides: Partial<CtxMock> = {}): CtxMock {
 }
 
 function ctxAdapter(mock: CtxMock): unknown {
-	return {
+	const ctx = {
 		cwd: mock.cwd,
 		hasUI: mock.hasUI,
 		isIdle: () => mock.isIdleResult,
@@ -84,21 +85,16 @@ function ctxAdapter(mock: CtxMock): unknown {
 			setStatus: () => {},
 		},
 	};
-}
-
-function makePi(mock: CtxMock): unknown {
-	return {
-		sendUserMessage: async (content: string) => {
-			mock.userMessages.push(content);
-		},
+	setMessagingApi({
 		appendEntry: (customType: string, data?: unknown) => {
 			mock.entries.push({ customType, data });
 		},
 		sendMessage: () => {},
-		on: () => {},
-		setModel: async () => true,
-		setThinkingLevel: () => {},
-	};
+		sendUserMessage: async (content: string) => {
+			mock.userMessages.push(content);
+		},
+	});
+	return ctx;
 }
 
 const BASE_DIR = path.resolve(import.meta.dirname, "..");
@@ -113,7 +109,7 @@ after(() => {
 });
 
 describe("candidate discovery", () => {
-	it("lists resumable runs, excludes terminal ones, prioritizes active", () => {
+	it("lists resumable runs, excludes terminal ones, registry hint first", () => {
 		const workdir = setupRepo("discovery");
 		const planning = startRun(workdir, { topic: "alpha", skill: "plan-normal", requestText: "a" }).run;
 		const stopped = startRun(workdir, { topic: "beta", skill: "plan-normal", requestText: "b" }).run;
@@ -136,21 +132,24 @@ describe("candidate discovery", () => {
 		assert.equal(ids.includes(abandoned.run_id), false);
 		assert.equal(ids.includes(done.run_id), false, "plain done excluded");
 
-		// Active priority: shared pointer names `doneWithReview` (last started).
-		const picked = pickDefaultCandidate(workdir, candidates);
-		assert.equal(picked?.runId, doneWithReview.run_id);
+		// v0.6.0: the active-pointer auto-win is gone. The registry hint (newest
+		// non-terminal run) still sorts first; picking defaults to null when
+		// several candidates exist — the command opens the form (binding-first).
+		assert.equal(candidates[0]!.runId, stopped.run_id, "registry hint sorts first");
+		assert.equal(pickDefaultCandidate(workdir, candidates), null, "multi-candidate requires choosing");
 	});
 
-	it("unique candidate auto-picks; unfinished active wins; ambiguity requires choosing", () => {
+	it("unique candidate auto-picks; ambiguity requires choosing (v0.6.0)", () => {
 		const workdir = setupRepo("picking");
 		const only = startRun(workdir, { topic: "only", skill: "plan-normal", requestText: "a" }).run;
 		const candidates = listResumeCandidates(workdir);
 		assert.equal(pickDefaultCandidate(workdir, candidates)?.runId, only.run_id);
 
-		// D-001: an unfinished active run wins even when others exist.
+		// v0.6.0 (D-1): no auto-win — two resumable runs are ambiguous here; the
+		// command's binding-first path handles the session-bound case.
 		const second = startRun(workdir, { topic: "second", skill: "plan-normal", requestText: "b" }).run;
 		const withActive = listResumeCandidates(workdir);
-		assert.equal(pickDefaultCandidate(workdir, withActive)?.runId, second.run_id);
+		assert.equal(pickDefaultCandidate(workdir, withActive), null, "two candidates require choosing");
 
 		// Ambiguity: two resumable runs, active pointer names a non-resumable one.
 		const third = startRun(workdir, { topic: "third", skill: "plan-normal", requestText: "c" }).run;
@@ -165,7 +164,7 @@ describe("candidate discovery", () => {
 		const run = startRun(workdir, { topic: "corrupt", skill: "plan-normal", requestText: "a" }).run;
 		createCheckpoint(workdir, { runId: run.run_id, originWorkdir: workdir, workdir });
 		fs.writeFileSync(
-			path.join(workdir, ".git", "pi_plans", "runs", run.run_id, "checkpoint.json"),
+			path.join(workdir, ".git", "pi-plans", "runs", run.run_id, "checkpoint.json"),
 			"{ broken",
 			"utf8",
 		);
@@ -179,27 +178,27 @@ describe("/resume-plans command", () => {
 	it("refuses non-interactive and busy sessions, notifies when nothing is resumable", async () => {
 		const workdir = setupRepo("guards");
 		const noUI = makeCtx(workdir, { hasUI: false });
-		await resumePlansCommand(makePi(noUI) as never, ctxAdapter(noUI) as never, BASE_DIR);
+		await resumePlansCommand(ctxAdapter(noUI) as never, BASE_DIR);
 		assert.ok(noUI.notifies.some((n) => /interactive/.test(n.message)));
 
 		const busy = makeCtx(workdir, { isIdleResult: false });
-		await resumePlansCommand(makePi(busy) as never, ctxAdapter(busy) as never, BASE_DIR);
+		await resumePlansCommand(ctxAdapter(busy) as never, BASE_DIR);
 		assert.ok(busy.notifies.some((n) => /busy/.test(n.message)));
 		assert.equal(busy.userMessages.length, 0);
 
 		const empty = setupRepo("empty-repo");
 		const emptyCtx = makeCtx(empty);
-		await resumePlansCommand(makePi(emptyCtx) as never, ctxAdapter(emptyCtx) as never, BASE_DIR);
+		await resumePlansCommand(ctxAdapter(emptyCtx) as never, BASE_DIR);
 		assert.ok(emptyCtx.notifies.some((n) => /No resumable/.test(n.message)));
 	});
 
 	it("corrupt checkpoints report and change nothing", async () => {
 		const workdir = setupRepo("corrupt-cmd");
 		const run = startRun(workdir, { topic: "corruptcmd", skill: "plan-normal", requestText: "a" }).run;
-		const cpPath = path.join(workdir, ".git", "pi_plans", "runs", run.run_id, "checkpoint.json");
+		const cpPath = path.join(workdir, ".git", "pi-plans", "runs", run.run_id, "checkpoint.json");
 		fs.writeFileSync(cpPath, "{ broken", "utf8");
 		const mock = makeCtx(workdir);
-		await resumePlansCommand(makePi(mock) as never, ctxAdapter(mock) as never, BASE_DIR);
+		await resumePlansCommand(ctxAdapter(mock) as never, BASE_DIR);
 		assert.ok(mock.notifies.some((n) => /corrupt/.test(n.message)));
 		assert.equal(mock.userMessages.length, 0);
 		assert.equal(fs.readFileSync(cpPath, "utf8"), "{ broken");
@@ -222,7 +221,7 @@ describe("/resume-plans command", () => {
 		void cp;
 
 		const mock = makeCtx(workdir);
-		await resumePlansCommand(makePi(mock) as never, ctxAdapter(mock) as never, BASE_DIR);
+		await resumePlansCommand(ctxAdapter(mock) as never, BASE_DIR);
 		assert.equal(mock.userMessages.length, 1, "exactly one kickoff");
 		const brief = mock.userMessages[0]!;
 		assert.match(brief, /PI-PLANS RESUME/);
@@ -241,7 +240,7 @@ describe("/resume-plans command", () => {
 		const latest = startRun(workdir, { topic: "three", skill: "plan-normal", requestText: "c" }).run;
 		setRunStatus(workdir, latest.run_id, "abandoned");
 		const mock = makeCtx(workdir, { selectAnswer: null });
-		await resumePlansCommand(makePi(mock) as never, ctxAdapter(mock) as never, BASE_DIR);
+		await resumePlansCommand(ctxAdapter(mock) as never, BASE_DIR);
 		assert.equal(mock.userMessages.length, 0);
 		assert.ok(mock.notifies.some((n) => /Cancelled/.test(n.message)));
 		assert.equal(mock.selects.length, 1);
@@ -254,7 +253,7 @@ describe("/resume-plans command", () => {
 		const child = spawn("sleep", ["30"], { stdio: "ignore" });
 		try {
 			fs.writeFileSync(
-				path.join(workdir, ".git", "pi_plans", "runs", run.run_id, "owner.json"),
+				path.join(workdir, ".git", "pi-plans", "runs", run.run_id, "owner.json"),
 				JSON.stringify({
 					schema: 1,
 					host: os.hostname(),
@@ -268,7 +267,7 @@ describe("/resume-plans command", () => {
 				"utf8",
 			);
 			const mock = makeCtx(workdir);
-			await resumePlansCommand(makePi(mock) as never, ctxAdapter(mock) as never, BASE_DIR);
+			await resumePlansCommand(ctxAdapter(mock) as never, BASE_DIR);
 			assert.ok(mock.notifies.some((n) => /actively owned/.test(n.message)));
 			assert.equal(mock.userMessages.length, 0);
 		} finally {
@@ -277,8 +276,11 @@ describe("/resume-plans command", () => {
 	});
 
 	it("cross-worktree: cancel changes nothing; confirm migrates artifacts and resets approval", async () => {
-		// Source worktree holds the artifacts inside its own tree.
+		// Source worktree holds the artifacts inside its own tree. D-007 only
+		// applies to a per-worktree root, so pin one; the default root lives in
+		// the shared git common dir and is never migrated.
 		const source = setupRepo("xwt-source", { commit: true });
+		setArtifactRoot(source, "./docs/pi-plans", "user");
 		const run = startRun(source, { topic: "xwt", skill: "plan-normal", requestText: "a" }).run;
 		const cp = createCheckpoint(source, { runId: run.run_id, originWorkdir: source, workdir: source });
 		void cp;
@@ -291,12 +293,12 @@ describe("/resume-plans command", () => {
 		spawnSync("git", ["worktree", "add", target], { cwd: source });
 
 		const cancelMock = makeCtx(target, { confirmAnswer: false });
-		await resumePlansCommand(makePi(cancelMock) as never, ctxAdapter(cancelMock) as never, BASE_DIR);
+		await resumePlansCommand(ctxAdapter(cancelMock) as never, BASE_DIR);
 		assert.equal(cancelMock.userMessages.length, 0);
 		assert.ok(cancelMock.confirmShown.length >= 1);
 
 		const goMock = makeCtx(target, { confirmAnswer: true });
-		await resumePlansCommand(makePi(goMock) as never, ctxAdapter(goMock) as never, BASE_DIR);
+		await resumePlansCommand(ctxAdapter(goMock) as never, BASE_DIR);
 		assert.equal(goMock.userMessages.length, 1, "one kickoff after migration");
 		// Artifacts copied into the target worktree's artifact root.
 		const copied = path.join(target, "docs", "pi-plans", path.basename(run.artifact_dir));
@@ -320,7 +322,7 @@ describe("/resume-plans command", () => {
 		fs.mkdirSync(run.artifact_dir, { recursive: true });
 		fs.writeFileSync(path.join(run.artifact_dir, "PLAN_v1.md"), "# plan", "utf8");
 		const mock = makeCtx(workdir, { confirmAnswer: true });
-		await resumePlansCommand(makePi(mock) as never, ctxAdapter(mock) as never, BASE_DIR);
+		await resumePlansCommand(ctxAdapter(mock) as never, BASE_DIR);
 		assert.equal(mock.userMessages.length, 1);
 		assert.match(mock.userMessages[0]!, /re-run the execution handoff/);
 		assert.ok(mock.confirmShown.some((c) => /Legacy execution run/.test(c.title)));
@@ -328,6 +330,7 @@ describe("/resume-plans command", () => {
 
 	it("migrateRunIntoCurrentWorktree aborts on differing conflicts (F-003)", () => {
 		const source = setupRepo("mig-overwrite", { commit: true });
+		setArtifactRoot(source, "./docs/pi-plans", "user");
 		const run = startRun(source, { topic: "mig", skill: "plan-normal", requestText: "a" }).run;
 		createCheckpoint(source, { runId: run.run_id, originWorkdir: source, workdir: source });
 		fs.mkdirSync(run.artifact_dir, { recursive: true });
@@ -373,7 +376,7 @@ describe("F-004 ledger reconcile (crash window)", () => {
 			questionId: "q-x",
 		});
 		const mock = makeCtx(workdir);
-		await resumePlansCommand(makePi(mock) as never, ctxAdapter(mock) as never, BASE_DIR);
+		await resumePlansCommand(ctxAdapter(mock) as never, BASE_DIR);
 		assert.equal(mock.userMessages.length, 1);
 		const brief = mock.userMessages[0]!;
 		assert.doesNotMatch(brief, /PENDING question/, "answered ledger entry wins");
@@ -383,58 +386,10 @@ describe("F-004 ledger reconcile (crash window)", () => {
 	});
 });
 
-describe("impl-review config crash-window recovery (0.5.4, D-5)", () => {
-	it("both answers in the ledger, none persisted: everything recovers, nothing missing", async () => {
-		const { resolveImplReviewConfig } = await import("../src/resume-command.ts");
-		const ledger = [
-			{ questionId: "termination-condition", answer: "1 round" },
-			{ questionId: "impl-review-reviewer-count", answer: "3" },
-		];
-		const resolved = resolveImplReviewConfig({ completedRounds: 0 }, ledger);
-		assert.equal(resolved.condition, "1 round");
-		assert.ok(resolved.conditionFromLedger);
-		assert.equal(resolved.reviewerCount, 3);
-		assert.ok(resolved.reviewerCountFromLedger);
-		assert.deepEqual(resolved.missing, []);
-	});
-
-	it("only termination answered: reviewer-count is the single missing question", async () => {
-		const { resolveImplReviewConfig } = await import("../src/resume-command.ts");
-		const resolved = resolveImplReviewConfig({ completedRounds: 0 }, [
-			{ questionId: "termination-condition", answer: "goal wait" },
-		]);
-		assert.equal(resolved.condition, "goal wait");
-		assert.equal(resolved.reviewerCount, undefined);
-		assert.deepEqual(resolved.missing, ["impl-review-reviewer-count"]);
-	});
-
-	it("persisted checkpoint wins over the ledger; latest ledger entry wins", async () => {
-		const { resolveImplReviewConfig } = await import("../src/resume-command.ts");
-		const resolved = resolveImplReviewConfig(
-			{ terminationCondition: "1 round", reviewerCount: 2, completedRounds: 0 },
-			[
-				{ questionId: "termination-condition", answer: "goal wait" },
-				{ questionId: "impl-review-reviewer-count", answer: "1" },
-			],
-		);
-		assert.equal(resolved.condition, "1 round");
-		assert.ok(!resolved.conditionFromLedger);
-		assert.equal(resolved.reviewerCount, 2);
-		assert.deepEqual(resolved.missing, []);
-		const staleThenFresh = resolveImplReviewConfig({ completedRounds: 0 }, [
-			{ questionId: "termination-condition", answer: "old" },
-			{ questionId: "termination-condition", answer: "new" },
-		]);
-		assert.equal(staleThenFresh.condition, "new", "latest ledger entry wins");
-	});
-
-	it("non-integer or out-of-range ledger counts are ignored, not adopted", async () => {
-		const { resolveImplReviewConfig } = await import("../src/resume-command.ts");
-		for (const bad of ["0", "4", "three"]) {
-			const resolved = resolveImplReviewConfig({ terminationCondition: "1 round", completedRounds: 0 }, [
-				{ questionId: "impl-review-reviewer-count", answer: bad },
-			]);
-			assert.equal(resolved.reviewerCount, undefined, `ledger answer ${bad} ignored`);
-		}
+describe("impl-review crash-window recovery (removed in v0.6.1)", () => {
+	it("the resolver is gone with the loop: the helper no longer exists", async () => {
+		const mod = await import("../src/resume-command.ts");
+		assert.equal("resolveImplReviewConfig" in mod, false);
 	});
 });
+