pi-plans 0.5.7 → 0.7.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-pros-cons.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Feature 5 (v0.6.0): every AI-written ask_choice option must state its
+ * advantage AND its drawback as '✓ <advantage> / ✗ <drawback>' in the
+ * configured language.
+ *
+ * The rule is SOFT GUIDANCE (deliberately — no runtime validation, no new
+ * schema fields), so these tests pin the *contract text* the model actually
+ * reads: the Option schema, the tool description, the promptGuidelines, the
+ * batch/single `options` arrays, the six skills, and the normative reference
+ * doc. They also prove the convention is actually RENDERABLE by the existing
+ * form renderer, so guidance can never drift away from what users see.
+ */
+
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, it } from "node:test";
+import { Value } from "typebox/value";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Option, AskChoiceParams, BatchQuestionParams, registerAskChoiceTool } from "../tools/ask-choice.ts";
+import { createFormState, formRender, type FormQuestion } from "../src/ask-form.ts";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+const PRO = "✓";
+const CON = "✗";
+
+interface ToolDef {
+	name: string;
+	description: string;
+	promptSnippet: string;
+	promptGuidelines: string[];
+	parameters: unknown;
+	execute: (id: string, params: unknown, signal: undefined, update: undefined, ctx: unknown) => Promise<unknown>;
+}
+
+function loadTool(): ToolDef {
+	let tool: ToolDef | undefined;
+	const pi = { registerTool: (definition: ToolDef) => { tool = definition; } } as unknown as ExtensionAPI;
+	registerAskChoiceTool(pi);
+	if (!tool) throw new Error("ask_choice tool not registered");
+	return tool;
+}
+
+/** Read a TypeBox property description out of a schema object. */
+function propertyDescription(schema: unknown, property: string): string {
+	const properties = (schema as { properties?: Record<string, { description?: string }> }).properties;
+	const found = properties?.[property]?.description;
+	assert.equal(typeof found, "string", `expected a description on property ${property}`);
+	return found!;
+}
+
+const SKILL_DIRS = ["planning", "debug-and-plan", "plan-small", "plan-normal", "plan-big", "plan-with-refs"];
+
+describe("ask_choice pros/cons contract (v0.6.0 feature 5)", () => {
+	it("Option.description requires both halves via the ✓ / ✗ markers", () => {
+		const text = propertyDescription(Option, "description");
+		assert.ok(text.includes(PRO), "description must show the advantage marker");
+		assert.ok(text.includes(CON), "description must show the drawback marker");
+		assert.ok(/drawback/i.test(text), "description must name the drawback half");
+		assert.ok(/advantage/i.test(text), "description must name the advantage half");
+		assert.ok(/configured language/i.test(text), "description must pin the configured language");
+	});
+
+	it("the registered tool description states the rule and exempts the tool-appended tails", () => {
+		const tool = loadTool();
+		assert.ok(tool.description.includes(PRO) && tool.description.includes(CON));
+		assert.ok(/advantage/i.test(tool.description) && /drawback/i.test(tool.description));
+		assert.ok(/Other/.test(tool.description) && /Auto-complete/.test(tool.description));
+	});
+
+	it("promptGuidelines carry the rule as an imperative, not as new schema fields", () => {
+		const tool = loadTool();
+		assert.ok(Array.isArray(tool.promptGuidelines));
+		const joined = tool.promptGuidelines.join("\n");
+		assert.ok(joined.includes(PRO) && joined.includes(CON), "a guideline must carry the markers");
+		assert.ok(/drawback/i.test(joined), "a guideline must name the drawback half");
+		// The failure mode this guards: a model inventing `pros`/`cons` keys,
+		// which Option rejects (additionalProperties: false).
+		assert.ok(
+			/no separate pros\/cons fields|there are no separate pros\/cons fields/i.test(joined),
+			"guidelines must forbid inventing pros/cons fields",
+		);
+	});
+
+	it("both the batch and single-question options arrays propagate the rule", () => {
+		const batch = propertyDescription(BatchQuestionParams, "options");
+		assert.ok(batch.includes(PRO) && batch.includes(CON));
+		assert.ok(/configured language/i.test(batch));
+
+		const single = propertyDescription(AskChoiceParams, "options");
+		assert.ok(single.includes(PRO) && single.includes(CON));
+		assert.ok(/configured language/i.test(single));
+	});
+
+	it("every skill states the per-option pros/drawbacks rule", () => {
+		for (const dir of SKILL_DIRS) {
+			const file = path.join(ROOT, "skills", dir, "SKILL.md");
+			const text = fs.readFileSync(file, "utf8");
+			assert.ok(text.includes(PRO), `${dir}: must show the advantage marker`);
+			assert.ok(text.includes(CON), `${dir}: must show the drawback marker`);
+		}
+	});
+
+	it("the normative workflow doc states the rule at the options clause", () => {
+		const text = fs.readFileSync(path.join(ROOT, "references", "pi-planning-workflow.md"), "utf8");
+		const optionsBullet = text.split("\n").find((line) => line.startsWith("- `options`:"));
+		assert.ok(optionsBullet, "the options clause must exist");
+		assert.ok(optionsBullet!.includes(PRO) && optionsBullet!.includes(CON));
+		assert.ok(/configured language/i.test(optionsBullet!));
+		assert.ok(/accept\/execute/.test(optionsBullet!), "the handoff must be in scope");
+	});
+
+	it("the convention is renderable by the existing form renderer", () => {
+		const question: FormQuestion = {
+			question: "Which storage approach?",
+			options: [
+				{ label: "Reuse the existing table", description: `${PRO} no migration / ${CON} needs a backfill`, recommended: true },
+				{ label: "Add a new table", description: `${PRO} clean isolation / ${CON} doubles write cost` },
+			],
+			allowOther: true,
+			questionId: "q1",
+			autoComplete: true,
+		};
+		const rows = formRender(createFormState([question]), 100);
+		const rendered = rows.join("\n");
+		assert.ok(rendered.includes(PRO), "the advantage half must reach the user");
+		assert.ok(rendered.includes(CON), "the drawback half must reach the user");
+		assert.ok(rendered.includes("no migration"), "the advantage text must be shown");
+		assert.ok(rendered.includes("backfill"), "the drawback text must be shown");
+	});
+
+	it("a convention-following option still validates against the Option schema", () => {
+		// No new keys: the whole point of riding `description` is that the
+		// existing schema accepts it unchanged.
+		const ok = Value.Check(Option, {
+			label: "Reuse the existing table",
+			description: `${PRO} no migration / ${CON} needs a backfill`,
+			recommended: true,
+		});
+		assert.equal(ok, true);
+		// And stray pros/cons keys are still rejected loudly.
+		const stray = Value.Check(Option, { label: "x", pros: "a", cons: "b" });
+		assert.equal(stray, false);
+	});
+});

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