pi-plans 0.3.1 → 0.3.3

package/tests/ask-choice.test.ts

@@ -262,3 +262,116 @@ describe("ask_choice panel fitting", () => {
 		assert.ok(totalLines < rows - STATUS_BAR_HEIGHT - PANEL_SAFETY_MARGIN);
 	});
 });
+
+describe("ask_choice checkpoint question lifecycle (I-003)", () => {
+	it("records pending before the panel opens and the answer before it returns", async () => {
+		const { spawnSync } = await import("node:child_process");
+		const { initState, startRun } = await import("../src/state.ts");
+		const { createCheckpoint, loadCheckpoint } = await import("../src/workflow-state.ts");
+		const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-ask-cp-"));
+		try {
+			spawnSync("git", ["init"], { cwd: workdir });
+			initState(workdir);
+			const { run } = startRun(workdir, { topic: "askcp", skill: "plan-small", requestText: "t" });
+			createCheckpoint(workdir, { runId: run.run_id, originWorkdir: workdir, workdir });
+
+			let pendingDuringPanel: unknown = null;
+			const tool = loadTool();
+			const ctx = makeCtx({
+				select: async (_question, labels) => {
+					pendingDuringPanel = loadCheckpoint(workdir, run.run_id);
+					return labels[0];
+				},
+			});
+			const result = await tool.execute("t1", {
+				question: "Scope ok?",
+				options: OPTIONS,
+				workdir,
+				questionId: "scope-confirm",
+				purpose: "scope",
+			}, undefined, undefined, ctx);
+			assert.match(result.content[0].text, /User selected: 1/);
+
+			// During the panel: the pending question is already durable.
+			const during = pendingDuringPanel as { status: string; checkpoint?: { pendingQuestion: unknown } };
+			assert.equal(during.status, "ok");
+			assert.ok(during.checkpoint?.pendingQuestion, "pending recorded before display");
+
+			// After the answer: cleared + answered with source user.
+			const after = loadCheckpoint(workdir, run.run_id);
+			assert.equal(after.status, "ok");
+			if (after.status === "ok") {
+				assert.equal(after.checkpoint.pendingQuestion, null);
+				assert.equal(after.checkpoint.answeredQuestions.length, 1);
+				assert.equal(after.checkpoint.answeredQuestions[0]?.questionId, "scope-confirm");
+				assert.equal(after.checkpoint.answeredQuestions[0]?.source, "user");
+			}
+		} finally {
+			fs.rmSync(workdir, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps the pending question when the user cancels", async () => {
+		const { spawnSync } = await import("node:child_process");
+		const { initState, startRun } = await import("../src/state.ts");
+		const { createCheckpoint, loadCheckpoint } = await import("../src/workflow-state.ts");
+		const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-ask-cancel-"));
+		try {
+			spawnSync("git", ["init"], { cwd: workdir });
+			initState(workdir);
+			const { run } = startRun(workdir, { topic: "askcancel", skill: "plan-small", requestText: "t" });
+			createCheckpoint(workdir, { runId: run.run_id, originWorkdir: workdir, workdir });
+			const tool = loadTool();
+			const ctx = makeCtx({ select: async () => undefined });
+			const result = await tool.execute("t1", {
+				question: "Scope ok?",
+				options: OPTIONS,
+				workdir,
+				questionId: "scope-confirm",
+			}, undefined, undefined, ctx);
+			assert.match(result.content[0].text, /cancelled/i);
+			const loaded = loadCheckpoint(workdir, run.run_id);
+			if (loaded.status === "ok") {
+				assert.ok(loaded.checkpoint.pendingQuestion, "cancelled question stays pending for resume");
+				assert.equal(loaded.checkpoint.answeredQuestions.length, 0);
+			}
+		} finally {
+			fs.rmSync(workdir, { recursive: true, force: true });
+		}
+	});
+
+	it("skips checkpoint writes without questionId or without a checkpoint", async () => {
+		const { spawnSync } = await import("node:child_process");
+		const { initState, startRun } = await import("../src/state.ts");
+		const { createCheckpoint, loadCheckpoint } = await import("../src/workflow-state.ts");
+		const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-ask-skip-"));
+		try {
+			spawnSync("git", ["init"], { cwd: workdir });
+			initState(workdir);
+			const withCp = startRun(workdir, { topic: "withcp", skill: "plan-small", requestText: "t" }).run;
+			createCheckpoint(workdir, { runId: withCp.run_id, originWorkdir: workdir, workdir });
+			const noCp = startRun(workdir, { topic: "nocp", skill: "plan-small", requestText: "t" }).run;
+
+			const tool = loadTool();
+			const ctx = makeCtx({ select: async (_question, labels) => labels[0] });
+			// No questionId → no checkpoint mutation.
+			await tool.execute("t1", { question: "Q?", options: OPTIONS, workdir }, undefined, undefined, ctx);
+			let loaded = loadCheckpoint(workdir, withCp.run_id);
+			if (loaded.status === "ok") {
+				assert.equal(loaded.checkpoint.pendingQuestion, null);
+				assert.equal(loaded.checkpoint.answeredQuestions.length, 0);
+			}
+			// questionId but the active run has no checkpoint → silent skip.
+			const result = await tool.execute("t2", {
+				question: "Q?",
+				options: OPTIONS,
+				workdir,
+				questionId: "q-no-cp",
+			}, undefined, undefined, ctx);
+			assert.match(result.content[0].text, /User selected/);
+			assert.equal(loadCheckpoint(workdir, noCp.run_id).status, "missing");
+		} finally {
+			fs.rmSync(workdir, { recursive: true, force: true });
+		}
+	});
+});

package/tests/compaction.test.ts

@@ -10,6 +10,7 @@ import {
 	DEFAULT_VCC_SETTINGS,
 	loadVccSettings,
 	parseCompactionInstructions,
+	PLANNING_PREPLAN_COMPACT_HINT,
 	PI_VCC_COMPACT_INSTRUCTION,
 	scaffoldVccSettings,
 	shouldScheduleAutoContinue,
@@ -386,3 +387,41 @@ describe("pi-vcc compaction", () => {
 		}
 	});
 });
