pi-plans 0.1.2 → 0.2.0

package/tests/exec.test.ts

@@ -8,12 +8,12 @@ import { after, before, describe, it } from "node:test";
 import {
 	applyDoneMarkers,
 	applyImplMarkers,
+	applyCurrentIMarker,
 	buildExecutionCompactionResult,
 	buildPlanningCompactionResult,
 	completeExecution,
 	consumePendingExecutionFlush,
 	consumePlanningCompactionResumeGuard,
-	consumePendingPanelSync,
 	drainExecutionFlush,
 	executionContextMessage,
 	filterExecutionResumeMessages,
@@ -21,6 +21,7 @@ import {
 	getExecution,
 	handleExecutionBeforeCompact,
 	handleExecutionCompact,
+	handleExecutionTurnCompaction,
 	handleExecutionCompactFailed,
 	handlePlanningBeforeCompact,
 	handlePlanningCompact,
@@ -32,17 +33,14 @@ import {
 	requestPlanningCompaction,
 	restoreFromSession,
 	shouldTriggerPlanningCompaction,
-	ensureExecutionModelActive,
 	startExecution,
 	recordExecutionTurn,
 	registerExecutionTurnHandlers,
 	stopExecution,
-	chooseExecutionModelSelection,
-	toggleExecutionPanelView,
 	updateStatusWidget,
 } from "../src/exec.ts";
 import type { CheckItem } from "../src/plan.ts";
-import { initState, setExecutionModel, setRunStatus, showConfig, startRun } from "../src/state.ts";
+import { initState, setRunStatus, startRun } from "../src/state.ts";
 
 interface Recorded {
 	entries: { type: string; customType?: string; data?: unknown }[];
@@ -50,8 +48,6 @@ interface Recorded {
 	status: string | undefined;
 	statusCalls: number;
 	colors: string[];
-	widget?: { key: string; options?: unknown; factory: any };
-	widgetCalls: number;
 	models: { provider: string; id: string }[];
 	thinkingLevels: (string | null)[];
 	notifies: { message: string; severity: string }[];
@@ -76,7 +72,6 @@ function makeHarness(workdir: string): Harness {
 		status: undefined,
 		statusCalls: 0,
 		colors: [],
-		widgetCalls: 0,
 		models: [],
 		thinkingLevels: [],
 		notifies: [],
@@ -129,14 +124,6 @@ function makeHarness(workdir: string): Harness {
 			recorded.statusCalls += 1;
 			recorded.status = value;
 		},
-		setWidget: (key: string, factory: any, options?: unknown) => {
-			recorded.widgetCalls += 1;
-			if (factory === undefined) {
-				recorded.widget = undefined;
-				return;
-			}
-			recorded.widget = { key, options, factory };
-		},
 		notify: (message: string, severity: string) => {
 			recorded.notifies.push({ message, severity });
 		},
@@ -214,36 +201,20 @@ describe("execution loop", () => {
 		const { pi, ctx, recorded } = makeHarness(workdir);
 		await startExecution(pi, ctx, path.join(workdir, "PLAN_v1.md"), items("VC-001", "VC-002"));
 
-		// Collapsed by default: progress lives in the bottom status bar (same
-		// layer as the ⛔/⌛ indicators); no panel widget is registered yet.
-		assert.equal(recorded.widget, undefined);
 		assert.match(recorded.status ?? "", /⌛ plans 0\/2: spent \d{2}:\d{2}:\d{2}/);
 		assert.match(recorded.status ?? "", /in-toks/);
 		assert.match(recorded.status ?? "", /out-toks/);
 
-		toggleExecutionPanelView(pi, ctx);
-		assert.ok(recorded.widget);
-		assert.equal(recorded.widget?.key, "pi-plans-execution");
-		assert.deepEqual(recorded.widget?.options, { placement: "belowEditor" });
-		// Expanded: footer ⌛ line is cleared — the panel renders its own header.
-		assert.equal(recorded.status, undefined);
-		const expandedWidget = recorded.widget?.factory(
-			{} as any,
-			{ fg: (_color: string, text: string) => text, strikethrough: (text: string) => `~~${text}~~` },
-		);
-		assert.ok(expandedWidget);
-		const expandedLines = expandedWidget.render(80);
-		// Header line first, then the legacy item list.
-		assert.match(expandedLines[0] ?? "", /⌛ plans 0\/2: spent/);
-		assert.match(expandedLines.join("\n"), /☐/);
-		// Detail view never repeats the keyboard hint.
-		assert.doesNotMatch(expandedLines.join("\n"), /alt\+o/);
-
 		assert.ok(getExecution());
 		const rules = executionContextMessage()!;
 		assert.match(rules, /PI-PLANS EXECUTION/);
 		assert.match(rules, /VC-001/);
-		// Seven-principle rule set: representative anchors (PLAN_v2 D-003/D-004).
+		assert.match(rules, /subprocess-backed verification/);
+		assert.match(rules, /waiting for/);
+		assert.match(rules, /5s\s*->\s*10s\s*->\s*20s\s*->\s*40s\s*->\s*80s/);
+		assert.match(rules, /keep polling at 80s/);
+		assert.match(rules, /restart at 5s for each new subprocess/);
+		// Representative anchors for the core execution rules (PLAN_v2 D-003/D-004).
 		assert.match(rules, /for the long term/);
 		assert.match(rules, /Simplest implementation/);
 		assert.match(rules, /grow the change in layers/);
@@ -270,17 +241,6 @@ describe("execution loop", () => {
 			planPath: path.join(workdir, "PLAN_v1.md"),
 			items: items("VC-001", "VC-002"),
 			startedAt: "2026-08-25T00:00:00Z",
-			panel: {
-				expanded: true,
-				baseline: { added: 0, removed: 0, files: 0 },
-				lastSnapshot: { added: 1, removed: 0, files: 1 },
-				touchedPaths: ["src/exec.ts"],
-				itemSummaries: {
-					"VC-001": {
-						summary: { added: 1, removed: 0, files: 1, paths: ["src/exec.ts"] },
-					},
-			},
-			},
 			compaction: {
 				inFlight: true,
 				resumeGuard: true,
@@ -302,15 +262,6 @@ describe("execution loop", () => {
 		const execution = getExecution();
 		assert.ok(execution);
 		assert.equal("compaction" in execution!, false, "legacy scheduler state must not reactivate on restore");
-		assert.ok(recorded.widget);
-		const widget = recorded.widget?.factory(
-			{} as any,
-			{ fg: (_color: string, text: string) => text, strikethrough: (text: string) => `~~${text}~~` },
-		);
-		assert.ok(widget);
-		const rendered = widget.render(80);
-		assert.match(rendered.join("\n"), /☑/);
-		assert.match(rendered.join("\n"), /\+1/);
 
 		const clearedEntries = [...entries, { type: "custom", customType: "pi-plans-exec-cleared", data: {} }];
 		await restoreFromSession(pi, ctx, clearedEntries as any);
@@ -343,99 +294,21 @@ describe("execution loop", () => {
 		assert.equal(getExecution(), null);
 	});
 
-	it("switches to the execution model and restores the planning model", async () => {
+	it("starts execution without switching models", async () => {
 		const workdir = freshWorkdir();
 		const { pi, ctx, recorded } = makeHarness(workdir);
-		await startExecution(pi, ctx, path.join(workdir, "PLAN_v6.md"), items("VC-001"), {
-			planningSelector: "p/m:high",
-			executionSelector: "prov/other:xhigh",
-		});
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v6.md"), items("VC-001"));
 
-		assert.deepEqual(recorded.models, [{ provider: "prov", id: "other" }]);
-		assert.equal(recorded.thinking, "xhigh");
+		assert.deepEqual(recorded.models, []);
+		assert.equal(recorded.thinking, "high");
 		assert.match(recorded.status ?? "", /⌛ plans 0\/1/);
 
 		await stopExecution(pi, ctx, "restore-check");
-		assert.equal(recorded.models.at(-1)?.provider, "p");
-		assert.equal(recorded.thinking, "high");
-	});
-
-	it("defers execution model restore until the first agent turn and restores planning model on completion", async () => {
-		const workdir = freshWorkdir();
-		const { pi, ctx, recorded } = makeHarness(workdir);
-		const snapshot = {
-			planPath: path.join(workdir, "PLAN_v7.md"),
-			items: items("VC-001"),
-			startedAt: "2026-08-25T00:00:00Z",
-			modelState: { planningSelector: "p/m:high", executionSelector: "prov/other:xhigh" },
-		};
-		fs.writeFileSync(snapshot.planPath, "# plan");
-		const entries = [{ type: "custom", customType: "pi-plans-exec", data: snapshot }];
-
-		await restoreFromSession(pi, ctx, entries as any);
-		assert.ok(getExecution());
 		assert.deepEqual(recorded.models, []);
-
-		await ensureExecutionModelActive(pi, ctx);
-		assert.deepEqual(recorded.models, [{ provider: "prov", id: "other" }]);
-		assert.equal(recorded.thinking, "xhigh");
-
-		const doneEntries = [
-			...entries,
-			{ type: "message", message: { role: "assistant", content: [{ type: "text", text: "did [DONE:VC-001]" }] } },
-		];
-		await restoreFromSession(pi, ctx, doneEntries as any);
-		assert.equal(getExecution(), null);
-		assert.equal(recorded.models.at(-1)?.provider, "p");
 		assert.equal(recorded.thinking, "high");
 	});
 
-	it("prompts for the execution model when unset and confirms inherit current session model", async () => {
-		const workdir = freshWorkdir();
-		const { ctx, recorded } = makeHarness(workdir);
-		initState(workdir);
-		recorded.selectAnswer = "Inherit current session model";
-		const selection = await chooseExecutionModelSelection(ctx as any, "Execution model", {
-			model_selector: null,
-			source: "unset",
-			updated_at: null,
-		}, async (selector) => {
-			setExecutionModel(workdir, { modelSelector: selector, source: "user" });
-		});
-
-		assert.equal(recorded.selects.length, 1);
-		assert.equal(recorded.selects[0]?.options[0], "Inherit current session model");
-		assert.equal(selection?.selector, "p/m:high");
-		assert.equal(showConfig(workdir).execution.source, "user");
-		assert.equal(showConfig(workdir).execution.model_selector, null);
-	});
-
-	it("does not prompt when the execution model is already confirmed as inherit", async () => {
-		const workdir = freshWorkdir();
-		const { ctx, recorded } = makeHarness(workdir);
-		initState(workdir);
-		setExecutionModel(workdir, { modelSelector: "inherit", source: "user" });
-		const selection = await chooseExecutionModelSelection(ctx as any, "Execution model", showConfig(workdir).execution);
-
-		assert.equal(recorded.selects.length, 0);
-		assert.equal(selection?.selector, "p/m:high");
-	});
-
-	it("continues on the current model with a warning when the selector is unavailable", async () => {
-		const workdir = freshWorkdir();
-		const { ctx, recorded } = makeHarness(workdir);
-		(ctx as any).hasUI = false;
-		const selection = await chooseExecutionModelSelection(ctx as any, "Execution model", {
-			model_selector: "prov/missing:xhigh",
-			source: "user",
-			updated_at: null,
-		});
-
-		assert.equal(selection?.provider, "p");
-		assert.ok(recorded.notifies.some((n) => n.severity === "warning" && n.message.includes("prov/missing")));
-	});
-
-	it("keeps the status bar count-free while executing and points at the panel", async () => {
+	it("keeps the execution status bar current while executing", async () => {
 		const workdir = freshWorkdir();
 		const { pi, ctx, recorded } = makeHarness(workdir);
 		await startExecution(pi, ctx, path.join(workdir, "PLAN_v2.md"), items("VC-001", "VC-002"));
@@ -519,32 +392,6 @@ describe("execution loop", () => {
 		assert.equal(getExecution(), null);
 	});
 
-	it("defers persistence and widget churn when toggling mid-turn", async () => {
-		const workdir = freshWorkdir();
-		const { pi, ctx, recorded } = makeHarness(workdir);
-		await startExecution(pi, ctx, path.join(workdir, "PLAN_v3.md"), items("VC-001", "VC-002"));
-
-		const entriesBefore = recorded.entries.length;
-		const factoriesBefore = recorded.widgetCalls;
-
-		// Mid-turn: flip must be pure memory — no session writes, no re-register.
-		(ctx as any).isIdle = () => false;
-		assert.equal(toggleExecutionPanelView(pi, ctx), true);
-		assert.equal(recorded.entries.length, entriesBefore, "busy toggle appended a session entry");
-		assert.equal(recorded.widgetCalls, factoriesBefore, "busy toggle re-registered the widget");
-		assert.equal(consumePendingPanelSync(), true, "expected a pending panel sync marker");
-		assert.equal(consumePendingPanelSync(), false, "marker should be consumed exactly once");
-
-		// Back to idle: the next toggle persists and syncs without touching the
-		// widget slot because the panel is collapsed again.
-		ctx.isIdle = () => true;
-		assert.equal(toggleExecutionPanelView(pi, ctx), false);
-		assert.ok(recorded.entries.length > entriesBefore, "idle toggle did not persist");
-		assert.equal(recorded.widgetCalls, factoriesBefore, "collapsed toggle churned the widget registration");
-
-		await stopExecution(pi, ctx, "test-done");
-	});
-
 	it("lets Pi core own execution compaction scheduling and customizes every reason", async () => {
 		const workdir = freshWorkdir();
 		const { pi, ctx, setUsagePercent } = makeHarness(workdir);
@@ -599,15 +446,73 @@ describe("execution loop", () => {
 		await stopExecution(pi, ctx, "test-done");
 	});
 
-	it("does not install an execution threshold trigger in turn_end", () => {
+	it("triggers execution compaction at the high watermark, suppresses repeats, and re-arms below the low watermark", async () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded, setUsagePercent } = makeHarness(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v9.md"), items("VC-001", "VC-002"));
+
+		setUsagePercent(96);
+		handleExecutionTurnCompaction(ctx);
+		assert.equal(recorded.compacts?.length ?? 0, 1, "first high-watermark turn should request one compact");
+
+		handleExecutionTurnCompaction(ctx);
+		assert.equal(recorded.compacts?.length ?? 0, 1, "in-flight compact must not be requested twice");
+
+		handleExecutionCompact(pi, ctx, {
+			type: "session_compact",
+			compactionEntry: { type: "compaction" } as never,
+			fromExtension: true,
+			reason: "threshold",
+			willRetry: false,
+		});
+		assert.equal(
+			recorded.messages.filter((message) => message.customType === "pi-plans-exec-resume").length,
+			1,
+			"non-retry execution compaction should queue one hidden resume",
+		);
+
+		setUsagePercent(96);
+		handleExecutionTurnCompaction(ctx);
+		assert.equal(recorded.compacts?.length ?? 0, 1, "resume guard should suppress the immediate follow-up turn");
+
+		setUsagePercent(79);
+		handleExecutionTurnCompaction(ctx);
+		assert.equal(recorded.compacts?.length ?? 0, 1, "low-watermark turns stay quiet while below re-arm");
+
+		setUsagePercent(96);
+		handleExecutionTurnCompaction(ctx);
+		assert.equal(recorded.compacts?.length ?? 0, 2, "high watermark should re-arm after the low-watermark drop");
+
+		await stopExecution(pi, ctx, "test-done");
+	});
+
+	it("skips proactive current-I compaction when no eligible prefix exists", async () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v22.md"), items("VC-001"), [
+			{ id: "I-001", text: "First item." },
+		]);
+		(ctx.sessionManager as any).getBranch = () => [
+			{ id: "only", type: "message", tokens: 30000, message: { role: "assistant", content: [{ type: "text", text: "[I-001:current] one oversized turn" }] } },
+		];
+		handleExecutionTurnCompaction(ctx);
+		assert.equal(recorded.compacts?.length ?? 0, 0);
+		await stopExecution(pi, ctx, "no-prefix");
+	});
+	it("wires execution compaction without restoring execution model helpers", () => {
 		const indexSource = fs.readFileSync(path.join(process.cwd(), "index.ts"), "utf8");
 		const execSource = fs.readFileSync(path.join(process.cwd(), "src/exec.ts"), "utf8");
-		const turnEndStart = execSource.indexOf('pi.on("turn_end"');
-		const nextSection = execSource.indexOf("type CompactBranchEntry", turnEndStart);
-		assert.match(indexSource, /registerExecutionTurnHandlers\(pi/);
-		assert.ok(turnEndStart >= 0);
-		assert.ok(nextSection > turnEndStart);
-		assert.doesNotMatch(execSource.slice(turnEndStart, nextSection), /requestExecutionCompaction|shouldTriggerExecutionCompaction|ctx\.compact/);
+		assert.match(indexSource, /handleExecutionTurnCompaction/);
+		assert.match(execSource, /shouldTriggerExecutionCompaction/);
+		assert.match(execSource, /requestExecutionCompaction/);
+		assert.doesNotMatch(
+			indexSource,
+			/setExecutionModel|chooseExecutionModelSelection|snapshotCurrentModelSelector|ensureExecutionModelActive|restorePlanningModel/,
+		);
+		assert.doesNotMatch(
+			execSource,
+			/setExecutionModel|chooseExecutionModelSelection|snapshotCurrentModelSelector|ensureExecutionModelActive|restorePlanningModel/,
+		);
 	});
 
 	it("queues one non-retry resume, skips overflow retry, and keeps execution after failure", async () => {
@@ -708,7 +613,48 @@ describe("execution loop", () => {
 		await stopExecution(pi, ctx, "test-done");
 	});
 
-	it("filters the hidden resume message out of the LLM context payload", () => {
+	it("uses the current model for bounded valid summaries and falls back on invalid output", async () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v21.md"), items("VC-001"), [
+			{ id: "I-001", text: "First item." },
+		]);
+		const signal = new AbortController().signal;
+		const calls: unknown[][] = [];
+		let response: any = {
+			stopReason: "stop",
+			content: [{ type: "text", text: "## Implementation Items\n- I-001\n\n## Current I\n- I-001\n\n## Read Records\n- none\n\n## Compaction Boundary\n- a-2\n\n## Decisions\n- preserved\n\n## Open Questions\n- none\n\n## Next Steps\n- continue" }],
+			usage: { input: 12, output: 34 },
+		};
+		(ctx.modelRegistry as any).complete = async (...args: unknown[]) => {
+			calls.push(args);
+			return response;
+		};
+		const event: any = {
+			type: "session_before_compact",
+			preparation: makePreparation("threshold", null),
+			branchEntries: [
+				{ id: "i-1", type: "message", tokens: 100, message: { role: "assistant", content: [{ type: "text", text: "[I-001:current] work" }] } },
+				{ id: "a-1", type: "message", tokens: 100, message: { role: "assistant", content: [{ type: "text", text: "details" }] } },
+			],
+			reason: "threshold",
+			willRetry: false,
+			signal,
+		};
+		const valid = await handleExecutionBeforeCompact(pi, ctx, event);
+		assert.ok(valid?.compaction);
+		assert.equal(calls[0]?.[0], recorded.current);
+		assert.equal((calls[0]?.[2] as any).signal, signal);
+		assert.equal((calls[0]?.[2] as any).cacheRetention, "none");
+		assert.ok((calls[0]?.[2] as any).maxTokens <= 2048);
+		assert.deepEqual(valid?.compaction?.usage, response.usage);
+		assert.equal((valid?.compaction?.details as any)?.metrics?.summaryTokens, Math.ceil(response.content[0].text.length / 4));
+
+		response = { stopReason: "length", content: [{ type: "text", text: "## Implementation Items\npartial" }] };
+		const invalid = await handleExecutionBeforeCompact(pi, ctx, { ...event, signal: new AbortController().signal });
+		assert.equal(invalid, undefined, "incomplete model output must return control to Pi default compaction");
+		await stopExecution(pi, ctx, "model-test");
+	});	it("filters the hidden resume message out of the LLM context payload", () => {
 		const messages = [
 			{ customType: "user", content: "real prompt" },
 			{ customType: "pi-plans-exec-resume", content: "Continue execution." },
@@ -910,63 +856,10 @@ describe("execution loop", () => {
 		assert.equal(lastComplete.items?.[0]?.done, true, "completion snapshot missing final done state");
 	});
 
-	it("plans-list groups by implementation item with status tags and strikethrough", async () => {
-		const workdir = freshWorkdir();
-		const { pi, ctx, recorded } = makeHarness(workdir);
-		const implItems = [
-			{ id: "I-001", text: "Add state helpers; evaluate percent." },
-			{ id: "I-002", text: "Wire the turn_end trigger and status bar." },
-			{ id: "I-003", text: "Zero coverage orphan item." },
-		];
-		const vcItems: CheckItem[] = [
-			{ id: "VC-001", text: "`VC-001` covers `I-001`; pass condition: tests", done: false },
-			{ id: "VC-002", text: "`VC-002` covers `I-001` and `I-002`; pass condition: lint", done: false },
-		];
-		await startExecution(pi, ctx, path.join(workdir, "PLAN_v14.md"), vcItems, undefined, implItems);
-
-		// Status bar counts by I, excluding the zero-coverage orphan.
-		updateStatusWidget(ctx);
-		assert.match(recorded.status ?? "", /⌛ plans 0\/2: spent/);
-
-		toggleExecutionPanelView(pi, ctx);
-		assert.ok(recorded.widget);
-		// Expanded: footer ⌛ line cleared — the panel renders its own header.
-		assert.equal(recorded.status, undefined);
-		const widget = recorded.widget!.factory(
-			{} as any,
-			{ fg: (_c: string, t: string) => t, strikethrough: (t: string) => `~~${t}~~` },
-		);
-		const lines = widget.render(120).join("\n");
-		assert.match(lines, /⌛ plans 0\/2: spent/);
-		assert.match(lines, /\[Implementing\] I-001: Add state helpers/);
-		assert.match(lines, /\[Pending\] I-002: Wire the turn_end trigger/);
-		assert.match(lines, /\[Pending\] I-003: Zero coverage orphan item/);
-		// Only I status rows — no VC sub-rows in grouped mode.
-		assert.doesNotMatch(lines, /☐/);
-		assert.doesNotMatch(lines, /`VC-001` covers/);
-
-		// Markers move the states; fan-out advances both covered I items.
-		applyImplMarkers("[I-001:implemented]");
-		applyDoneMarkers("[DONE:VC-001]");
-		applyDoneMarkers("[DONE:VC-002]");
-		widget.invalidate();
-		const rendered = widget.render(120).join("\n");
-		assert.match(rendered, /~~\[VC passed\] I-001: Add state helpers~~/);
-		assert.match(rendered, /~~\[VC passed\] I-002: Wire the turn_end trigger and status bar\.~~/);
-
-		// Status bar now counts both I items as passed.
-		updateStatusWidget(ctx);
-		assert.equal(recorded.status, undefined, "expanded panel keeps the footer ⌛ line cleared");
-
-		await stopExecution(pi, ctx, "done");
-		// Panel cleared and execution over: the ⌛ line must not linger.
-		assert.doesNotMatch(recorded.status ?? "", /⌛ plans/);
-	});
-
 	it("updates the status bar in real time on every turn without session writes", async () => {
 		const workdir = freshWorkdir();
 		const { pi, ctx, recorded, setUsagePercent } = makeHarness(workdir);
-		await startExecution(pi, ctx, path.join(workdir, "PLAN_v15.md"), items("VC-001", "VC-002"), undefined, [
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v15.md"), items("VC-001", "VC-002"), [
 			{ id: "I-001", text: "First item." },
 			{ id: "I-002", text: "Second item." },
 		]);
@@ -1003,19 +896,6 @@ describe("execution loop", () => {
 		});
 		assert.match(recorded.status ?? "", /⌛ plans 1\/3: spent/);
 		assert.match(recorded.status ?? "", /12 in-toks/);
-		assert.equal(recorded.widgetCalls, 0, "collapsed progress must not touch the widget slot");
-
-		// Expanded progress is updated through the same event handler without
-		// re-registering the live widget.
-		toggleExecutionPanelView(pi, ctx);
-		const renderRequests = { count: 0 };
-		const widget = recorded.widget?.factory(
-			{ requestRender: () => { renderRequests.count += 1; } },
-			{ fg: (_color: string, text: string) => text, strikethrough: (text: string) => text },
-		);
-		assert.ok(widget);
-		assert.match(widget.render(100)[0] ?? "", /⌛ plans 1\/3: spent/);
-		const widgetCalls = recorded.widgetCalls;
 
 		await emit("message_end", {
 			message: { role: "assistant", usage: { input: 8, output: 3 } },
@@ -1023,17 +903,15 @@ describe("execution loop", () => {
 		await emit("turn_end", {
 			message: { role: "assistant", content: [{ type: "text", text: "verified [DONE:VC-002]" }] },
 		});
-		assert.equal(recorded.status, undefined, "expanded execution keeps the footer indicator cleared");
-		assert.equal(recorded.widgetCalls, widgetCalls, "progress refresh must reuse the live widget");
-		assert.equal(renderRequests.count, 1, "expanded progress must request a TUI render");
-		assert.match(widget.render(100)[0] ?? "", /⌛ plans 2\/3: spent/);
+		assert.match(recorded.status ?? "", /⌛ plans 2\/3: spent/);
+		assert.match(recorded.status ?? "", /20 in-toks/);
 
 		await stopExecution(pi, ctx, "event-chain-test");
 	});
 	it("applies impl markers with silent unknown ids and later-overwrite semantics", async () => {
 		const workdir = freshWorkdir();
 		const { pi, ctx } = makeHarness(workdir);
-		await startExecution(pi, ctx, path.join(workdir, "PLAN_v16.md"), items("VC-001"), undefined, [
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v16.md"), items("VC-001"), [
 			{ id: "I-001", text: "First item." },
 		]);
 
@@ -1045,6 +923,27 @@ describe("execution loop", () => {
 		await stopExecution(pi, ctx, "done");
 	});
 
+	it("applies current-I markers to the live progress bar and snapshot", async () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded, emit } = makeHarness(workdir);
+		registerExecutionTurnHandlers(pi);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v20.md"), items("VC-001", "VC-002", "VC-003"), [
+			{ id: "I-001", text: "First item." },
+			{ id: "I-002", text: "Second item." },
+			{ id: "I-003", text: "Third item." },
+		]);
+
+		await emit("turn_end", {
+			message: { role: "assistant", content: [{ type: "text", text: "starting [I-003:current]" }] },
+		});
+		assert.match(recorded.status ?? "", /⌛ plans 2\/3: spent/);
+		assert.equal(getExecution()?.currentI, "I-003");
+		drainExecutionFlush(pi, ctx);
+		const snapshot = recorded.entries.filter((entry) => entry.customType === "pi-plans-exec").at(-1)?.data as { currentI?: string };
+		assert.equal(snapshot.currentI, "I-003");
+		assert.equal(applyCurrentIMarker("[I-999:current]"), false);
+		await stopExecution(pi, ctx, "current-I-test");
+	});
 	it("replays impl markers from post-snapshot messages on restore", async () => {
 		const workdir = freshWorkdir();
 		const { pi, ctx } = makeHarness(workdir);
@@ -1064,15 +963,21 @@ describe("execution loop", () => {
 		assert.equal(getExecution()?.implStatus?.["I-001"], "implemented");
 	});
 
+
 	it("keeps the injection rules teaching the impl markers", async () => {
 		const workdir = freshWorkdir();
 		const { pi, ctx } = makeHarness(workdir);
-		await startExecution(pi, ctx, path.join(workdir, "PLAN_v18.md"), items("VC-001"), undefined, [
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v18.md"), items("VC-001"), [
 			{ id: "I-001", text: "First item." },
 		]);
 		const rules = executionContextMessage()!;
 		assert.match(rules, /\[I-001:implemented\]/);
 		assert.match(rules, /\[I-001:validating\]/);
+		assert.match(rules, /subprocess-backed verification/);
+		assert.match(rules, /waiting for/);
+		assert.match(rules, /5s\s*->\s*10s\s*->\s*20s\s*->\s*40s\s*->\s*80s/);
+		assert.match(rules, /keep polling at 80s/);
+		assert.match(rules, /restart at 5s for each new subprocess/);
 		await stopExecution(pi, ctx, "done");
 	});
 

package/tests/execute-plan.test.ts

@@ -0,0 +1,65 @@
+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, before, describe, it } from "node:test";
+
+import { getExecution, startExecution, stopExecution } from "../src/exec.ts";
+
+let tmpRoot: string;
+
+before(() => {
+	tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-execute-test-"));
+});
+
+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;
+}
+
+describe("execute handoff", () => {
+	it("starts execution without switching models", async () => {
+		const workdir = mkWorkdir("handoff");
+		const recorded = {
+			messages: [] as string[],
+			entries: [] as Array<{ customType: string; data: unknown }>,
+			setModelCalls: 0,
+		};
+		const pi = {
+			appendEntry: (customType: string, data: unknown) => {
+				recorded.entries.push({ customType, data });
+			},
+			sendMessage: (message: { customType: string; content: string }) => {
+				recorded.messages.push(message.content);
+			},
+			setModel: async () => {
+				recorded.setModelCalls += 1;
+				return true;
+			},
+		};
+		const ctx = {
+			cwd: workdir,
+			ui: {
+				setStatus: () => {},
+				theme: {
+					fg: (_kind: string, text: string) => text,
+					bold: (text: string) => text,
+				},
+			},
+		} as any;
+
+		await startExecution(pi as any, ctx, path.join(workdir, "PLAN_v1.md"), [
+			{ id: "VC-001", text: "first item", done: false },
+		] as any);
+		assert.equal(recorded.setModelCalls, 0);
+		assert.ok(getExecution());
+
+		await stopExecution(pi as any, ctx, "cleanup");
+		assert.equal(getExecution(), null);
+	});
+});

package/tests/plan.test.ts

@@ -5,7 +5,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { after, before, describe, it } from "node:test";
-import { latestPlanVersion, nextPlanVersionPath, parseChecklist, parseImplItems, resolveImplStatuses, scanDoneMarkers, scanImplMarkers, shortImplDescription, extractCoverage } from "../src/plan.ts";
+import { latestPlanVersion, nextPlanVersionPath, parseChecklist, parseImplItems, resolveImplStatuses, scanCurrentIMarkers, scanDoneMarkers, scanImplMarkers, shortImplDescription, extractCoverage, resolveCurrentI, inferCurrentI } from "../src/plan.ts";
 
 const PLAN = `# PLAN_v1 - demo
 
@@ -148,6 +148,16 @@ describe("implementation items", () => {
 		assert.deepEqual(extractCoverage("no coverage clause here"), []);
 	});
 
+	it("parses and resolves current-I markers without changing progress marker states", () => {
+		const implItems = [{ id: "I-001", text: "first" }, { id: "I-002", text: "second" }];
+		assert.deepEqual(scanCurrentIMarkers("[I-001:current] [I-999:current] [I-002:current]"), [
+			{ id: "I-001" },
+			{ id: "I-999" },
+			{ id: "I-002" },
+		]);
+		assert.equal(resolveCurrentI(implItems, scanCurrentIMarkers("[I-999:current] [I-002:current]")), "I-002");
+		assert.equal(inferCurrentI(implItems, [], undefined), "I-001");
+	});
 	it("scans impl markers", () => {
 		assert.deepEqual(scanImplMarkers("[I-001:implemented] then [I-002:validating] and [I-003:done]"), [
 			{ id: "I-001", state: "implemented" },