pi-plans 0.1.2 → 0.3.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,7 +21,11 @@ import {
 	getExecution,
 	handleExecutionBeforeCompact,
 	handleExecutionCompact,
+	handleExecutionTurnCompaction,
 	handleExecutionCompactFailed,
+	compactionInFlight,
+	noteCompactionStarted,
+	noteCompactionEnded,
 	handlePlanningBeforeCompact,
 	handlePlanningCompact,
 	handlePlanningCompactFailed,
@@ -32,17 +36,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, setGraphEnabled, setRunStatus, startRun } from "../src/state.ts";
 
 interface Recorded {
 	entries: { type: string; customType?: string; data?: unknown }[];
@@ -50,8 +51,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 }[];
@@ -59,6 +58,7 @@ interface Recorded {
 	selectAnswer?: string;
 	current: { provider: string; id: string } | null;
 	thinking: string | null;
+	userMessages: string[];
 	compacts?: { customInstructions?: string }[];
 }
 
@@ -76,13 +76,13 @@ function makeHarness(workdir: string): Harness {
 		status: undefined,
 		statusCalls: 0,
 		colors: [],
-		widgetCalls: 0,
 		models: [],
 		thinkingLevels: [],
 		notifies: [],
 		selects: [],
 		current: { provider: "p", id: "m" },
 		thinking: "high",
+		userMessages: [],
 	};
 	let contextPercent: number | null = 0;
 	const registryModels = [
@@ -113,7 +113,9 @@ function makeHarness(workdir: string): Harness {
 		sendMessage: (message: { customType: string; content: string }, options?: { triggerTurn?: boolean }) => {
 			recorded.messages.push({ ...message, options });
 		},
-		sendUserMessage: async () => {},
+		sendUserMessage: async (content: string) => {
+			recorded.userMessages.push(content);
+		},
 		setModel: async (model: { provider: string; id: string }) => {
 			recorded.models.push({ provider: model.provider, id: model.id });
 			recorded.current = { provider: model.provider, id: model.id };
@@ -129,14 +131,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 });
 		},
@@ -190,6 +184,22 @@ function items(...ids: string[]): CheckItem[] {
 	return ids.map((id) => ({ id, text: `\`${id}\` demo item`, done: false }));
 }
 