+describe("pre-plan compaction settings and hint", () => {
+	let tmpRoot: string;
+
+	before(() => {
+		tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-preplan-vcc-"));
+	});
+
+	after(() => {
+		fs.rmSync(tmpRoot, { recursive: true, force: true });
+	});
+
+	it("parses the pre-plan compaction hint as an internal pi-plans instruction", () => {
+		assert.equal(DEFAULT_VCC_SETTINGS.prePlanCompact, true);
+		assert.deepEqual(parseCompactionInstructions(PLANNING_PREPLAN_COMPACT_HINT), {
+			isPiVcc: false,
+			isInternalPiPlans: true,
+			keepUserTurns: 1,
+			keepUserTurnsExplicit: false,
+			followUpPrompt: null,
+		});
+	});
+
+	it("fills a missing prePlanCompact key and honors an explicit false", () => {
+		const stateRoot = path.join(tmpRoot, "state");
+		fs.mkdirSync(stateRoot, { recursive: true });
+		fs.writeFileSync(vccSettingsPath(stateRoot), JSON.stringify({ debug: true }), "utf8");
+		scaffoldVccSettings(stateRoot);
+		assert.deepEqual(loadVccSettings(stateRoot), { ...DEFAULT_VCC_SETTINGS, debug: true });
+
+		fs.writeFileSync(
+			vccSettingsPath(stateRoot),
+			JSON.stringify({ ...DEFAULT_VCC_SETTINGS, prePlanCompact: false }),
+			"utf8",
+		);
+		scaffoldVccSettings(stateRoot);
+		assert.equal(loadVccSettings(stateRoot).prePlanCompact, false);
+	});
+});

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