pi-plans 0.6.0 → 0.8.0

package/tests/analyze-refs.test.ts

@@ -12,13 +12,22 @@ import { initState, setRole, setLanguage, startRun, readActive } from "../src/st
 const ROOT = path.dirname(path.dirname(url.fileURLToPath(import.meta.url)));
 
 let tmpRoot: string;
+let globalDir: string;
+let previousGlobalDir: string | undefined;
 
 before(() => {
 	tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-analyze-refs-"));
+	// Isolate the global reviewer config (F-002): never touch ~/.pi/pi-plans.
+	previousGlobalDir = process.env.PI_PLANS_GLOBAL_DIR;
+	globalDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-global-analyze-refs-"));
+	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(tmpRoot, { recursive: true, force: true });
+	fs.rmSync(globalDir, { recursive: true, force: true });
 });
 
 function mkWorkdir(name: string): string {
@@ -102,7 +111,7 @@ function subagentLines(workdir: string): Array<any> {
 		.map((line) => JSON.parse(line));
 }
 
-describe("analyze_refs gates", () => {
+	describe("analyze_refs gates", () => {
 	it("refuses when no pi-plans state exists", async () => {
 		const workdir = mkWorkdir("gates-no-state");
 		const tool = loadTool();
@@ -112,35 +121,43 @@ describe("analyze_refs gates", () => {
 		);
 	});
 
-	it("refuses with role-setting guidance when reviewer mode is invalid", async () => {
-		const workdir = mkWorkdir("gates-bad-mode");
+	it("refuses with embedded text guidance when the reviewer model is unconfirmed (headless)", async () => {
+		const workdir = mkWorkdir("gates-unconfirmed");
 		initState(workdir);
-		const configPath = path.join(workdir, ".git", "pi_plans", "config.json");
-		const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
-		config.reviewer.mode = "bogus";
-		fs.writeFileSync(configPath, `${JSON.stringify(config, null, "\t")}\n`, "utf8");
 		const tool = loadTool();
 		await assert.rejects(
 			tool.execute("c1", { refs: [{ id: "ref-1", localPath: "." }] }, undefined, undefined, headlessCtx(workdir)),
-			/reviewer role mode is missing or invalid/,
+			/model was never confirmed/,
 		);
 	});
 
-	it("refuses current-session reviewer mode with a switch-to-delegated message", async () => {
+	it("ignores the reviewer mode entirely (Q-4=B): current-session proceeds once a model is confirmed", async () => {
 		const workdir = mkWorkdir("gates-current-session");
 		initState(workdir);
-		setRole(workdir, { role: "reviewer", mode: "current-session" });
-		const tool = loadTool();
-		await assert.rejects(
-			tool.execute("c1", { refs: [{ id: "ref-1", localPath: "." }] }, undefined, undefined, headlessCtx(workdir)),
-			/current-session.*delegated-subagent/s,
+		setRole(workdir, { role: "reviewer", mode: "current-session", modelSelector: "fake/model", confirmed: true });
+		const refDir = path.join(workdir, "refs", "solo");
+		fs.mkdirSync(refDir, { recursive: true });
+		const restore = withFakePi(
+			fakePiScript(
+				`emit({ type: "message_end", message: { role: "assistant", model: "fake/model", content: [{ type: "text", text: "OK" }] } });`,
+			),
 		);
+		const tool = loadTool();
+		try {
+			const result = await tool.execute("c1", { refs: [{ id: "ref-1", localPath: refDir }] }, undefined, undefined, headlessCtx(workdir));
+			assert.match(result.content[0]!.text, /mode is current-session, but analyze_refs always spawns/);
+			assert.match(result.content[0]!.text, /OK/);
+		} finally {
+			restore();
+		}
 	});
 
-	it("refuses with confirmation guidance when the reviewer model is unconfirmed", async () => {
-		const workdir = mkWorkdir("gates-unconfirmed");
+	it("requires a confirmed model even in current-session mode (analysis always spawns)", async () => {
+		const workdir = mkWorkdir("gates-current-session-unconfirmed");
 		initState(workdir);
-		setRole(workdir, { role: "reviewer", mode: "delegated-subagent" });
+		// 'inherit' fully resets selector AND confirmation — the prior test's
+		// confirmed selector must not carry over (the global config is shared).
+		setRole(workdir, { role: "reviewer", mode: "current-session", modelSelector: "inherit" });
 		const tool = loadTool();
 		await assert.rejects(
 			tool.execute("c1", { refs: [{ id: "ref-1", localPath: "." }] }, undefined, undefined, headlessCtx(workdir)),
@@ -310,7 +327,7 @@ describe("analyze_refs fanout", () => {
 			const result = await tool.execute("c1", { refs: [{ id: "ref-1", localPath: refDir }] }, undefined, undefined, headlessCtx(workdir));
 			assert.match(result.content[0]!.text, /### pi-plans-refs-adhoc-ref-1/);
 			assert.equal(readActive(workdir), null);
-			const ledger = path.join(workdir, ".git", "pi_plans", "runs");
+			const ledger = path.join(workdir, ".git", "pi-plans", "runs");
 			const runs = fs.existsSync(ledger) ? fs.readdirSync(ledger) : [];
 			const spawnFiles = runs.flatMap((run) =>
 				fs.existsSync(path.join(ledger, run, "subagents.jsonl")) ? [fs.readFileSync(path.join(ledger, run, "subagents.jsonl"), "utf8")] : [],

package/tests/ask-choice-schema.test.ts

@@ -157,18 +157,6 @@ describe("VC-2 · hardening does not wound legitimate single-question shapes", (
 		assert.equal(Value.Check(AskChoiceParams as never, wellFormed), true);
 	});
 
-	it("single question with trailing + autoComplete:false passes Value.Check", () => {
-		const wellFormed = {
-			question: "实现评审循环如何终止？",
-			options: [
-				{ label: "goal wait：直到无未通过 VC", recommended: true },
-				{ label: "直到无高危发现（硬帽 5 轮）" },
-			],
-			trailing: "auto-refine-loop",
-			autoComplete: false,
-		};
-		assert.equal(Value.Check(AskChoiceParams as never, wellFormed), true);
-	});
 });
 
 describe("VC-3 · zero-recommended batches reject loudly with zero side effects", () => {

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,210 @@
+/** Tests for the execution reviewer: tri-state verdict parsing, contract
+ * coverage, 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 { auditRollbackSet, buildTaskView } from "../src/tasks.ts";
+import {
+	applyAuditOutcome,
+	auditablePendingChecks,
+	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);
+}
+
+const ALL_IDS = ["VC-001", "VC-002", "VC-003", "VC-004"];
+
+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, undeterminable } = parseAuditReport(report, ALL_IDS);
+		assert.deepEqual(passed, ["VC-001"]);
+		assert.deepEqual(failed, ["VC-002"]);
+		assert.deepEqual(undeterminable.sort(), ["VC-003", "VC-004"]);
+	});
+
+	it("parses verdicts wrapped in markdown emphasis", () => {
+		// Regression: `verdict: **pass**` used to parse as nothing, and the
+		// caller's fail-closed rule then rolled the entire run back.
+		const report = [
+			"- `VC-001` — verdict: **pass**; evidence: src/a.ts",
+			"- `VC-002` — verdict: **fail**; evidence: src/c.ts",
+			"- `VC-003` — verdict: *pass*; evidence: src/d.ts",
+			"- `VC-004` — verdict: `pass`; evidence: src/e.ts",
+		].join("\n");
+		const { passed, failed, undeterminable } = parseAuditReport(report, ALL_IDS);
+		assert.deepEqual(passed, ["VC-001", "VC-003", "VC-004"]);
+		assert.deepEqual(failed, ["VC-002"]);
+		assert.deepEqual(undeterminable, []);
+	});
+
+	it("does not read a verdict word prefix as a verdict", () => {
+		const report = ["- `VC-001` — verdict: passed; evidence: x", "- `VC-002` — verdict: failing; evidence: y"].join("\n");
+		const { passed, failed, undeterminable } = parseAuditReport(report, ALL_IDS);
+		assert.deepEqual(passed, []);
+		assert.deepEqual(failed, []);
+		assert.deepEqual(undeterminable.sort(), ["VC-001", "VC-002", "VC-003", "VC-004"]);
+	});
+
+	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, ALL_IDS);
+		assert.deepEqual(passed, []);
+		assert.deepEqual(failed, ["VC-001"]);
+	});
+
+	it("reads an explicit undeterminable verdict", () => {
+		const report = "- `VC-001` — verdict: pass\n- `VC-002` — verdict: undeterminable; evidence: bash not granted";
+		const { passed, failed, undeterminable } = parseAuditReport(report, ALL_IDS);
+		assert.deepEqual(passed, ["VC-001"]);
+		assert.deepEqual(failed, []);
+		assert.deepEqual(undeterminable.sort(), ["VC-002", "VC-003", "VC-004"]);
+	});
+
+	it("treats a reviewer-shaped report as undeterminable, never as failure", () => {
+		// Regression: agents/reviewer.md was the auditor's system prompt and
+		// mandates `## Findings` / `## Questions` with F-### lines and never
+		// says "verdict". Under fail-closed that whole shape read as "every
+		// check failed" and rolled the run back.
+		const report = [
+			"## Findings",
+			"",
+			"- `F-001` — severity: high; affected: VC-001; evidence: src/a.ts; impact: x; recommended fix: y; suggested disposition: accept.",
+			"",
+			"## Questions",
+			"",
+			"None.",
+		].join("\n");
+		const { passed, failed, undeterminable } = parseAuditReport(report, ALL_IDS);
+		assert.deepEqual(passed, []);
+		assert.deepEqual(failed, [], "a reviewer-shaped report is not a failed audit");
+		assert.deepEqual(undeterminable.sort(), ["VC-001", "VC-002", "VC-003", "VC-004"]);
+	});
+
+	it("classifies a partially covered report per check", () => {
+		const report = "- `VC-001` — verdict: pass\n- `VC-003` — verdict: **pass**";
+		const { passed, failed, undeterminable } = parseAuditReport(report, ALL_IDS);
+		assert.deepEqual(passed, ["VC-001", "VC-003"]);
+		assert.deepEqual(failed, []);
+		assert.deepEqual(undeterminable.sort(), ["VC-002", "VC-004"]);
+	});
+
+	it("builds the brief with the auditable pending 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`/);
+		assert.doesNotMatch(task, /`VC-004`/, "a check covering no task is never audited");
+	});
+
+	it("brief states the tri-state contract and forbids fail-for-want-of-evidence", () => {
+		const task = buildAuditTask("/tmp/PLAN_v1.md", checks(), view(), 1);
+		assert.match(task, /verdict: pass \| fail \| undeterminable/);
+		assert.match(task, /never report `fail` for want of evidence/i);
+	});
+
+	it("brief omits checks already done in an earlier round", () => {
+		// Regression: the brief listed every auditable check, so a round-2
+		// auditor that legitimately skipped the satisfied ones looked like a
+		// contract violation -- and, with no rollback to produce progress, the
+		// budget climbed to the cap and the run livelocked.
+		const done = buildAuditTask("/tmp/PLAN_v1.md", checks(["VC-001"]), view(), 2);
+		assert.doesNotMatch(done, /`VC-001`/);
+		assert.match(done, /`VC-002`/);
+		assert.deepEqual(
+			auditablePendingChecks(checks(["VC-001"]), view()).map((item) => item.id),
+			["VC-002", "VC-003"],
+		);
+	});
+
+	it("applyAuditOutcome classifies without touching the checklist or task tree", () => {
+		const checklist = checks();
+		const tasks = view({ "Task-1": { status: "complete" }, "Task-2": { status: "complete" }, "Task-3": { status: "complete" }, "Task-3.1": { status: "complete" } });
+		const parsed = parseAuditReport("- `VC-001` — verdict: pass\n- `VC-002` — verdict: fail", ["VC-001", "VC-002"]);
+		const outcome = applyAuditOutcome(3, parsed, "report text");
+		assert.deepEqual(outcome.passed, ["VC-001"]);
+		assert.deepEqual(outcome.failed, ["VC-002"]);
+		assert.deepEqual(outcome.undeterminable, []);
+		assert.equal(outcome.round, 3);
+		assert.equal(outcome.report, "report text");
+		assert.equal(checklist.every((item) => item.done === false), true, "no done flag written here");
+		assert.equal(tasks.find((t) => t.id === "Task-2")?.status, "complete", "no rollback here");
+	});
+});
+
+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 rolledBack = auditRollbackSet(tasks, checks(), "VC-002");
+		assert.deepEqual(rolledBack.sort(), ["Task-2", "Task-3", "Task-3.1"]);
+		// A check that passed keeps its task closed.
+		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" } });
+		assert.ok(auditRollbackSet(tasks, checks(), "VC-002").includes("Task-3.1"), "subtask reopens with the parent");
+	});
+
+	it("skipped tasks reopen too (skip state cleared)", () => {
+		const tasks = view({ "Task-2": { status: "skipped" } });
+		assert.ok(auditRollbackSet(tasks, checks(), "VC-002").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());