+function compactableBranchEntries(): any[] {
+	return [
+		{ id: "u-1", type: "message", message: { role: "user", content: [{ type: "text", text: "start the work" }] } },
+		{ id: "a-1", type: "message", message: { role: "assistant", content: [{ type: "text", text: "made progress" }] } },
+		{ id: "u-2", type: "message", message: { role: "user", content: [{ type: "text", text: "continue from here" }] } },
+		{ id: "a-2", type: "message", message: { role: "assistant", content: [{ type: "text", text: "tail work" }] } },
+	];
+}
+
+function startActiveRun(workdir: string, status: "planning" | "executing" = "planning") {
+	initState(workdir);
+	const { run } = startRun(workdir, { topic: "compact", skill: "plan-normal", requestText: "x" });
+	if (status !== "planning") setRunStatus(workdir, run.run_id, status);
+	return run;
+}
+
 describe("execution loop", () => {
 	let tmpRoot: string;
 	let counter = 0;
@@ -214,36 +224,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()!;
+		const rules = executionContextMessage(ctx)!;
 		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/);
@@ -263,24 +257,93 @@ describe("execution loop", () => {
 		assert.ok(recorded.messages.some((message) => message.customType === "pi-plans-complete"));
 	});
 
-	it("restores progress from session entries and rescans messages", async () => {
+	it("completion enters goal-running continuation and triggers a turn in interactive sessions", async () => {
 		const workdir = freshWorkdir();
 		const { pi, ctx, recorded } = makeHarness(workdir);
+		const planPath = path.join(workdir, "PLAN_v1.md");
+		await startExecution(pi, ctx, planPath, items("VC-001", "VC-002"));
+		assert.deepEqual(applyDoneMarkers("[DONE:VC-001] [DONE:VC-002]"), ["VC-001", "VC-002"]);
+
+		await completeExecution(pi, ctx);
+
+		const completeMessage = recorded.messages.find((message) => message.customType === "pi-plans-complete");
+		assert.ok(completeMessage);
+		assert.match(completeMessage.content, /Goal-running continuation/);
+		assert.match(completeMessage.content, /termination condition of the implementation-review loop/);
+		assert.doesNotMatch(completeMessage.content, /Run a post-execution amelioration round/);
+		assert.equal(completeMessage.options?.triggerTurn, true);
+		const ameliorateEntry = recorded.entries.find((entry) => entry.customType === "pi-plans-ameliorate");
+		assert.ok(ameliorateEntry);
+		const data = ameliorateEntry.data as Record<string, unknown>;
+		assert.equal(data.phase, "goal-started");
+		assert.equal(data.rounds, null);
+		assert.equal(data.currentRound, 0);
+		assert.equal(data.planPath, planPath);
+	});
+
+	it("completion stays silent in headless sessions", async () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v1.md"), items("VC-001"));
+		assert.deepEqual(applyDoneMarkers("[DONE:VC-001]"), ["VC-001"]);
+		(ctx as any).hasUI = false;
+
+		await completeExecution(pi, ctx);
+
+		const completeMessage = recorded.messages.find((message) => message.customType === "pi-plans-complete");
+		assert.ok(completeMessage);
+		assert.doesNotMatch(completeMessage.content, /Goal-running continuation/);
+		assert.equal(completeMessage.options?.triggerTurn, false);
+		assert.equal(
+			recorded.entries.some((entry) => entry.customType === "pi-plans-ameliorate"),
+			false,
+			"headless completion must not append the ameliorate entry",
+		);
+	});
+
+	it("restoreFromSession completion triggers the same goal-running continuation in interactive sessions", async () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		const planPath = path.join(workdir, "PLAN_v1.md");
+		fs.writeFileSync(planPath, "# plan");
 		const snapshot = {
-			planPath: path.join(workdir, "PLAN_v1.md"),
+			planPath,
 			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"] },
-					},
+			usage: { inToks: 0, outToks: 0 },
+			implItems: [],
+			implStatus: {},
+			compaction: {
+				inFlight: true,
+				resumeGuard: true,
+				cooldownActive: true,
+				lastAttemptReason: "threshold",
+				lastSuccessfulUsagePercent: 100,
+				lastSuccessfulAt: "2026-08-25T00:01:00Z",
 			},
+		};
+		const entries = [
+			{ type: "custom", customType: "pi-plans-exec", data: snapshot },
+			{
+				type: "message",
+				message: { role: "assistant", content: [{ type: "text", text: "did [DONE:VC-001] [DONE:VC-002]" }] },
 			},
+		];
+		await restoreFromSession(pi, ctx, entries as any);
+		const completeMessage = recorded.messages.find((message) => message.customType === "pi-plans-complete");
+		assert.ok(completeMessage, "restore path must fire completeExecution");
+		assert.match(completeMessage.content, /Goal-running continuation/);
+		assert.equal(completeMessage.options?.triggerTurn, true);
+		assert.ok(recorded.entries.some((entry) => entry.customType === "pi-plans-ameliorate"));
+	});
+
+	it("restores progress from session entries and rescans messages", async () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		const snapshot = {
+			planPath: path.join(workdir, "PLAN_v1.md"),
+			items: items("VC-001", "VC-002"),
+			startedAt: "2026-08-25T00:00:00Z",
 			compaction: {
 				inFlight: true,
 				resumeGuard: true,
@@ -302,15 +365,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 +397,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,62 +495,51 @@ describe("execution loop", () => {
 		assert.equal(getExecution(), null);
 	});
 
-	it("defers persistence and widget churn when toggling mid-turn", async () => {
+	it("returns control to Pi core without active execution or planning state", 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");
-	});
+		const { pi, ctx } = makeHarness(workdir);
 
-	it("lets Pi core own execution compaction scheduling and customizes every reason", async () => {
-		const workdir = freshWorkdir();
-		const { pi, ctx, setUsagePercent } = makeHarness(workdir);
-		await startExecution(pi, ctx, path.join(workdir, "PLAN_v8.md"), items("VC-001", "VC-002"));
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v0.md"), items("VC-001"));
+		const executionResult = handleExecutionBeforeCompact(pi, ctx, {
+			type: "session_before_compact",
+			preparation: makePreparation("threshold", null),
+			branchEntries: compactableBranchEntries(),
+			reason: "threshold",
+			willRetry: false,
+			signal: new AbortController().signal,
+		});
+		assert.equal(executionResult, undefined);
+		await stopExecution(pi, ctx, "no-active-run");
 
-		setUsagePercent(50);
-		const below = handleExecutionBeforeCompact(pi, ctx, {
+		const planningResult = handlePlanningBeforeCompact(pi as any, ctx as any, {
 			type: "session_before_compact",
 			preparation: makePreparation("threshold", null),
-			branchEntries: [],
+			branchEntries: compactableBranchEntries(),
 			reason: "threshold",
 			willRetry: false,
 			signal: new AbortController().signal,
 		});
-		assert.equal(below?.cancel, undefined);
-		assert.ok(below?.compaction, "threshold compaction should remain Pi-core-owned but use the custom summary");
+		assert.equal(planningResult, undefined);
+	});
 
-		setUsagePercent(105);
-		const above = handleExecutionBeforeCompact(pi, ctx, {
+	it("lets Pi core own execution compaction scheduling and customizes safe reasons", async () => {
+		const workdir = freshWorkdir();
+		startActiveRun(workdir);
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v8.md"), items("VC-001", "VC-002"));
+
+		const threshold = handleExecutionBeforeCompact(pi, ctx, {
 			type: "session_before_compact",
 			preparation: makePreparation("threshold", null),
-			branchEntries: [],
+			branchEntries: compactableBranchEntries(),
 			reason: "threshold",
 			willRetry: false,
 			signal: new AbortController().signal,
 		});
-		assert.equal(above?.cancel, undefined);
-		assert.ok(above?.compaction);
+		assert.equal(threshold?.cancel, undefined);
+		assert.ok(threshold?.compaction, "threshold compaction should use the VCC summary when a legal cut exists");
 
-		const overflow = handleExecutionBeforeCompact(pi, ctx, {
+		const overflowRetry = handleExecutionBeforeCompact(pi, ctx, {
 			type: "session_before_compact",
 			preparation: makePreparation("overflow", null),
 			branchEntries: [],
@@ -582,8 +547,7 @@ describe("execution loop", () => {
 			willRetry: true,
 			signal: new AbortController().signal,
 		});
-		assert.equal(overflow?.cancel, undefined);
-		assert.ok(overflow?.compaction);
+		assert.equal(overflowRetry, undefined, "overflow retry falls back to Pi core when VCC has no safe cut");
 
 		const manual = handleExecutionBeforeCompact(pi, ctx, {
 			type: "session_before_compact",
@@ -593,53 +557,116 @@ describe("execution loop", () => {
 			willRetry: false,
 			signal: new AbortController().signal,
 		});
-		assert.equal(manual?.cancel, undefined);
-		assert.ok(manual?.compaction);
+		assert.equal(manual?.cancel, true, "manual compaction cancels instead of discarding unsafe context");
+		assert.ok(recorded.notifies.some((note) => note.message.includes("Nothing to compact")));
+
+		await stopExecution(pi, ctx, "test-done");
+	});
+
+	it("does not proactively request execution compaction", async () => {
+		const workdir = freshWorkdir();
+		startActiveRun(workdir);
+		const { pi, ctx, recorded, setUsagePercent } = makeHarness(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v9.md"), items("VC-001", "VC-002"));
+
+		setUsagePercent(99);
+		handleExecutionTurnCompaction(ctx);
+		handleExecutionTurnCompaction(ctx);
+		assert.equal(recorded.compacts?.length ?? 0, 0, "execution scheduling is owned by Pi core");
 
 		await stopExecution(pi, ctx, "test-done");
 	});
 
-	it("does not install an execution threshold trigger in turn_end", () => {
+	it("ignores current-I growth for proactive execution compaction", async () => {
+		const workdir = freshWorkdir();
+		startActiveRun(workdir);
+		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 proactive requests or 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.doesNotMatch(execSource, /ctx\.compact\(/);
+		assert.doesNotMatch(
+			indexSource,
+			/setExecutionModel|chooseExecutionModelSelection|snapshotCurrentModelSelector|ensureExecutionModelActive|restorePlanningModel/,
+		);
+		assert.doesNotMatch(
+			execSource,
+			/setExecutionModel|chooseExecutionModelSelection|snapshotCurrentModelSelector|ensureExecutionModelActive|restorePlanningModel|buildModelExecutionCompactionResult|modelRegistry\.complete/,
+		);
 	});
 
-	it("queues one non-retry resume, skips overflow retry, and keeps execution after failure", async () => {
+	it("auto-continues execution only for threshold/overflow and honors manual follow-up prompts", async () => {
 		const workdir = freshWorkdir();
+		startActiveRun(workdir);
 		const { pi, ctx, recorded } = makeHarness(workdir);
+		(ctx as any).piVersion = "0.84.3";
 		await startExecution(pi, ctx, path.join(workdir, "PLAN_v9.md"), items("VC-001"));
 
-		const beforeRequests = recorded.compacts?.length ?? 0;
-		handleExecutionCompact(pi, ctx, {
+		const threshold = handleExecutionBeforeCompact(pi, ctx, {
+			type: "session_before_compact",
+			preparation: makePreparation("threshold", null),
+			branchEntries: compactableBranchEntries(),
+			reason: "threshold",
+			willRetry: false,
+			signal: new AbortController().signal,
+		});
+		assert.ok(threshold?.compaction);
+		await handleExecutionCompact(pi, ctx, {
 			type: "session_compact",
 			compactionEntry: { type: "compaction" } as never,
-			fromExtension: true,
+			fromExtension: false,
 			reason: "threshold",
 			willRetry: false,
 		});
-		const resumes = recorded.messages.filter((message) => message.customType === "pi-plans-exec-resume");
-		assert.equal(resumes.length, 1, "non-retry compaction should queue one hidden resume");
-		assert.equal(resumes[0]?.options?.triggerTurn, true);
-		assert.equal(recorded.compacts?.length ?? 0, beforeRequests, "compaction hook must not invoke ctx.compact");
+		assert.equal(recorded.messages.filter((message) => message.customType === "pi-plans-exec-resume").length, 1);
+		assert.ok(recorded.notifies.some((note) => note.message.startsWith("pi-vcc: kept")));
 
-		handleExecutionCompact(pi, ctx, {
+		handleExecutionBeforeCompact(pi, ctx, {
+			type: "session_before_compact",
+			preparation: makePreparation("manual", null),
+			branchEntries: compactableBranchEntries(),
+			reason: "manual",
+			willRetry: false,
+			signal: new AbortController().signal,
+		});
+		await handleExecutionCompact(pi, ctx, {
 			type: "session_compact",
 			compactionEntry: { type: "compaction" } as never,
-			fromExtension: true,
-			reason: "overflow",
-			willRetry: true,
+			fromExtension: false,
+			reason: "manual",
+			willRetry: false,
 		});
-		assert.equal(
-			recorded.messages.filter((message) => message.customType === "pi-plans-exec-resume").length,
-			1,
-			"overflow retry is owned by Pi core",
-		);
+		assert.equal(recorded.messages.filter((message) => message.customType === "pi-plans-exec-resume").length, 1);
+
+		handleExecutionBeforeCompact(pi, ctx, {
+			type: "session_before_compact",
+			preparation: makePreparation("manual", null),
+			branchEntries: compactableBranchEntries(),
+			customInstructions: "Run focused tests keep:1",
+			reason: "manual",
+			willRetry: false,
+			signal: new AbortController().signal,
+		});
+		await handleExecutionCompact(pi, ctx, {
+			type: "session_compact",
+			compactionEntry: { type: "compaction" } as never,
+			fromExtension: false,
+			reason: "manual",
+			willRetry: false,
+		});
+		assert.deepEqual(recorded.userMessages, ["Run focused tests"]);
 
 		handleExecutionCompactFailed(pi, ctx, {
 			type: "session_compact_failed",
@@ -655,29 +682,30 @@ describe("execution loop", () => {
 		await stopExecution(pi, ctx, "test-done");
 	});
 
-	it("builds a plan-aware summary with per-item sections and chains the previous summary", async () => {
+	it("builds a VCC execution summary with phase context and previous summary", async () => {
 		const workdir = freshWorkdir();
-		const { pi, ctx, setUsagePercent } = makeHarness(workdir);
-		await startExecution(pi, ctx, path.join(workdir, "PLAN_v10.md"), items("VC-001", "VC-002"));
-
-		applyDoneMarkers("[DONE:VC-001]");
+		startActiveRun(workdir);
+		const { pi, ctx } = makeHarness(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v10.md"), items("VC-001", "VC-002"), [
+			{ id: "I-001", text: "First item." },
+			{ id: "I-002", text: "Second item." },
+		]);
 
-		const previousSummary = "## Goal\nDeliver auto-compact in execution phase.\n\n## Finished Items\n- legacy VC-000 summary";
+		const previousSummary = "## Legacy Summary\nDeliver auto-compact in execution phase.";
+		applyCurrentIMarker("[I-002:current]");
 		const preparation = makePreparation("threshold", previousSummary);
 		const branchEntries: any[] = [
-			{ id: "exec-start", type: "custom", customType: "pi-plans-exec-start" },
 			{ id: "u-1", type: "message", message: { role: "user", content: [{ type: "text", text: "implement VC-001" }] } },
-			{ id: "a-1", type: "message", message: { role: "assistant", content: [{ type: "text", text: "wrote helper [DONE:VC-001]" }] } },
+			{ id: "a-1", type: "message", message: { role: "assistant", content: [{ type: "text", text: "wrote helper [I-002:current]" }] } },
 			{ id: "u-2", type: "message", message: { role: "user", content: [{ type: "text", text: "implement VC-002" }] } },
 			{ id: "a-2", type: "message", message: { role: "assistant", content: [{ type: "text", text: "almost done" }] } },
-			{ id: "exec-ctx", type: "custom", customType: "pi-plans-exec-context" },
 		];
 		const result = buildExecutionCompactionResult(
 			{
 				type: "session_before_compact",
 				preparation,
 				branchEntries,
-				customInstructions: "keep current task visible",
+				customInstructions: "keep:1",
 				reason: "threshold",
 				willRetry: false,
 				signal: new AbortController().signal,
@@ -685,30 +713,51 @@ describe("execution loop", () => {
 			ctx,
 		);
 		assert.ok(result);
-		assert.match(result!.summary, /## Compact Instructions/);
-		assert.match(result!.summary, /keep current task visible/);
-		assert.match(result!.summary, /## Plan Before This Run/);
-		assert.match(result!.summary, /## Previous Compact Summary/);
-		assert.match(result!.summary, /## Finished VC Items/);
-		assert.match(result!.summary, /### `VC-001`/);
-		assert.match(result!.summary, /## Current Work/);
-		assert.match(result!.summary, /Raw tail preserved from `u-2`/);
-		assert.deepEqual(result!.firstKeptEntryId, "u-2");
-
-		setUsagePercent(110);
-		handleExecutionBeforeCompact(pi, ctx, {
+		assert.equal(result!.firstKeptEntryId, "u-2");
+		assert.match(result!.summary, /\[Session Goal\]/);
+		assert.match(result!.summary, /Execute accepted plan/);
+		assert.match(result!.summary, /\[Outstanding Context\]/);
+		assert.match(result!.summary, /Current implementation item: I-002/);
+		assert.match(result!.summary, /Remaining verifier items: VC-001, VC-002/);
+		assert.match(result!.summary, /Previous compact summary: Legacy Summary Deliver auto-compact/);
+		assert.equal((result!.details as any).compactor, "pi-vcc");
+		assert.equal((result!.details as any).phase, "execution");
+
+		await stopExecution(pi, ctx, "test-done");
+	});
+
+	it("does not call model helpers and respects overrideDefaultCompaction=false", async () => {
+		const workdir = freshWorkdir();
+		startActiveRun(workdir);
+		const { pi, ctx } = makeHarness(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v21.md"), items("VC-001"), [
+			{ id: "I-001", text: "First item." },
+		]);
+		let completeCalled = false;
+		(ctx.modelRegistry as any).complete = async () => {
+			completeCalled = true;
+			return {};
+		};
+		const event: any = {
 			type: "session_before_compact",
-			preparation,
-			branchEntries,
+			preparation: makePreparation("threshold", null),
+			branchEntries: compactableBranchEntries(),
 			reason: "threshold",
 			willRetry: false,
 			signal: new AbortController().signal,
-		});
+		};
+		const valid = handleExecutionBeforeCompact(pi, ctx, event);
+		assert.ok(valid?.compaction);
+		assert.equal(completeCalled, false);
 
-		await stopExecution(pi, ctx, "test-done");
-	});
+		const configPath = path.join(workdir, ".git", "pi_plans", "pi-vcc-config.json");
+		fs.writeFileSync(configPath, JSON.stringify({ overrideDefaultCompaction: false }), "utf8");
+		const fallback = handleExecutionBeforeCompact(pi, ctx, { ...event, signal: new AbortController().signal });
+		assert.equal(fallback, undefined, "override-disabled should return control to Pi default compaction");
 
-	it("filters the hidden resume message out of the LLM context payload", () => {
+		await stopExecution(pi, ctx, "model-test");
+	});
+	it("filters the hidden resume message out of the model context payload", () => {
 		const messages = [
 			{ customType: "user", content: "real prompt" },
 			{ customType: "pi-plans-exec-resume", content: "Continue execution." },
@@ -719,37 +768,27 @@ describe("execution loop", () => {
 		assert.equal(filterPlanningResumeMessages(messages).length, 3);
 	});
 
-	it("planning compaction cuts at plan-written when present and falls back to run-start", () => {
+	it("builds a VCC planning summary from active-run session context", () => {
 		const workdir = freshWorkdir();
 		const { ctx } = makeHarness(workdir);
 		initState(workdir);
 		const { run } = startRun(workdir, { topic: "planning compact", skill: "plan-normal", requestText: "demo" });
-		fs.writeFileSync(path.join(run.artifact_dir, "PLAN_v1.md"), "# plan");
-
-		const makePlanningPreparation = (previousSummary: string | null) => ({
-			firstKeptEntryId: "fallback",
-			messagesToSummarize: [],
-			turnPrefixMessages: [],
-			isSplitTurn: false,
-			tokensBefore: 50000,
-			previousSummary,
-			fileOps: { read: [], written: [], edited: [] },
-			settings: { enabled: true, reserveTokens: 16384, keepRecentTokens: 20000 },
-		});
+		const planPath = path.join(run.artifact_dir, "PLAN_v1.md");
+		fs.writeFileSync(planPath, "# plan");
 
-		// Case A: plan written → cut at next non-internal entry after plan-written; QA section included.
-		const branchEntriesWithPlan = [
+		const branchEntries = [
 			{ id: "rs", type: "custom", customType: PLANNING_RUN_START_CUSTOM_TYPE, data: { runId: run.run_id, artifactDir: run.artifact_dir } },
 			{ id: "u-1", type: "message", message: { role: "user", content: [{ type: "text", text: "background question?" }] } },
-			{ id: "a-1", type: "message", message: { role: "assistant", content: [{ type: "text", text: "some context" }] } },
-			{ id: "pw", type: "custom", customType: PLANNING_PLAN_WRITTEN_CUSTOM_TYPE, data: { runId: run.run_id, planPath: path.join(run.artifact_dir, "PLAN_v1.md") } },
+			{ id: "a-1", type: "message", message: { role: "assistant", content: [{ type: "text", text: "some context [I-004:current]" }] } },
+			{ id: "pw", type: "custom", customType: PLANNING_PLAN_WRITTEN_CUSTOM_TYPE, data: { runId: run.run_id, planPath } },
 			{ id: "u-2", type: "message", message: { role: "user", content: [{ type: "text", text: "review please" }] } },
 		] as any;
 		const withPlan = buildPlanningCompactionResult(
 			{
 				type: "session_before_compact",
-				preparation: makePlanningPreparation(null),
-				branchEntries: branchEntriesWithPlan,
+				preparation: makePreparation("threshold", "## Previous\nEarlier summary."),
+				branchEntries,
+				customInstructions: "keep:1",
 				reason: "threshold",
 				willRetry: false,
 				signal: new AbortController().signal,
@@ -758,95 +797,57 @@ describe("execution loop", () => {
 		);
 		assert.ok(withPlan);
 		assert.deepEqual(withPlan!.firstKeptEntryId, "u-2");
-		assert.match(withPlan!.summary, /## Q&A During Planning/);
-		assert.match(withPlan!.summary, /background question?/);
-
-		// Case B: only run-start → cut at first non-internal entry after marker; no QA section.
-		const branchEntriesWithoutPlan = [
-			{ id: "rs", type: "custom", customType: PLANNING_RUN_START_CUSTOM_TYPE, data: { runId: run.run_id, artifactDir: run.artifact_dir } },
-			{ id: "u-1", type: "message", message: { role: "user", content: [{ type: "text", text: "open question" }] } },
-			{ id: "a-1", type: "message", message: { role: "assistant", content: [{ type: "text", text: "thinking out loud" }] } },
-		] as any;
-		const withoutPlan = buildPlanningCompactionResult(
-			{
-				type: "session_before_compact",
-				preparation: makePlanningPreparation(null),
-				branchEntries: branchEntriesWithoutPlan,
-				reason: "manual",
-				willRetry: false,
-				signal: new AbortController().signal,
-			},
-			ctx,
-		);
-		assert.ok(withoutPlan);
-		assert.deepEqual(withoutPlan!.firstKeptEntryId, "u-1");
-		assert.doesNotMatch(withoutPlan!.summary, /## Q&A During Planning/);
-
-		// Case C: no markers → fallback to preparation.firstKeptEntryId and no QA section.
-		const fallback = buildPlanningCompactionResult(
-			{
-				type: "session_before_compact",
-				preparation: makePlanningPreparation("## Previous\nEarlier summary."),
-				branchEntries: [],
-				reason: "threshold",
-				willRetry: false,
-				signal: new AbortController().signal,
-			},
-			ctx,
-		);
-		assert.ok(fallback);
-		assert.deepEqual(fallback!.firstKeptEntryId, "fallback");
-		assert.doesNotMatch(fallback!.summary, /## Q&A During Planning/);
-		assert.match(fallback!.summary, /## Previous Compact Summary/);
+		assert.match(withPlan!.summary, /\[Session Goal\]/);
+		assert.match(withPlan!.summary, new RegExp(run.run_id));
+		assert.match(withPlan!.summary, /\[Outstanding Context\]/);
+		assert.match(withPlan!.summary, /Latest plan path from session/);
+		assert.match(withPlan!.summary, /Planning artifact directory from session/);
+		assert.match(withPlan!.summary, /Current implementation marker observed during planning: I-004/);
+		assert.match(withPlan!.summary, /Previous compact summary: Previous Earlier summary\./);
+		assert.equal((withPlan!.details as any).compactor, "pi-vcc");
+		assert.equal((withPlan!.details as any).phase, "planning");
 	});
 
-	it("planning hook is gated by run.status=planning and defers to execution hook when execution is running", async () => {
+	it("planning hook is gated by run.status=planning and defers while execution is running", async () => {
 		const workdir = freshWorkdir();
-		const { ctx, setUsagePercent } = makeHarness(workdir);
+		const { pi, ctx } = makeHarness(workdir);
 		initState(workdir);
 		const { run } = startRun(workdir, { topic: "planning gate", skill: "plan-small", requestText: "x" });
 
-		setUsagePercent(110);
-		const resultPlanning = handlePlanningBeforeCompact({} as any, ctx as any, {
+		const resultPlanning = handlePlanningBeforeCompact(pi as any, ctx as any, {
 			type: "session_before_compact",
-			preparation: {
-				firstKeptEntryId: "fb",
-				messagesToSummarize: [],
-				turnPrefixMessages: [],
-				isSplitTurn: false,
-				tokensBefore: 1,
-				previousSummary: null,
-				fileOps: { read: [], written: [], edited: [] },
-				settings: { enabled: true, reserveTokens: 16384, keepRecentTokens: 20000 },
-			},
-			branchEntries: [],
+			preparation: makePreparation("threshold", null),
+			branchEntries: compactableBranchEntries(),
+			customInstructions: "keep:1",
 			reason: "threshold",
 			willRetry: false,
 			signal: new AbortController().signal,
 		});
-		assert.ok(resultPlanning?.compaction || resultPlanning === undefined);
+		assert.ok(resultPlanning?.compaction);
 
-		// Flip status to done; planning hook should refuse.
 		setRunStatus(workdir, run.run_id, "done");
-		setUsagePercent(110);
-		const resultDone = handlePlanningBeforeCompact({} as any, ctx as any, {
+		const resultDone = handlePlanningBeforeCompact(pi as any, ctx as any, {
 			type: "session_before_compact",
-			preparation: {
-				firstKeptEntryId: "fb",
-				messagesToSummarize: [],
-				turnPrefixMessages: [],
-				isSplitTurn: false,
-				tokensBefore: 1,
-				previousSummary: null,
-				fileOps: { read: [], written: [], edited: [] },
-				settings: { enabled: true, reserveTokens: 16384, keepRecentTokens: 20000 },
-			},
-			branchEntries: [],
+			preparation: makePreparation("threshold", null),
+			branchEntries: compactableBranchEntries(),
 			reason: "threshold",
 			willRetry: false,
 			signal: new AbortController().signal,
 		});
 		assert.equal(resultDone, undefined);
+
+		setRunStatus(workdir, run.run_id, "planning");
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v14.md"), items("VC-001"));
+		const duringExecution = handlePlanningBeforeCompact(pi as any, ctx as any, {
+			type: "session_before_compact",
+			preparation: makePreparation("threshold", null),
+			branchEntries: compactableBranchEntries(),
+			reason: "threshold",
+			willRetry: false,
+			signal: new AbortController().signal,
+		});
+		assert.equal(duringExecution, undefined);
+		await stopExecution(pi, ctx, "planning-gate");
 	});
 
 	it("turn_end writes are unconditionally deferred even when isIdle reads true", async () => {
@@ -910,63 +911,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 +951,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 +958,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 +978,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,54 +1018,429 @@ 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()!;
+		const rules = executionContextMessage(ctx)!;
 		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");
 	});
 
-	it("planning compaction honors cooldown + resume guard and survives manual /compact", () => {
+	it("does not proactively request planning compaction", () => {
 		const workdir = freshWorkdir();
-		const { pi, ctx, setUsagePercent, recorded } = makeHarness(workdir);
+		const { ctx, setUsagePercent, recorded } = makeHarness(workdir);
 		initState(workdir);
-		startRun(workdir, { topic: "planning cooldown", skill: "plan-normal", requestText: "x" });
+		startRun(workdir, { topic: "planning no-op", skill: "plan-normal", requestText: "x" });
 
 		setUsagePercent(120);
-		assert.equal(shouldTriggerPlanningCompaction(ctx as any), true);
-		requestPlanningCompaction(ctx as any);
-		// In flight, second trigger ignored.
-		requestPlanningCompaction(ctx as any);
 		assert.equal(shouldTriggerPlanningCompaction(ctx as any), false);
+		requestPlanningCompaction(ctx as any);
+		refreshPlanningCompactionCooldown(ctx as any);
+		assert.equal(recorded.compacts?.length ?? 0, 0, "planning scheduling is owned by Pi core");
+	});
 
-		setUsagePercent(50);
-		handlePlanningCompact(pi as any, ctx as any, {
+	it("auto-continues planning only for threshold/overflow and honors manual follow-up prompts", async () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		(ctx as any).piVersion = "0.84.3";
+		initState(workdir);
+		startRun(workdir, { topic: "planning success", skill: "plan-normal", requestText: "x" });
+
+		const threshold = handlePlanningBeforeCompact(pi as any, ctx as any, {
+			type: "session_before_compact",
+			preparation: makePreparation("threshold", null),
+			branchEntries: compactableBranchEntries(),
+			customInstructions: "keep:1",
+			reason: "threshold",
+			willRetry: false,
+			signal: new AbortController().signal,
+		});
+		assert.ok(threshold?.compaction);
+		await handlePlanningCompact(pi as any, ctx as any, {
 			type: "session_compact",
 			compactionEntry: { type: "compaction" } as never,
-			fromExtension: true,
-			reason: "manual",
+			fromExtension: false,
+			reason: "threshold",
 			willRetry: false,
 		});
-		const resume = recorded.messages.find((message) => message.customType === "pi-plans-plan-resume");
-		assert.ok(resume);
+		assert.equal(recorded.messages.filter((message) => message.customType === "pi-plans-plan-resume").length, 1);
 		assert.equal(consumePlanningCompactionResumeGuard(ctx as any), true);
-		// Cooldown blocks retrigger while usage is still mid-band.
-		setUsagePercent(95);
-		assert.equal(shouldTriggerPlanningCompaction(ctx as any), false);
-		setUsagePercent(50);
-		refreshPlanningCompactionCooldown(ctx as any);
+
+		handlePlanningBeforeCompact(pi as any, ctx as any, {
+			type: "session_before_compact",
+			preparation: makePreparation("manual", null),
+			branchEntries: compactableBranchEntries(),
+			customInstructions: "Ask the next question keep:1",
+			reason: "manual",
+			willRetry: false,
+			signal: new AbortController().signal,
+		});
+		await handlePlanningCompact(pi as any, ctx as any, {
+			type: "session_compact",
+			compactionEntry: { type: "compaction" } as never,
+			fromExtension: false,
+			reason: "manual",
+			willRetry: false,
+		});
+		assert.deepEqual(recorded.userMessages, ["Ask the next question"]);
+		assert.equal(recorded.messages.filter((message) => message.customType === "pi-plans-plan-resume").length, 1);
+	});
+
+	it("planning request helper remains a no-op regardless of idleness", () => {
+		const workdir = freshWorkdir();
+		const { ctx, recorded, setUsagePercent } = makeHarness(workdir);
+		initState(workdir);
+		startRun(workdir, { topic: "idle no-op", skill: "plan-normal", requestText: "x" });
 		setUsagePercent(120);
-		assert.equal(shouldTriggerPlanningCompaction(ctx as any), true);
+
+		(ctx as any).isIdle = () => false;
+		requestPlanningCompaction(ctx as any);
+		(ctx as any).isIdle = () => true;
+		(ctx as any).hasPendingMessages = () => false;
+		requestPlanningCompaction(ctx as any);
+		assert.equal(recorded.compacts?.length ?? 0, 0);
+		assert.equal((ctx as any).sessionManager.__planningCompaction, undefined);
+	});
+
+	it("planning compact failures notify but do not re-request proactively", () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		initState(workdir);
+		startRun(workdir, { topic: "failure notify", skill: "plan-normal", requestText: "x" });
+		handlePlanningBeforeCompact(pi as any, ctx as any, {
+			type: "session_before_compact",
+			preparation: makePreparation("threshold", null),
+			branchEntries: compactableBranchEntries(),
+			customInstructions: "keep:1",
+			reason: "threshold",
+			willRetry: false,
+			signal: new AbortController().signal,
+		});
+
+		handlePlanningCompactFailed(pi as any, ctx as any, {
+			type: "session_compact_failed",
+			reason: "manual",
+			errorMessage: "Compaction failed: Nothing to compact (session too small)",
+			aborted: false,
+			willRetry: false,
+			fromExtension: false,
+		});
+		assert.ok(recorded.notifies.some((note) => note.message.includes("nothing to summarize")));
+		requestPlanningCompaction(ctx as any);
+		assert.equal(recorded.compacts?.length ?? 0, 0);
+
+		handlePlanningBeforeCompact(pi as any, ctx as any, {
+			type: "session_before_compact",
+			preparation: makePreparation("threshold", null),
+			branchEntries: compactableBranchEntries(),
+			customInstructions: "keep:1",
+			reason: "threshold",
+			willRetry: false,
+			signal: new AbortController().signal,
+		});
+		handlePlanningCompactFailed(pi as any, ctx as any, {
+			type: "session_compact_failed",
+			reason: "manual",
+			errorMessage: "network down",
+			aborted: false,
+			willRetry: false,
+			fromExtension: false,
+		});
+		assert.ok(recorded.notifies.some((note) => note.message.includes("will try again")));
+	});
+
+	it("execution turn compaction helper remains a no-op and failures keep execution active", async () => {
+		const workdir = freshWorkdir();
+		startActiveRun(workdir);
+		const { pi, ctx, recorded, setUsagePercent } = makeHarness(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v23.md"), items("VC-001"), [
+			{ id: "I-001", text: "First item." },
+		]);
+
+		setUsagePercent(96);
+		handleExecutionTurnCompaction(ctx);
+		assert.equal(recorded.compacts?.length ?? 0, 0, "execution scheduling is owned by Pi core");
+
+		handleExecutionBeforeCompact(pi, ctx, {
+			type: "session_before_compact",
+			preparation: makePreparation("threshold", null),
+			branchEntries: compactableBranchEntries(),
+			customInstructions: "keep:1",
+			reason: "threshold",
+			willRetry: false,
+			signal: new AbortController().signal,
+		});
+		handleExecutionCompactFailed(pi, ctx, {
+			type: "session_compact_failed",
+			reason: "manual",
+			errorMessage: "Compaction failed: Already compacted",
+			aborted: false,
+			willRetry: false,
+			fromExtension: false,
+		});
+		assert.ok(getExecution());
+		assert.ok(recorded.notifies.some((note) => note.message.includes("nothing to summarize")));
+
+		await stopExecution(pi, ctx, "test-done");
+	});
+
+	it("treats planning abort/stream compact failures as terminal and notifies explicitly", () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		initState(workdir);
+		startRun(workdir, { topic: "abort-stream classification", skill: "plan-normal", requestText: "x" });
+
+		const abortMessages = [
+			"Auto-compaction failed: Turn prefix summarization failed: This operation was aborted",
+			"Error: OpenAI Responses stream ended before a terminal response event",
+			"Auto-compaction failed: context overflow recovery failed",
+			"this operation was aborted",
+			"aborted",
+		];
+		for (const errorMessage of abortMessages) {
+			recorded.notifies.length = 0;
+			handlePlanningBeforeCompact(pi as any, ctx as any, {
+				type: "session_before_compact",
+				preparation: makePreparation("threshold", null),
+				branchEntries: compactableBranchEntries(),
+				customInstructions: "keep:1",
+				reason: "threshold",
+				willRetry: false,
+				signal: new AbortController().signal,
+			});
+			handlePlanningCompactFailed(pi as any, ctx as any, {
+				type: "session_compact_failed",
+				reason: "threshold",
+				errorMessage,
+				aborted: errorMessage.includes("aborted"),
+				willRetry: false,
+				fromExtension: false,
+			});
+			const backoffNote = recorded.notifies.find((n) => n.message.includes("was aborted"));
+			assert.ok(backoffNote, `expected abort-class notify for: ${errorMessage}`);
+			assert.match(backoffNote!.message, /provider interruption|competing manual/);
+			const before = recorded.compacts?.length ?? 0;
+			requestPlanningCompaction(ctx as any);
+			assert.equal((recorded.compacts?.length ?? 0) - before, 0);
+		}
+	});
+
+	it("event.aborted=true with empty errorMessage still enters abort-class handling", () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		initState(workdir);
+		startRun(workdir, { topic: "aborted-no-message", skill: "plan-normal", requestText: "x" });
+		handlePlanningBeforeCompact(pi as any, ctx as any, {
+			type: "session_before_compact",
+			preparation: makePreparation("threshold", null),
+			branchEntries: compactableBranchEntries(),
+			customInstructions: "keep:1",
+			reason: "threshold",
+			willRetry: false,
+			signal: new AbortController().signal,
+		});
+
+		handlePlanningCompactFailed(pi as any, ctx as any, {
+			type: "session_compact_failed",
+			reason: "threshold",
+			errorMessage: undefined,
+			aborted: true,
+			willRetry: false,
+			fromExtension: false,
+		});
+		const backoffNote = recorded.notifies.find((n) => n.message.includes("was aborted"));
+		assert.ok(backoffNote);
+		const before = recorded.compacts?.length ?? 0;
+		requestPlanningCompaction(ctx as any);
+		assert.equal((recorded.compacts?.length ?? 0) - before, 0);
+	});
+
+	it("network-style planning failures stay retryable without proactive requests", () => {
+		const workdir = freshWorkdir();
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		initState(workdir);
+		startRun(workdir, { topic: "network-retryable", skill: "plan-normal", requestText: "x" });
+		handlePlanningBeforeCompact(pi as any, ctx as any, {
+			type: "session_before_compact",
+			preparation: makePreparation("threshold", null),
+			branchEntries: compactableBranchEntries(),
+			customInstructions: "keep:1",
+			reason: "threshold",
+			willRetry: false,
+			signal: new AbortController().signal,
+		});
+
+		handlePlanningCompactFailed(pi as any, ctx as any, {
+			type: "session_compact_failed",
+			reason: "threshold",
+			errorMessage: "network down",
+			aborted: false,
+			willRetry: false,
+			fromExtension: false,
+		});
+		const abortNote = recorded.notifies.find((n) => n.message.includes("was aborted"));
+		assert.equal(abortNote, undefined, "network down must not be classified as abort-class");
+		const retryNote = recorded.notifies.find((n) => n.message.includes("will try again"));
+		assert.ok(retryNote, "network down must keep the retryable path");
+		const before = recorded.compacts?.length ?? 0;
+		requestPlanningCompaction(ctx as any);
+		assert.equal((recorded.compacts?.length ?? 0) - before, 0);
+	});
+
+	it("lifecycle flags distinguish unhinted and phase-attributed compactions", () => {
+		const workdir = freshWorkdir();
+		const { ctx } = makeHarness(workdir);
+
+		noteCompactionStarted(ctx as any, undefined);
+		assert.equal(compactionInFlight(ctx as any, "planning"), true, "unhinted compaction marks planning inFlight");
+		assert.equal(compactionInFlight(ctx as any, "execution"), true, "unhinted compaction marks execution inFlight");
+		noteCompactionEnded(ctx as any, undefined);
+		assert.equal(compactionInFlight(ctx as any, "planning"), false);
+		assert.equal(compactionInFlight(ctx as any, "execution"), false);
+
+		noteCompactionStarted(ctx as any, "pi-plans planning auto compact");
+		assert.equal(compactionInFlight(ctx as any, "planning"), true);
+		assert.equal(compactionInFlight(ctx as any, "execution"), false);
+		noteCompactionEnded(ctx as any, "pi-plans planning auto compact");
+		assert.equal(compactionInFlight(ctx as any, "planning"), false);
+
+		noteCompactionStarted(ctx as any, "pi-plans execution auto compact");
+		assert.equal(compactionInFlight(ctx as any, "planning"), false);
+		assert.equal(compactionInFlight(ctx as any, "execution"), true);
+		noteCompactionEnded(ctx as any, "pi-plans execution auto compact");
+		assert.equal(compactionInFlight(ctx as any, "execution"), false);
+	});
+
+	it("execution handler classifies abort/stream failures as terminal", async () => {
+		const workdir = freshWorkdir();
+		startActiveRun(workdir);
+		const { pi, ctx, recorded } = makeHarness(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v4.md"), items("VC-001"));
+
+		const abortMessages = [
+			"Auto-compaction failed: Turn prefix summarization failed: This operation was aborted",
+			"Error: OpenAI Responses stream ended before a terminal response event",
+			"Auto-compaction failed: context overflow recovery failed",
+			"aborted",
+		];
+		for (const errorMessage of abortMessages) {
+			recorded.notifies.length = 0;
+			handleExecutionBeforeCompact(pi, ctx, {
+				type: "session_before_compact",
+				preparation: makePreparation("threshold", null),
+				branchEntries: compactableBranchEntries(),
+				customInstructions: "keep:1",
+				reason: "threshold",
+				willRetry: false,
+				signal: new AbortController().signal,
+			});
+			handleExecutionCompactFailed(pi, ctx, {
+				type: "session_compact_failed",
+				reason: "threshold",
+				errorMessage,
+				aborted: errorMessage.includes("aborted"),
+				willRetry: false,
+				fromExtension: false,
+			});
+			const note = recorded.notifies.find((n) => n.message.includes("was aborted"));
+			assert.ok(note, `expected abort-class notify for: ${errorMessage}`);
+			assert.match(note!.message, /provider interruption|competing manual/);
+		}
+		handleExecutionBeforeCompact(pi, ctx, {
+			type: "session_before_compact",
+			preparation: makePreparation("threshold", null),
+			branchEntries: compactableBranchEntries(),
+			customInstructions: "keep:1",
+			reason: "threshold",
+			willRetry: false,
+			signal: new AbortController().signal,
+		});
+		handleExecutionCompactFailed(pi, ctx, {
+			type: "session_compact_failed",
+			reason: "threshold",
+			errorMessage: undefined,
+			aborted: true,
+			willRetry: false,
+			fromExtension: false,
+		});
+		const cleanNote = recorded.notifies.find((n) => n.message.includes("was aborted"));
+		assert.ok(cleanNote, "aborted-without-message must enter abort-class handling on execution side too");
+		await stopExecution(pi, ctx, "test-done");
+	});
+
+	it("index.ts wires session_compact/session_compact_failed to clear inFlight flags (F-003/F-004 coverage)", () => {
+		const indexSource = fs.readFileSync(path.join(process.cwd(), "index.ts"), "utf8");
+		assert.match(indexSource, /await handleExecutionCompact\(pi, ctx, event\)/);
+		assert.match(indexSource, /await handlePlanningCompact\(pi, ctx, event\)/);
+
+		const workdir = freshWorkdir();
+		// Use a minimal harness that exposes sessionManager so we can inspect the
+		// in-flight store after dispatching the registered event handlers.
+		const ctx: any = {
+			cwd: workdir,
+			hasUI: false,
+			sessionManager: {},
+		};
+		// Simulate the lifecycle that index.ts wires in production:
+		noteCompactionStarted(ctx, undefined);
+		assert.equal(compactionInFlight(ctx, "planning"), true);
+		assert.equal(compactionInFlight(ctx, "execution"), true);
+		noteCompactionEnded(ctx, undefined);
+		assert.equal(compactionInFlight(ctx, "planning"), false);
+		assert.equal(compactionInFlight(ctx, "execution"), false);
+		// And a planning-attributed start + end still clears both (end has no hint).
+		noteCompactionStarted(ctx, "pi-plans planning auto compact");
+		assert.equal(compactionInFlight(ctx, "planning"), true);
+		noteCompactionEnded(ctx, "pi-plans planning auto compact");
+		assert.equal(compactionInFlight(ctx, "planning"), false);
+	});
+});
+
+describe("execution injection reads graph config live", () => {
+	it("reflects graph_enabled flips on the next assembly and surfaces config failures", async (t) => {
+		const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-exec-graph-"));
+		t.after(() => {
+			try {
+				fs.rmSync(workdir, { recursive: true, force: true });
+			} catch {
+				/* ignore */
+			}
+		});
+		const { pi, ctx } = makeHarness(workdir);
+		setGraphEnabled(workdir, true);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v1.md"), items("VC-001"));
+
+		const enabledRules = executionContextMessage(ctx)!;
+		assert.match(enabledRules, /Code graph loop: indexed code files read as a function digest/);
+		assert.doesNotMatch(enabledRules, /Code graph disabled/);
+
+		setGraphEnabled(workdir, false);
+		assert.match(executionContextMessage(ctx)!, /Code graph disabled/);
+
+		fs.writeFileSync(path.join(workdir, ".git", "pi_plans", "config.json"), "{broken");
+		const brokenRules = executionContextMessage(ctx)!;
+		assert.match(brokenRules, /Code graph disabled/);
+		assert.match(brokenRules, /config unreadable this turn/);
+	});
+
+	it("keeps no graphEnabled snapshot in the execution state source", () => {
+		const source = fs.readFileSync(path.join(process.cwd(), "src", "exec.ts"), "utf8");
+		assert.doesNotMatch(source, /graphEnabled/);
+		assert.match(source, /resolveGraphMode/);
 	});
 });
 
-function makePreparation(reason: "manual" | "threshold" | "overflow", previousSummary: string | null): any {
-	return {
+function makePreparation(reason: "manual" | "threshold" | "overflow", previousSummary: string | null): any {	return {
 		firstKeptEntryId: "a-2",
 		messagesToSummarize: [],
 		turnPrefixMessages: [],