pi-plans 0.6.0 → 0.7.0

package/tests/ask-choice.test.ts

@@ -66,41 +66,7 @@ const OPTIONS = [
 ];
 
 describe("ask_choice trailing option", () => {
-	it("renders Auto-refine loop as the trailing option and suppresses Auto-complete", async () => {
-		const tool = loadTool();
-		let seenLabels: string[] = [];
-		const ctx = makeCtx({
-			select: async (_question, labels) => {
-				seenLabels = labels;
-				return labels.find((label) => label.startsWith("Auto-refine loop"));
-			},
-		});
-		const result = await tool.execute("t1", {
-			question: "Ameliorate?",
-			options: OPTIONS,
-			autoComplete: true, // deliberately erroneous: trailing must suppress it
-			trailing: "auto-refine-loop",
-		}, undefined, undefined, ctx);
-
-		assert.equal(seenLabels.at(-1)?.startsWith("Auto-refine loop"), true, "Auto-refine loop must be last");
-		assert.equal(seenLabels.some((label) => label.startsWith("Auto-complete")), false, "Auto-complete must be absent");
-		const text = result.content[0].text as string;
-		assert.match(text, /User selected Auto-refine loop/);
-		assert.match(text, /until no high-severity finding \(hard cap 5 rounds\)/);
-		assert.match(text, /goal wait: continue until no unpassed VCs remain/);
-		assert.match(text, /refine \(role: "reviewer", target: "implementation", reviewers: <configured reviewerCount>\)/);
-		// 0.5.4: the trailing instructions now include the reviewer-count
-		// question with a skill-aware default (D-1/D-2) and the deferred
-		// combined persistence (D-5).
-		assert.match(text, /impl-review-reviewer-count/);
-		assert.match(text, /How many concurrent reviewers should each implementation-review round use\?/);
-		assert.match(text, /1 \(recommended\)/, "default workdir run has no active run → default 1");
-		assert.match(text, /Do not persist yet/);
-		assert.equal(result.details.source, "user");
-		assert.equal(result.details.answer, "Auto-refine loop");
-	});
-
-	it("keeps Auto-complete as the trailing option without the trailing param", async () => {
+	it("keeps Auto-complete as the trailing option (the auto-refine trailing param was removed in v0.6.1)", async () => {
 		const tool = loadTool();
 		let seenLabels: string[] = [];
 		const ctx = makeCtx({
@@ -117,22 +83,9 @@ describe("ask_choice trailing option", () => {
 		assert.equal(seenLabels.at(-1)?.startsWith("Auto-complete"), true);
 		assert.equal(seenLabels.some((label) => label.startsWith("Auto-refine loop")), false);
 	});
-
-	it("never auto-answers a trailing question in headless sessions", async () => {
-		const tool = loadTool();
-		const ctx = makeCtx({ hasUI: false, select: async () => undefined });
-		await assert.rejects(
-			tool.execute("t3", {
-				question: "Ameliorate?",
-				options: OPTIONS,
-				autoComplete: true,
-				trailing: "auto-refine-loop",
-			}, undefined, undefined, ctx),
-			/No UI available/,
-		);
-	});
 });
 
+
 describe("ask_choice panel fitting", () => {
 	it("sanitizes newlines in the question and labels", () => {
 		const fitted = fitAskChoicePanel("Q line1\nQ line2", [{ core: "1. a\nb", display: "1. a\nb — desc" }], 100, 30);

package/tests/ask-form-tool.test.ts

@@ -15,6 +15,7 @@ import { initState, recordDecision, startRun } from "../src/state.ts";
 import { createCheckpoint, loadCheckpoint } from "../src/workflow-state.ts";
 import { reconcileCheckpointWithLedger } from "../src/resume.ts";
 import { readDecisionLedger } from "../src/resume.ts";
+import { setMessagingApi } from "../src/messaging.ts";
 
 type ToolDef = {
 	execute: (id: string, params: any, signal: undefined, update: undefined, ctx: any) => Promise<any>;
@@ -58,7 +59,7 @@ function startActiveRun(workdir: string) {
 }
 
 function makeCtx(workdir: string, overrides: Record<string, unknown> = {}) {
-	return {
+	const ctx = {
 		cwd: workdir,
 		hasUI: true,
 		sessionManager: {},
@@ -70,6 +71,8 @@ function makeCtx(workdir: string, overrides: Record<string, unknown> = {}) {
 			...overrides,
 		},
 	};
+	setMessagingApi({ appendEntry: () => {}, sendMessage: () => {}, sendUserMessage: async () => {} });
+	return ctx;
 }
 
 function recordDecisionEntry(workdir: string, runId: string, entry: Record<string, unknown>): void {
@@ -139,10 +142,6 @@ describe("ask_choice batch validation (R-013b/D-025)", () => {
 			() => tool.execute("t", { question: "single?", options: [{ label: "A" }], questions: [Q1, Q2] }, undefined, undefined, ctx),
 			/not both/,
 		);
-		await assert.rejects(
-			() => tool.execute("t", { questions: [Q1, Q2], trailing: "auto-refine-loop" }, undefined, undefined, ctx),
-			/trailing/,
-		);
 	});
 
 	it("rejects the canonical scope-confirm id in batches (F-003)", async () => {

package/tests/ask-form.test.ts

@@ -37,7 +37,7 @@ describe("form state machine", () => {
 	it("preselects the recommended option as cursor without marking it answered", () => {
 		const state = createFormState(qs(2));
 		assert.deepEqual(state.selection, [0, 0]);
-		// goal-x semantics: a pre-positioned cursor is NOT an answer — chips
+		// a pre-positioned cursor is NOT an answer — chips
 		// stay □ until the user presses Enter (or commits a custom answer).
 		assert.equal(allAnswered(state), false);
 		assert.deepEqual(state.confirmed, [false, false]);
@@ -428,7 +428,7 @@ describe("recommended marker hygiene (0.4.1)", () => {
 	});
 });
 
-describe("themed question frame (pi-goal-x alignment, 0.4.1)", () => {
+describe("themed question frame (0.4.1)", () => {
 	const T: FormTheme = {
 		fg: (c, t) => `⟪${c}⟩${t}⟪/⟫`,
 		bg: (c, t) => `⟦${c}⟧${t}⟦/⟧`,

package/tests/auditor.test.ts

@@ -0,0 +1,111 @@
+/** Tests for the completion auditor (v0.6.1): verdict parsing, rollback
+ * boundaries, skipped-pass, and no-cover exclusion. */
+
+import * as assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { CheckItem } from "../src/plan.ts";
+import { buildTaskView } from "../src/tasks.ts";
+import { applyAuditOutcome, buildAuditTask, parseAuditReport, presolvedCheckIds } from "../src/auditor.ts";
+import { parsePlanTasks } from "../src/plan.ts";
+
+const PLAN = `## Tasks
+
+- Task-1: parser — files: src/a.ts; wave: 1
+- Task-2: tool — files: src/b.ts; wave: 1
+- Task-3: core — deps: Task-1, Task-2; files: src/c.ts; wave: 2
+  - Task-3.1: injection — files: src/c.ts
+
+## Verification Checks
+
+- [ ] \`VC-001\` covers \`Task-1\`; pass condition: parser ok
+- [ ] \`VC-002\` covers \`Task-2\` and \`Task-3\`; pass condition: tool+core ok
+- [ ] \`VC-003\` covers \`Task-3.1\`; pass condition: injection ok
+- [ ] \`VC-004\` covers nothing here; pass condition: orphan
+`;
+
+function checks(done: string[] = []): CheckItem[] {
+	const raw = PLAN.split("## Verification Checks")[1] ?? "";
+	const items: CheckItem[] = [];
+	for (const line of raw.split("\n")) {
+		const m = line.match(/^- \[ \] `(VC-\d+)` (.+)$/);
+		if (m) items.push({ id: m[1], text: m[2], done: done.includes(m[1]) });
+	}
+	return items;
+}
+
+function view(progress?: Record<string, { status: "complete" | "skipped" }>) {
+	return buildTaskView(parsePlanTasks(PLAN), progress);
+}
+
+describe("auditor parsing", () => {
+	it("parses per-check verdicts and ignores unknown ids", () => {
+		const report = [
+			"- `VC-001` — verdict: pass; evidence: src/a.ts; note: ok",
+			"- `VC-002` — verdict: fail; evidence: src/c.ts; note: missing",
+			"- `VC-999` — verdict: pass; evidence: n/a",
+		].join("\n");
+		const { passed, failed } = parseAuditReport(report, checks());
+		assert.deepEqual(passed, ["VC-001"]);
+		assert.deepEqual(failed, ["VC-002"]);
+	});
+
+	it("conflicting verdicts for one check resolve to fail", () => {
+		const report = "- `VC-001` — verdict: pass; note: a\n- `VC-001` — verdict: fail; note: b";
+		const { passed, failed } = parseAuditReport(report, checks());
+		assert.deepEqual(passed, []);
+		assert.deepEqual(failed, ["VC-001"]);
+	});
+
+	it("builds the brief with the auditable checks only", () => {
+		const task = buildAuditTask("/tmp/PLAN_v1.md", checks(), view(), 1);
+		assert.match(task, /read-only/i);
+		assert.match(task, /`VC-001`/);
+		assert.doesNotMatch(task, /`VC-999`/);
+	});
+});
+
+describe("audit rollback boundaries", () => {
+	it("failed multi-cover check rolls back every covered task", () => {
+		const tasks = view({ "Task-1": { status: "complete" }, "Task-2": { status: "complete" }, "Task-3": { status: "complete" }, "Task-3.1": { status: "complete" } });
+		const checklist = checks();
+		const outcome = applyAuditOutcome(checklist, tasks, 1, ["VC-001"], ["VC-002"], "report");
+		assert.deepEqual(outcome.rolledBack.sort(), ["Task-2", "Task-3", "Task-3.1"]);
+		// Passed check stays done; its task stays closed.
+		assert.equal(checks().length, 4);
+		assert.equal(tasks.find((t) => t.id === "Task-1")?.status, "complete");
+		assert.equal(tasks.find((t) => t.id === "Task-2")?.status, "pending");
+	});
+
+	it("covering the parent cascades to subtasks even when the parent alone is listed", () => {
+		const tasks = view({ "Task-3": { status: "complete" }, "Task-3.1": { status: "complete" } });
+		const outcome = applyAuditOutcome(checks(), tasks, 1, [], ["VC-002"], "report");
+		assert.ok(outcome.rolledBack.includes("Task-3.1"), "subtask reopens with the parent");
+	});
+
+	it("skipped tasks reopen too (skip state cleared)", () => {
+		const tasks = view({ "Task-2": { status: "skipped" } });
+		const outcome = applyAuditOutcome(checks(), tasks, 1, [], ["VC-002"], "report");
+		assert.ok(outcome.rolledBack.includes("Task-2"));
+		assert.equal(tasks.find((t) => t.id === "Task-2")?.skipReason, undefined);
+	});
+
+	it("checks with no task coverage are excluded from presolved audit", () => {
+		const tasks = view({ "Task-1": { status: "complete" }, "Task-2": { status: "complete" }, "Task-3": { status: "complete" }, "Task-3.1": { status: "complete" } });
+		const presolved = presolvedCheckIds(checks(), tasks);
+		assert.ok(!presolved.includes("VC-004"), "no-cover check is never audited");
+	});
+
+	it("mixed coverage (skipped + complete siblings) resolves as skipped-pass (I-007)", () => {
+		const tasks = view({ "Task-2": { status: "skipped" }, "Task-3": { status: "complete" }, "Task-3.1": { status: "complete" } });
+		const presolved = presolvedCheckIds(checks(), tasks);
+		assert.ok(presolved.includes("VC-002"), "skipped + complete siblings presolve");
+		assert.ok(!presolved.includes("VC-003"), "pure complete coverage goes to the auditor");
+	});
+
+	it("all-skipped coverage resolves as skipped-pass", () => {
+		const tasks = view({ "Task-3": { status: "skipped" }, "Task-3.1": { status: "skipped" } });
+		const presolved = presolvedCheckIds(checks(), tasks);
+		assert.ok(presolved.includes("VC-003"));
+		assert.ok(!presolved.includes("VC-002"), "mixed coverage needs the auditor");
+	});
+});

package/tests/auto-approve.test.ts

@@ -10,7 +10,7 @@ import * as path from "node:path";
 import { after, before, describe, it } from "node:test";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerAskChoiceTool } from "../tools/ask-choice.ts";
-import { executeHandoff, setCurrentApi } from "../tools/execute-plan.ts";
+import { executeHandoff } from "../tools/execute-plan.ts";
 import {
 	AUTO_APPROVE_ENV,
 	assertAutoApprovable,
@@ -18,6 +18,7 @@ import {
 	isExternalStateQuestion,
 } from "../src/auto-approve.ts";
 import { getExecution, stopExecution } from "../src/exec.ts";
+import { setMessagingApi } from "../src/messaging.ts";
 
 type ToolDef = {
 	execute: (id: string, params: any, signal: undefined, update: undefined, ctx: any) => Promise<any>;
@@ -55,7 +56,7 @@ function loadTool(): ToolDef {
 function makeCtx(opts: { hasUI?: boolean } = {}): any {
 	selectCalls = 0;
 	confirmCalls = 0;
-	return {
+	const ctx = {
 		cwd: root,
 		hasUI: opts.hasUI ?? false,
 		sessionManager: {},
@@ -74,6 +75,8 @@ function makeCtx(opts: { hasUI?: boolean } = {}): any {
 			theme: { fg: (_kind: string, text: string) => text, bold: (text: string) => text },
 		},
 	};
+	setMessagingApi({ appendEntry: () => {}, sendMessage: () => {}, sendUserMessage: async () => {} });
+	return ctx;
 }
 
 const LIFECYCLE_OPTIONS = [
@@ -241,15 +244,9 @@ describe("execute_handoff under auto-approve", () => {
 	});
 
 	function makeExecMocks() {
-		const pi = {
-			appendEntry: () => {},
-			sendMessage: () => {},
-			setModel: async () => true,
-		} as unknown as ExtensionAPI;
-		setCurrentApi(pi);
 		const ctx = makeCtx({ hasUI: false });
 		ctx.cwd = root;
-		return { pi, ctx };
+		return { ctx };
 	}
 
 	it("approves headlessly with an [auto-approve] annotated result and no confirm call", async () => {
@@ -261,7 +258,7 @@ describe("execute_handoff under auto-approve", () => {
 			assert.match(outcome.message, /^\[auto-approve\] Execution approved/);
 			assert.equal(confirmCalls, 0, "no confirm prompt may open");
 		} finally {
-			if (getExecution()) await stopExecution({ appendEntry: () => {}, sendMessage: () => {} } as any, ctx, "cleanup");
+			if (getExecution()) await stopExecution(ctx, "cleanup");
 			setEnv(undefined);
 		}
 	});

package/tests/autocomplete.test.ts

@@ -14,9 +14,9 @@ import {
 	recordAskChoice,
 	registerAutoCompleteTurnHandlers,
 	restoreAutoCompleteFromSession,
-	setAutoCompleteApi,
 } from "../src/autocomplete.ts";
 import { initState, setRunStatus, startRun } from "../src/state.ts";
+import { setMessagingApi } from "../src/messaging.ts";
 
 let root: string;
 
@@ -46,7 +46,6 @@ before(() => {
 });
 
 after(() => {
-	setAutoCompleteApi(null);
 	fs.rmSync(root, { recursive: true, force: true });
 });
 
@@ -54,8 +53,8 @@ describe("Auto-complete state", () => {
 	it("enables only for the active planning run and restores only while planning", () => {
 		const { workdir, runId } = makeRun("restore");
 		const entries: any[] = [];
-		setAutoCompleteApi({ appendEntry: (customType: string, data: unknown) => entries.push({ type: "custom", customType, data }) } as any);
 		const ctx = makeContext(workdir);
+		setMessagingApi({ appendEntry: (customType: string, data: unknown) => entries.push({ type: "custom", customType, data }), sendMessage: () => {}, sendUserMessage: async () => {} });
 
 		assert.equal(enableAutoComplete(ctx), true);
 		assert.equal(autoCompleteStatus(ctx), "enabled");
@@ -79,8 +78,8 @@ describe("Auto-complete state", () => {
 	it("clears explicitly and marks plan writes as a continuation boundary", () => {
 		const { workdir } = makeRun("clear");
 		const entries: any[] = [];
-		setAutoCompleteApi({ appendEntry: (customType: string, data: unknown) => entries.push({ customType, data }) } as any);
 		const ctx = makeContext(workdir);
+		setMessagingApi({ appendEntry: (customType: string, data: unknown) => entries.push({ customType, data }), sendMessage: () => {}, sendUserMessage: async () => {} });
 		enableAutoComplete(ctx);
 		markPlanWritten(ctx);
 		recordAskChoice(ctx, true);
@@ -98,12 +97,10 @@ describe("Auto-complete continuation", () => {
 		const handlers = new Map<string, Function[]>();
 		const pi: any = {
 			on: (name: string, handler: Function) => handlers.set(name, [...(handlers.get(name) ?? []), handler]),
-			appendEntry: () => {},
-			sendUserMessage: async (content: string, options: unknown) => sent.push({ content, options }),
 		};
-		setAutoCompleteApi(pi);
 		registerAutoCompleteTurnHandlers(pi);
 		const ctx = makeContext(workdir, session);
+		setMessagingApi({ appendEntry: () => {}, sendMessage: () => {}, sendUserMessage: async (content: string, options: unknown) => sent.push({ content, options }) });
 		enableAutoComplete(ctx);
 		await handlers.get("turn_start")?.[0]?.({}, ctx);
 		recordAskChoice(ctx, true);
@@ -132,10 +129,10 @@ describe("ask_choice Auto-complete wiring", () => {
 		assert.match(source, /isAutoCompleteEnabled/);
 		assert.match(source, /recordAskChoice\(ctx, true\)/);
 		assert.match(source, /autoComplete && selected\.startsWith\("Auto-complete"\)/);
-		// Trailing option: Auto-refine loop replaces Auto-complete and is suppressed in headless sessions.
-		assert.match(source, /trailing === undefined/);
-		assert.match(source, /AUTO_REFINE_LOOP_LABEL/);
-		assert.match(source, /trailing && selected\.startsWith\("Auto-refine loop"\)/);
+		// v0.6.1: the auto-refine trailing param was removed with the
+		// implementation-review loop.
+		assert.doesNotMatch(source, /auto-refine-loop/);
+		assert.doesNotMatch(source, /AUTO_REFINE_LOOP_LABEL/);
 		const indexSource = fs.readFileSync(path.join(process.cwd(), "index.ts"), "utf8");
 		assert.match(indexSource, /plans-autocomplete-stop/);
 		assert.match(indexSource, /autoCompleteStatus\(ctx\)/);

package/tests/code-graph-apply-action.test.ts

@@ -51,9 +51,9 @@ async function setupIndexedRepo(): Promise<{ root: string; store: Store; cleanup
 		tsx: makeBackend("tsx", ParserCtor, runtime.runtime.parser.tsx),
 		python: new PythonBackend(ParserCtor, runtime.runtime.parser.python),
 	};
-	fs.mkdirSync(path.join(root, ".git", "pi_plans"), { recursive: true });
+	fs.mkdirSync(path.join(root, ".git", "pi-plans"), { recursive: true });
 	const store = new Store(
-		{ dbPath: path.join(root, ".git", "pi_plans", "code_graph.db"), worktreeRoot: root, gitCommonDir: path.join(root, ".git") },
+		{ dbPath: path.join(root, ".git", "pi-plans", "code_graph.db"), worktreeRoot: root, gitCommonDir: path.join(root, ".git") },
 		runtime.runtime.sqlite,
 	);
 	runIndex({ store, worktreeRoot: root, parsers, reindex: false });

package/tests/code-graph-commands.test.ts

@@ -31,7 +31,7 @@ function initRepo(): { root: string; cleanup: () => void } {
 	fs.writeFileSync(path.join(root, "helper.ts"), "export function twice(n: number): number { return n * 2; }\n");
 	git(root, ["add", "-A"]);
 	git(root, ["commit", "-m", "init"]);
-	fs.mkdirSync(path.join(root, ".git", "pi_plans"), { recursive: true });
+	fs.mkdirSync(path.join(root, ".git", "pi-plans"), { recursive: true });
 	const canonicalRoot = fs.realpathSync(root);
 	return {
 		root: canonicalRoot,
@@ -63,7 +63,7 @@ async function loadParsers() {
 
 function openStore(root: string, sqlite: typeof import("node:sqlite")): Store {
 	const canonicalRoot = fs.realpathSync(root);
-	const dbPath = path.join(canonicalRoot, ".git", "pi_plans", "code_graph.db");
+	const dbPath = path.join(canonicalRoot, ".git", "pi-plans", "code_graph.db");
 	fs.mkdirSync(path.dirname(dbPath), { recursive: true });
 	return new Store({ dbPath, worktreeRoot: canonicalRoot, gitCommonDir: path.join(canonicalRoot, ".git") }, sqlite);
 }

package/tests/code-graph-index.test.ts

@@ -63,7 +63,7 @@ test("runIndex indexes files, writes rows, and screening excludes full_code", as
 	};
 	const sqlite = await import("node:sqlite");
 	const commonDir = git(worktreeRoot, ["rev-parse", "--git-common-dir"]);
-	const dbDir = path.join(path.resolve(worktreeRoot, commonDir), "pi_plans");
+	const dbDir = path.join(path.resolve(worktreeRoot, commonDir), "pi-plans");
 	fs.mkdirSync(dbDir, { recursive: true });
 	const dbPath = path.join(dbDir, "code_graph.db");
 	try { fs.unlinkSync(dbPath); } catch { /* ignore */ }
@@ -151,7 +151,7 @@ test("runIndex with opts.paths indexes only hit paths and purges missing ones",
 		tsx: makeBackend("tsx", ParserCtor, runtime.runtime.parser.tsx),
 		python: new PythonBackend(ParserCtor, runtime.runtime.parser.python),
 	};
-	const stateRoot = path.join(worktreeRoot, ".git", "pi_plans");
+	const stateRoot = path.join(worktreeRoot, ".git", "pi-plans");
 	fs.mkdirSync(stateRoot, { recursive: true });
 	const store = new Store({ dbPath: path.join(stateRoot, "code_graph.db"), worktreeRoot, gitCommonDir: path.join(worktreeRoot, ".git") }, runtime.runtime.sqlite);
 	t.after(() => store.close());

package/tests/code-graph-loop.e2e.test.ts

@@ -57,7 +57,7 @@ test("closed loop: init → mutation → apply → drift → final-commit → cl
 	const { root, cleanup } = initRepo();
 	t.after(cleanup);
 
-	const stateRoot = path.join(root, ".git", "pi_plans");
+	const stateRoot = path.join(root, ".git", "pi-plans");
 	fs.mkdirSync(stateRoot, { recursive: true });
 	const dbPath = path.join(stateRoot, "code_graph.db");
 	const store = new Store({ dbPath, worktreeRoot: root, gitCommonDir: path.join(root, ".git") }, runtime.runtime.sqlite);

package/tests/code-graph-mutations.test.ts

@@ -51,7 +51,7 @@ test("updateFunction propagates offsets, rebuilds source exactly, and applies by
 	if (!runtime.status.parserAvailable || !runtime.status.sqliteAvailable) return;
 	const { root, cleanup } = initRepo();
 	t.after(cleanup);
-	const stateRoot = path.join(root, ".git", "pi_plans");
+	const stateRoot = path.join(root, ".git", "pi-plans");
 	fs.mkdirSync(stateRoot, { recursive: true });
 	const store = new Store({ dbPath: path.join(stateRoot, "g.db"), worktreeRoot: root, gitCommonDir: path.join(root, ".git") }, runtime.runtime.sqlite);
 	t.after(() => store.close());

package/tests/code-graph-rollback.test.ts

@@ -59,7 +59,7 @@ test("indexer rolls back the whole file batch when an emit step throws", async (
 	};
 	const sqlite = await import("node:sqlite");
 	const commonDir = git(worktreeRoot, ["rev-parse", "--git-common-dir"]);
-	const dbDir = path.join(path.resolve(worktreeRoot, commonDir), "pi_plans");
+	const dbDir = path.join(path.resolve(worktreeRoot, commonDir), "pi-plans");
 	fs.mkdirSync(dbDir, { recursive: true });
 	const dbPath = path.join(dbDir, "code_graph.db");
 	try { fs.unlinkSync(dbPath); } catch { /* ignore */ }

package/tests/code-graph-v05.test.ts

@@ -362,8 +362,8 @@ describe("watch lifecycle (VC-006)", () => {
 		execSync('git config user.email t@t && git config user.name t', { cwd: root, shell: "/bin/bash" });
 		const { parsers, sqlite } = await makeParsers();
 		fs.writeFileSync(path.join(root, "a.ts"), "export function alpha() { return 1; }\n");
-		// The watcher always opens the CANONICAL db under .git/pi_plans/.
-		const dbPath = path.join(root, ".git", "pi_plans", "code_graph.db");
+		// The watcher always opens the CANONICAL db under .git/pi-plans/.
+		const dbPath = path.join(root, ".git", "pi-plans", "code_graph.db");
 		fs.mkdirSync(path.dirname(dbPath), { recursive: true });
 		const store = new Store({ dbPath, worktreeRoot: root, gitCommonDir: path.join(root, ".git") }, sqlite);
 		await runIndex({ store, worktreeRoot: root, parsers });

package/tests/compaction.test.ts

@@ -245,7 +245,7 @@ describe("pi-vcc compaction", () => {
 		assert.match(result.compaction.summary, /Modified: src\/compaction\.ts/);
 		assert.match(result.compaction.summary, /Read: src\/exec\.ts/);
 		assert.match(result.compaction.summary, /\[Outstanding Context\]/);
-		assert.match(result.compaction.summary, /Current implementation item: I-002/);
+		assert.match(result.compaction.summary, /Current task: I-002/);
 		assert.match(result.compaction.summary, /Previous compact summary: Legacy Summary Earlier compact facts\./);
 		assert.match(result.compaction.summary, /\[User Preferences\]/);
 		assert.match(result.compaction.summary, /Always keep ASCII output/);