pi-plans 0.3.0 → 0.3.2

package/tests/analyze-refs.test.ts

@@ -0,0 +1,265 @@
+/** Tests for the analyze_refs tool: gates, batching, records, failure contract. */
+
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as url from "node:url";
+import { after, before, describe, it } from "node:test";
+import { registerAnalyzeRefsTool } from "../tools/analyze-refs.ts";
+import { initState, setRole, startRun, readActive } from "../src/state.ts";
+
+const ROOT = path.dirname(path.dirname(url.fileURLToPath(import.meta.url)));
+
+let tmpRoot: string;
+
+before(() => {
+	tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-analyze-refs-"));
+});
+
+after(() => {
+	fs.rmSync(tmpRoot, { recursive: true, force: true });
+});
+
+function mkWorkdir(name: string): string {
+	const dir = path.join(tmpRoot, name);
+	fs.mkdirSync(dir, { recursive: true });
+	return dir;
+}
+
+function fakePiScript(body: string): string {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-fake-pi-"));
+	const script = path.join(dir, "fake-pi.mjs");
+	fs.writeFileSync(
+		script,
+		[
+			'const emit = (event) => process.stdout.write(JSON.stringify(event) + "\\n");',
+			'emit({ type: "turn_start" });',
+			`async function main() { ${body} }`,
+			"await main();",
+		].join("\n"),
+	);
+	return script;
+}
+
+function withFakePi(scriptPath: string): () => void {
+	const previousScript = process.argv[1];
+	process.argv[1] = scriptPath;
+	return () => {
+		process.argv[1] = previousScript;
+	};
+}
+
+interface CapturedTool {
+	execute: (toolCallId: string, params: unknown, signal: AbortSignal | undefined, onUpdate: unknown, ctx: unknown) => Promise<{ content: Array<{ type: string; text: string }>; details: any }>;
+}
+
+function loadTool(): CapturedTool {
+	let captured: CapturedTool | undefined;
+	const pi = {
+		registerTool: (definition: unknown) => {
+			captured = definition as CapturedTool;
+		},
+	};
+	registerAnalyzeRefsTool(pi as any, ROOT);
+	assert.ok(captured, "registerTool was not called");
+	return captured!;
+}
+
+function headlessCtx(workdir: string): unknown {
+	return { cwd: workdir };
+}
+
+function subagentLines(workdir: string): Array<any> {
+	const active = readActive(workdir);
+	assert.ok(active, "expected an active run");
+	const file = path.join(active.run_dir, "subagents.jsonl");
+	if (!fs.existsSync(file)) return [];
+	return fs
+		.readFileSync(file, "utf8")
+		.trim()
+		.split("\n")
+		.filter(Boolean)
+		.map((line) => JSON.parse(line));
+}
+
+describe("analyze_refs gates", () => {
+	it("refuses when no pi-plans state exists", async () => {
+		const workdir = mkWorkdir("gates-no-state");
+		const tool = loadTool();
+		await assert.rejects(
+			tool.execute("c1", { refs: [{ id: "ref-1", localPath: "." }] }, undefined, undefined, headlessCtx(workdir)),
+			/no pi-plans state found/,
+		);
+	});
+
+	it("refuses with role-setting guidance when reviewer mode is invalid", async () => {
+		const workdir = mkWorkdir("gates-bad-mode");
+		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/,
+		);
+	});
+
+	it("refuses current-session reviewer mode with a switch-to-delegated message", 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,
+		);
+	});
+
+	it("refuses with confirmation guidance when the reviewer model is unconfirmed", async () => {
+		const workdir = mkWorkdir("gates-unconfirmed");
+		initState(workdir);
+		setRole(workdir, { role: "reviewer", mode: "delegated-subagent" });
+		const tool = loadTool();
+		await assert.rejects(
+			tool.execute("c1", { refs: [{ id: "ref-1", localPath: "." }] }, undefined, undefined, headlessCtx(workdir)),
+			/model was never confirmed/,
+		);
+	});
+});
+
+describe("analyze_refs fanout", () => {
+	it("spawns one lane per ref in batches of at most 3, records spawns, and returns sections", async () => {
+		const workdir = mkWorkdir("fanout");
+		initState(workdir);
+		setRole(workdir, { role: "reviewer", mode: "delegated-subagent", modelSelector: "fake/model", confirmed: true });
+		startRun(workdir, { topic: "refs", skill: "plan-with-refs", requestText: "x" });
+
+		const refs = [1, 2, 3, 4, 5].map((n) => {
+			const dir = path.join(workdir, `refs`, `repo-${n}`);
+			fs.mkdirSync(dir, { recursive: true });
+			fs.writeFileSync(path.join(dir, "README.md"), `ref ${n}`);
+			return { id: `ref-${n}`, localPath: dir, title: `Ref ${n}`, url: "https://example.com", kind: "project" };
+		});
+
+		const restore = withFakePi(
+			fakePiScript(
+				`const task = process.argv.filter((arg) => arg.startsWith("Task: ")).pop() ?? "";\n` +
+					`emit({ type: "message_end", message: { role: "assistant", model: "fake/model", content: [{ type: "text", text: "ANALYSIS from " + process.cwd().split("/").pop() + "\\n" + task }] } });`,
+			),
+		);
+		const tool = loadTool();
+		try {
+			const result = await tool.execute("c1", { refs, context: "pi-plans repo" }, undefined, undefined, headlessCtx(workdir));
+			const text = result.content[0]!.text;
+			for (let n = 1; n <= 5; n += 1) {
+				assert.ok(text.includes(`### pi-plans-refs-`), "missing section header");
+				assert.ok(text.includes(`ANALYSIS from repo-${n}`), `missing per-ref cwd output for repo-${n}`);
+				assert.ok(text.includes(`Reference id: ref-${n}`), `brief must carry the ref id for repo-${n}`);
+			}
+			assert.ok(text.includes("Target repo context: pi-plans repo"), "brief must carry the target repo context");
+			assert.ok(text.includes("## Evidence Gaps"), "brief must carry the seven-section contract");
+			assert.match(text, /Persist: paste each reference's analysis into REF_ANALYSIS\.md/);
+			assert.equal(result.details.batches, 2, "five refs must run as two batches");
+			assert.equal(result.details.role, "ref-analyst");
+
+			const spawns = subagentLines(workdir);
+			assert.equal(spawns.length, 5);
+			assert.ok(spawns.every((spawn: any) => spawn.role === "ref-analyst"));
+			assert.equal(spawns[0].model, "fake/model");
+			const names = spawns.map((spawn: any) => spawn.name).sort();
+			for (let n = 1; n <= 5; n += 1) {
+				assert.ok(names.some((name: string) => name.endsWith(`-ref-${n}`)), `missing spawn name ref-${n}`);
+			}
+		} finally {
+			restore();
+		}
+	});
+
+	it("section-fails missing ref directories without aborting the rest", async () => {
+		const workdir = mkWorkdir("fanout-missing");
+		initState(workdir);
+		setRole(workdir, { role: "reviewer", mode: "delegated-subagent", modelSelector: "fake/model", confirmed: true });
+		startRun(workdir, { topic: "refs-missing", skill: "plan-with-refs", requestText: "x" });
+
+		const good = path.join(workdir, "refs", "good");
+		fs.mkdirSync(good, { recursive: true });
+		const refs = [
+			{ id: "ref-1", localPath: path.join(workdir, "refs", "does-not-exist") },
+			{ id: "ref-2", localPath: good },
+		];
+
+		const restore = withFakePi(
+			fakePiScript(
+				`emit({ type: "message_end", message: { role: "assistant", model: "fake/model", content: [{ type: "text", text: "OK analysis" }] } });`,
+			),
+		);
+		const tool = loadTool();
+		try {
+			const result = await tool.execute("c1", { refs }, undefined, undefined, headlessCtx(workdir));
+			const text = result.content[0]!.text;
+			assert.match(text, /ref-1[^\n]*— FAILED\nreference directory not found:/);
+			assert.match(text, /OK analysis/);
+			const failed = result.details.outputs.find((output: any) => output.refId === "ref-1");
+			assert.equal(failed.ok, false);
+		} finally {
+			restore();
+		}
+	});
+
+	it("throws when every ref fails", async () => {
+		const workdir = mkWorkdir("fanout-all-failed");
+		initState(workdir);
+		setRole(workdir, { role: "reviewer", mode: "delegated-subagent", modelSelector: "fake/model", confirmed: true });
+		const tool = loadTool();
+		await assert.rejects(
+			tool.execute(
+				"c1",
+				{ refs: [{ id: "ref-1", localPath: path.join(workdir, "missing-a") }, { id: "ref-2", localPath: path.join(workdir, "missing-b") }] },
+				undefined,
+				undefined,
+				headlessCtx(workdir),
+			),
+			/all reference analysis subagents failed/,
+		);
+	});
+
+	it("pins the per-batch overlay lifecycle (open before spawn, close in finally, cap 3)", () => {
+		const source = fs.readFileSync(path.join(ROOT, "tools", "analyze-refs.ts"), "utf8");
+		assert.equal((source.match(/new RefineOverlayController\("refs"/g) ?? []).length, 1, "controller must be constructed per batch inside the loop");
+		assert.match(source, /overlay\?\.open\(refineOverlayContext\(ctx\), modelLabel\)/);
+		assert.match(source, /await overlay\?\.close\(\);/);
+		assert.match(source, /const BATCH_SIZE = 3;/);
+		assert.ok(source.indexOf("overlay?.open(") < source.indexOf("await overlay?.close();"), "open must precede close");
+	});
+
+	it("skips recording without an active run (adhoc) and still succeeds", async () => {
+		const workdir = mkWorkdir("adhoc");
+		initState(workdir);
+		setRole(workdir, { role: "reviewer", mode: "delegated-subagent", 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: "adhoc analysis" }] } });`,
+			),
+		);
+		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, /### pi-plans-refs-adhoc-ref-1/);
+			assert.equal(readActive(workdir), null);
+			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")] : [],
+			);
+			assert.equal(spawnFiles.join("").trim(), "", "adhoc calls must not record spawns");
+		} finally {
+			restore();
+		}
+	});
+});

package/tests/ask-choice.test.ts

@@ -87,6 +87,7 @@ describe("ask_choice trailing option", () => {
 		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"\)/);
 		assert.equal(result.details.source, "user");
 		assert.equal(result.details.answer, "Auto-refine loop");

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

@@ -0,0 +1,173 @@
+/** Tests for the agent-invokable code_graph "apply" action and its gates. */
+
+import * as assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as url from "node:url";
+import { test } from "node:test";
+import { Store } from "../src/code-graph/store.ts";
+import { runIndex } from "../src/code-graph/indexer.ts";
+import { applyGraphCore } from "../src/code-graph/commands.ts";
+import { updateFile } from "../src/code-graph/mutations.ts";
+import { makeBackend } from "../src/code-graph/parsers/javascript.ts";
+import { PythonBackend } from "../src/code-graph/parsers/python.ts";
+import { loadGraphRuntime } from "../src/code-graph/runtime.ts";
+import type { ParserBackend } from "../src/code-graph/parser.ts";
+import type { Language } from "../src/code-graph/types.ts";
+import { initState, setRunStatus, startRun } from "../src/state.ts";
+import { registerCodeGraphTool } from "../tools/code-graph.ts";
+
+const ROOT = path.dirname(path.dirname(url.fileURLToPath(import.meta.url)));
+
+function git(cwd: string, args: string[]): void {
+	const env: Record<string, string | undefined> = { ...process.env };
+	for (const key of ["GIT_DIR", "GIT_COMMON_DIR", "GIT_WORK_TREE"]) delete env[key];
+	const result = spawnSync("git", args, { cwd, env, encoding: "utf8" });
+	assert.equal(result.status, 0, `${args.join(" ")} failed: ${result.stderr}`);
+}
+
+async function setupIndexedRepo(): Promise<{ root: string; store: Store; cleanup: () => void } | null> {
+	const runtime = await loadGraphRuntime();
+	if (!runtime.status.parserAvailable || !runtime.status.sqliteAvailable) return null;
+
+	const raw = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-apply-action-"));
+	git(raw, ["init", "--initial-branch=main"]);
+	git(raw, ["config", "user.email", "test@example.com"]);
+	git(raw, ["config", "user.name", "test"]);
+	fs.writeFileSync(path.join(raw, "math.js"), "function add(a, b) { return a + b; }\n");
+	git(raw, ["add", "-A"]);
+	git(raw, ["commit", "-m", "init"]);
+	const root = fs.realpathSync(raw);
+
+	const ParserCtor = runtime.runtime.parser.Parser as unknown as new () => {
+		parse(input: string | Buffer): unknown;
+		setLanguage(language: unknown): void;
+	};
+	const parsers: Record<Language, ParserBackend> = {
+		javascript: makeBackend("javascript", ParserCtor, runtime.runtime.parser.javascript),
+		typescript: makeBackend("typescript", ParserCtor, runtime.runtime.parser.typescript),
+		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 });
+	const store = new Store(
+		{ 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 });
+	return {
+		root,
+		store,
+		cleanup: () => {
+			store.close();
+			try {
+				fs.rmSync(raw, { recursive: true, force: true });
+			} catch {
+				/* ignore */
+			}
+		},
+	};
+}
+
+test("applyGraphCore refuses during planning runs and allows once executing or done", async (t) => {
+	const opened = await setupIndexedRepo();
+	if (!opened) return;
+	t.after(() => opened.cleanup());
+	const { root } = opened;
+
+	initState(root);
+	const { run } = startRun(root, { topic: "apply-gate", skill: "plan-small", requestText: "x" });
+
+	const planning = await applyGraphCore(root);
+	assert.match(planning.refused ?? "", /planning run is currently planning or accepted/);
+	assert.equal(planning.report, undefined);
+
+	setRunStatus(root, run.run_id, "executing");
+	const mathBefore = fs.readFileSync(path.join(root, "math.js"), "utf8");
+	const allowed = await applyGraphCore(root);
+	assert.equal(allowed.refused, undefined);
+	assert.ok(allowed.report, "expected a report once allowed");
+	assert.ok(allowed.drift, "expected a drift summary once allowed");
+	// Safe no-op with no pending staged edits: disk untouched, nothing stale or errored.
+	assert.equal(fs.readFileSync(path.join(root, "math.js"), "utf8"), mathBefore);
+	const noPendingCounts: Record<string, number> = { ok: 0, deleted: 0, stale: 0, "skipped-missing": 0, error: 0 };
+	for (const file of allowed.report!.files) noPendingCounts[file.status] = (noPendingCounts[file.status] ?? 0) + 1;
+	assert.equal(noPendingCounts.stale, 0);
+	assert.equal(noPendingCounts.error, 0);
+
+	setRunStatus(root, run.run_id, "done");
+	const doneAllowed = await applyGraphCore(root);
+	assert.equal(doneAllowed.refused, undefined);
+	assert.ok(doneAllowed.report, "done runs must still be allowed");
+});
+
+test("applyGraphCore materializes pending DB edits and reports counts plus drift", async (t) => {
+	const opened = await setupIndexedRepo();
+	if (!opened) return;
+	t.after(() => opened.cleanup());
+	const { root, store } = opened;
+	initState(root); // no active run → allowed
+
+	const next = "function add(a, b) { return a + b + 1; }\n";
+	const mutation = updateFile(store, { fileDir: ".", fileName: "math.js", text: next });
+	assert.equal(mutation.ok, true);
+	// Disk still has the original content before apply.
+	assert.equal(fs.readFileSync(path.join(root, "math.js"), "utf8"), "function add(a, b) { return a + b; }\n");
+
+	const core = await applyGraphCore(root);
+	assert.equal(core.refused, undefined);
+	assert.ok(core.report);
+	const counts: Record<string, number> = { ok: 0, deleted: 0, stale: 0, "skipped-missing": 0, error: 0 };
+	for (const file of core.report.files) counts[file.status] = (counts[file.status] ?? 0) + 1;
+	assert.ok(counts.ok >= 1, "at least the staged file must materialize");
+	assert.equal(fs.readFileSync(path.join(root, "math.js"), "utf8"), next);
+	assert.ok(core.drift);
+	assert.equal(core.drift.pending, 0);
+	assert.equal(core.drift.ok, true);
+});
+
+test("code_graph tool apply action: refiner env refuses, planning gate holds, wiring present", async (t) => {
+	const source = fs.readFileSync(path.join(ROOT, "tools", "code-graph.ts"), "utf8");
+	assert.match(source, /"apply"/);
+	assert.match(source, /PI_PLANS_REFINER/);
+	assert.match(source, /applyGraphCore/);
+
+	const opened = await setupIndexedRepo();
+	if (!opened) return;
+	t.after(() => opened.cleanup());
+	const { root } = opened;
+	initState(root);
+	const { run } = startRun(root, { topic: "apply-tool", skill: "plan-small", requestText: "x" });
+
+	let captured: {
+		execute: (id: string, params: any, signal: unknown, onUpdate: unknown, ctx: any) => Promise<{ content: Array<{ type: string; text: string }> }>;
+	} | undefined;
+	registerCodeGraphTool({
+		registerTool: (definition: never) => {
+			captured = definition as typeof captured;
+		},
+	} as never);
+	assert.ok(captured, "registerTool was not called");
+
+	// Refiner marker refuses before any run-state lookup.
+	const previous = process.env.PI_PLANS_REFINER;
+	process.env.PI_PLANS_REFINER = "1";
+	try {
+		const refused = await captured!.execute("c1", { action: "apply", workdir: root }, undefined, undefined, { cwd: root });
+		const payload = JSON.parse(refused.content[0]!.text) as { ok: boolean; reason: string };
+		assert.equal(payload.ok, false);
+		assert.match(payload.reason, /PI_PLANS_REFINER/);
+	} finally {
+		if (previous === undefined) delete process.env.PI_PLANS_REFINER;
+		else process.env.PI_PLANS_REFINER = previous;
+	}
+
+	// Planning run (without the marker) is refused by the run-state gate.
+	setRunStatus(root, run.run_id, "planning");
+	const gateRefused = await captured!.execute("c2", { action: "apply", workdir: root }, undefined, undefined, { cwd: root });
+	const gatePayload = JSON.parse(gateRefused.content[0]!.text) as { ok: boolean; reason: string };
+	assert.equal(gatePayload.ok, false);
+	assert.match(gatePayload.reason, /planning run is currently planning or accepted/);
+});

package/tests/config-command.test.ts

@@ -99,6 +99,7 @@ describe("config-pi-plans command", () => {
 			select: (question, labels) => {
 				if (question === "Language?") return labels.find((label) => label.includes("en"));
 				if (question === "Artifact root?") return labels.find((label) => label.includes("./.git/pi_plans/plans"));
+				if (question === "Refs root (plan-with-refs downloads)?") return labels.find((label) => label.includes(".git/pi-plans/refs"));
 				if (question === "Code graph?") return labels.find((label) => label.includes("Disable code graph"));
 				if (question === "Reviewer mode?") return labels.find((label) => label.includes("Switch to current-session"));
 				if (question === "Reviewer model?") return labels.find((label) => label.includes("Use current session model (live/pro)"));
@@ -120,6 +121,9 @@ describe("config-pi-plans command", () => {
 		assert.equal(config.language.source, "user");
 		assert.equal(config.artifact_root, "./.git/pi_plans/plans");
 		assert.equal(config.artifact_root_source, "user");
+		assert.equal(config.refs_root, ".git/pi-plans/refs");
+		assert.equal(config.refs_root_source, "user");
+		assert.ok(config.refs_root_updated_at);
 		assert.equal(config.graph_enabled, false);
 		assert.equal(config.reviewer.mode, "current-session");
 		assert.equal(config.reviewer.model_selector, "live/pro");
@@ -141,6 +145,7 @@ describe("config-pi-plans command", () => {
 			select: (question, labels) => {
 				if (question === "Language?") return labels[0];
 				if (question === "Artifact root?") return labels[0];
+				if (question === "Refs root (plan-with-refs downloads)?") return labels[0];
 				if (question === "Code graph?") return labels[0];
 				if (question === "Reviewer mode?") return labels[0];
 				if (question === "Reviewer model?") return labels[0];
@@ -170,6 +175,7 @@ describe("config-pi-plans command", () => {
 			select: (question, labels) => {
 				if (question === "Language?") return labels[0];
 				if (question === "Artifact root?") return labels[0];
+				if (question === "Refs root (plan-with-refs downloads)?") return labels[0];
 				if (question === "Code graph?") return labels[0];
 				if (question === "Reviewer mode?") return labels[0];
 				if (question === "Reviewer model?") return labels.find((label) => label.includes("Other..."));
@@ -207,6 +213,7 @@ describe("config-pi-plans command", () => {
 			select: (question, labels) => {
 				if (question === "Language?") return labels[0];
 				if (question === "Artifact root?") return labels[0];
+				if (question === "Refs root (plan-with-refs downloads)?") return labels[0];
 				if (question === "Code graph?") return labels[0];
 				if (question === "Reviewer mode?") return labels[0];
 				if (question === "Reviewer model?") return labels[0];
@@ -233,6 +240,7 @@ describe("config-pi-plans command", () => {
 			select: (question, labels) => {
 				if (question === "Language?") return labels.find((label) => label.includes("en"));
 				if (question === "Artifact root?") return labels.find((label) => label.includes("./.git/pi_plans/plans"));
+				if (question === "Refs root (plan-with-refs downloads)?") return labels.find((label) => label.includes(".git/pi-plans/refs"));
 				if (question === "Code graph?") return labels.find((label) => label.includes("Enable code graph"));
 				if (question === "Reviewer mode?") return labels.find((label) => label.includes("Keep delegated-subagent"));
 				if (question === "Reviewer model?") return labels[0];

package/tests/exec-lifecycle.test.ts

@@ -0,0 +1,137 @@
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { after, describe, it } from "node:test";
+import { InMemoryCredentialStore, createAssistantMessageEventStream } from "@earendil-works/pi-ai";
+import { createAgentSession, DefaultResourceLoader, initTheme, ModelRuntime, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import piPlansExtension from "../index.ts";
+import { GOAL_WAIT_CUSTOM_TYPE, getExecution, startExecution } from "../src/exec.ts";
+
+initTheme("dark", false);
+const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-lifecycle-"));
+after(() => fs.rmSync(root, { recursive: true, force: true }));
+let serial = 0;
+
+async function exercise(mode: "tui" | "rpc" | "print" | "json", needsWake: boolean, commandResume = false) {
+	const cwd = path.join(root, String(++serial));
+	fs.mkdirSync(cwd);
+	const settingsManager = SettingsManager.inMemory({ compaction: { enabled: false }, retry: { enabled: false } });
+	const modelRuntime = await ModelRuntime.create({
+		credentials: new InMemoryCredentialStore(), modelsPath: null,
+		modelsStorePath: path.join(cwd, "models-store.json"), allowModelNetwork: false, refreshOnCreate: false,
+	});
+	const inputs: any[] = [];
+	let toolCalls = 0;
+	modelRuntime.registerProvider("local-lifecycle-test", {
+		baseUrl: "http://unused.invalid", api: "openai-completions", apiKey: "not-a-real-key",
+		models: [{ id: "fixture", name: "fixture", reasoning: false, input: ["text"],
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 100000, maxTokens: 1024 }],
+		streamSimple: (model: any, context: any) => {
+			inputs.push(structuredClone({ messages: context.messages, systemPrompt: context.systemPrompt }));
+			const call = inputs.length;
+			assert.ok(call <= 5, "unexpected extra model invocation");
+			const tool = call <= 2;
+			const text = call === 3
+				? needsWake ? "[DONE:VC-001] More verification remains." : "[DONE:VC-001] [DONE:VC-002]"
+				: call === 4 && needsWake ? "[DONE:VC-002]" : "Review awaits explicit user approval.";
+			const message: any = {
+				role: "assistant", api: model.api, provider: model.provider, model: model.id,
+				content: tool ? [
+					...(commandResume && call === 2 ? [{ type: "text", text: "[DONE:VC-001]" }] : []),
+					{ type: "toolCall", id: `call-${call}`, name: "probe", arguments: {} },
+				] : [{ type: "text", text: commandResume && call === 3 ? "Interrupted." : text }],
+				stopReason: tool ? "toolUse" : commandResume && call === 3 ? "aborted" : "stop", timestamp: Date.now(),
+				usage: { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, totalTokens: 15,
+					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+			};
+			const stream = createAssistantMessageEventStream();
+			stream.push({ type: "start", partial: message });
+			if (message.stopReason === "aborted") stream.push({ type: "error", reason: "aborted", error: message });
+			else stream.push({ type: "done", reason: message.stopReason, message });
+			stream.end(message);
+			return stream;
+		},
+	});
+	let beforeAgentStarts = 0;
+	const events: string[] = [];
+	const errors: string[] = [];
+	const loader = new DefaultResourceLoader({
+		cwd, agentDir: path.join(cwd, "agent"), settingsManager,
+		noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true,
+		agentsFilesOverride: () => ({ agentsFiles: [] }), systemPromptOverride: () => "Deterministic test.",
+		extensionFactories: [piPlansExtension, pi => {
+			pi.on("before_agent_start", () => { beforeAgentStarts++; });
+			pi.on("session_start", async (_event, ctx) => {
+				await startExecution(pi, ctx, path.join(cwd, "PLAN_v1.md"), [
+					{ id: "VC-001", text: "first", done: false }, { id: "VC-002", text: "second", done: false },
+				]);
+			});
+		}],
+	});
+	await loader.reload();
+	assert.deepEqual(loader.getExtensions().errors, []);
+	const { session } = await createAgentSession({
+		cwd, agentDir: path.join(cwd, "agent"), modelRuntime,
+		model: modelRuntime.getModel("local-lifecycle-test", "fixture")!, thinkingLevel: "off",
+		resourceLoader: loader, settingsManager, sessionManager: SessionManager.inMemory(cwd), tools: ["probe"],
+		customTools: [{ name: "probe", label: "Probe", description: "Local test probe", parameters: Type.Object({}),
+			execute: async () => { toolCalls++; return { content: [{ type: "text", text: "ok" }], details: {} }; } }],
+	});
+	const unsubscribe = session.subscribe(event => events.push(event.type));
+	try {
+		await session.bindExtensions({
+			mode,
+			...(mode === "tui" || mode === "rpc" ? { uiContext: {
+				setStatus: () => {}, notify: () => {}, theme: { fg: (_c: string, s: string) => s },
+			} as any } : {}),
+			onError: error => errors.push(error.error),
+		});
+		await session.prompt("Implement the test plan.");
+		await session.waitForIdle();
+		if (commandResume) {
+			assert.equal(getExecution()?.goalWait?.paused, true);
+			assert.deepEqual(getExecution()?.items.map(item => item.done), [true, false]);
+			assert.equal(inputs.length, 3);
+			await session.prompt("/plans-execute");
+		}
+		// SDK callers, unlike print mode, own the runtime until all nested wakes settle.
+		await session.waitForIdle();
+		assert.deepEqual(errors, []);
+		assert.deepEqual(session.messages.filter((m: any) => m.role === "assistant" && m.stopReason === "error"), [], "fixture model must run successfully");
+		const wakes = session.messages.filter((m: any) => m.customType === GOAL_WAIT_CUSTOM_TYPE) as any[];
+		assert.equal(toolCalls, 2);
+		assert.equal(beforeAgentStarts, 1, "custom wake must work without before_agent_start");
+		const interactive = mode === "tui" || mode === "rpc";
+		assert.equal(wakes.length, interactive && needsWake ? 1 : 0);
+		assert.equal(inputs.length, interactive ? needsWake ? 5 : 4 : 3);
+		if (interactive && needsWake) {
+			assert.equal(wakes[0].display, false);
+			assert.match(JSON.stringify(inputs[3].messages), /1\/2 verifier items done/);
+			assert.match(wakes[0].content, /- `VC-002` second/);
+			assert.doesNotMatch(wakes[0].content, /- `VC-001` first/);
+		}
+		if (interactive || !needsWake) assert.equal(getExecution(), null);
+		else assert.deepEqual(getExecution()?.items.map(item => item.done), [true, false]);
+		assert.equal(session.pendingMessageCount, 0);
+		assert.equal(events.at(-1), "agent_settled");
+		return { events, calls: inputs.length, wakes: wakes.length };
+	} finally {
+		unsubscribe();
+		session.dispose();
+	}
+}
+
+describe("goal-wait on the real Pi host", () => {
+	it("dispatches the registered /plans-execute command and preserves completed VCs", { timeout: 15000 }, async () => {
+		await exercise("rpc", true, true);
+	});
+	for (const mode of ["tui", "rpc", "print", "json"] as const) {
+		for (const needsWake of [false, true]) {
+			it(`${mode}: tools then ${needsWake ? "incomplete stop" : "completion"}`, { timeout: 15000 }, async () => {
+				await exercise(mode, needsWake);
+			});
+		}
+	}
+});