pi-plans 0.2.0 → 0.3.1

package/tests/exec.test.ts

@@ -6,6 +6,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { after, before, describe, it } from "node:test";
 import {
+	AMELIORATION_PROMPT_TEXT,
 	applyDoneMarkers,
 	applyImplMarkers,
 	applyCurrentIMarker,
@@ -19,10 +20,14 @@ import {
 	filterExecutionResumeMessages,
 	filterPlanningResumeMessages,
 	getExecution,
+	resumeGoalWaitIfPaused,
 	handleExecutionBeforeCompact,
 	handleExecutionCompact,
 	handleExecutionTurnCompaction,
 	handleExecutionCompactFailed,
+	compactionInFlight,
+	noteCompactionStarted,
+	noteCompactionEnded,
 	handlePlanningBeforeCompact,
 	handlePlanningCompact,
 	handlePlanningCompactFailed,
@@ -32,6 +37,7 @@ import {
 	refreshPlanningCompactionCooldown,
 	requestPlanningCompaction,
 	restoreFromSession,
+	resetGoalWaitTurnFlags,
 	shouldTriggerPlanningCompaction,
 	startExecution,
 	recordExecutionTurn,
@@ -40,7 +46,7 @@ import {
 	updateStatusWidget,
 } from "../src/exec.ts";
 import type { CheckItem } from "../src/plan.ts";
-import { initState, setRunStatus, startRun } from "../src/state.ts";
+import { initState, setGraphEnabled, setRunStatus, startRun } from "../src/state.ts";
 
 interface Recorded {
 	entries: { type: string; customType?: string; data?: unknown }[];
@@ -55,6 +61,8 @@ interface Recorded {
 	selectAnswer?: string;
 	current: { provider: string; id: string } | null;
 	thinking: string | null;
+	userMessages: string[];
+	userMessageOptions: Array<Record<string, unknown> | null>;
 	compacts?: { customInstructions?: string }[];
 }
 
@@ -78,6 +86,8 @@ function makeHarness(workdir: string): Harness {
 		selects: [],
 		current: { provider: "p", id: "m" },
 		thinking: "high",
+		userMessages: [],
+		userMessageOptions: [],
 	};
 	let contextPercent: number | null = 0;
 	const registryModels = [
@@ -108,7 +118,10 @@ 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, options?: Record<string, unknown>) => {
+			recorded.userMessages.push(content);
+			recorded.userMessageOptions.push(options ?? null);
+		},
 		setModel: async (model: { provider: string; id: string }) => {
 			recorded.models.push({ provider: model.provider, id: model.id });
 			recorded.current = { provider: model.provider, id: model.id };
@@ -177,6 +190,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;
@@ -206,7 +235,7 @@ describe("execution loop", () => {
 		assert.match(recorded.status ?? "", /out-toks/);
 
 		assert.ok(getExecution());
-		const rules = executionContextMessage()!;
+		const rules = executionContextMessage(ctx)!;
 		assert.match(rules, /PI-PLANS EXECUTION/);
 		assert.match(rules, /VC-001/);
 		assert.match(rules, /subprocess-backed verification/);
@@ -234,6 +263,87 @@ describe("execution loop", () => {
 		assert.ok(recorded.messages.some((message) => message.customType === "pi-plans-complete"));
 	});
 
+	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, /How should the implementation-review loop terminate\?/);
+		assert.match(completeMessage.content, /goal wait: continue until no unpassed VCs remain/);
+		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,
+			items: items("VC-001", "VC-002"),
+			startedAt: "2026-08-25T00:00:00Z",
+			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);
@@ -392,36 +502,51 @@ describe("execution loop", () => {
 		assert.equal(getExecution(), null);
 	});
 
-	it("lets Pi core own execution compaction scheduling and customizes every reason", async () => {
+	it("returns control to Pi core without active execution or planning state", 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"));
+		const { pi, ctx } = makeHarness(workdir);
 
-		setUsagePercent(50);
-		const below = handleExecutionBeforeCompact(pi, ctx, {
+		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: [],
+			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(executionResult, undefined);
+		await stopExecution(pi, ctx, "no-active-run");
 
-		setUsagePercent(105);
-		const above = 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(planningResult, undefined);
+	});
+
+	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: 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: [],
@@ -429,8 +554,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",
@@ -440,54 +564,29 @@ 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("triggers execution compaction at the high watermark, suppresses repeats, and re-arms below the low watermark", async () => {
+	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(96);
+		setUsagePercent(99);
 		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");
+		assert.equal(recorded.compacts?.length ?? 0, 0, "execution scheduling is owned by Pi core");
 
 		await stopExecution(pi, ctx, "test-done");
 	});
 
-	it("skips proactive current-I compaction when no eligible prefix exists", async () => {
+	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." },
@@ -499,52 +598,82 @@ describe("execution loop", () => {
 		assert.equal(recorded.compacts?.length ?? 0, 0);
 		await stopExecution(pi, ctx, "no-prefix");
 	});
-	it("wires execution compaction without restoring execution model helpers", () => {
+	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");
 		assert.match(indexSource, /handleExecutionTurnCompaction/);
 		assert.match(execSource, /shouldTriggerExecutionCompaction/);
-		assert.match(execSource, /requestExecutionCompaction/);
+		assert.doesNotMatch(execSource, /ctx\.compact\(/);
 		assert.doesNotMatch(
 			indexSource,
 			/setExecutionModel|chooseExecutionModelSelection|snapshotCurrentModelSelector|ensureExecutionModelActive|restorePlanningModel/,
 		);
 		assert.doesNotMatch(
 			execSource,
-			/setExecutionModel|chooseExecutionModelSelection|snapshotCurrentModelSelector|ensureExecutionModelActive|restorePlanningModel/,
+			/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",
@@ -560,29 +689,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,
@@ -590,71 +720,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, {
-			type: "session_before_compact",
-			preparation,
-			branchEntries,
-			reason: "threshold",
-			willRetry: false,
-			signal: new AbortController().signal,
-		});
+		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("uses the current model for bounded valid summaries and falls back on invalid output", async () => {
+	it("does not call model helpers and respects overrideDefaultCompaction=false", async () => {
 		const workdir = freshWorkdir();
-		const { pi, ctx, recorded } = makeHarness(workdir);
+		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." },
 		]);
-		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;
+		let completeCalled = false;
+		(ctx.modelRegistry as any).complete = async () => {
+			completeCalled = true;
+			return {};
 		};
 		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" }] } },
-			],
+			branchEntries: compactableBranchEntries(),
 			reason: "threshold",
 			willRetry: false,
-			signal,
+			signal: new AbortController().signal,
 		};
-		const valid = await handleExecutionBeforeCompact(pi, ctx, event);
+		const valid = 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");
+		assert.equal(completeCalled, false);
+
+		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");
+
 		await stopExecution(pi, ctx, "model-test");
-	});	it("filters the hidden resume message out of the LLM context payload", () => {
+	});
+	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." },
@@ -665,37 +775,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 planPath = path.join(run.artifact_dir, "PLAN_v1.md");
+		fs.writeFileSync(planPath, "# 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 },
-		});
-
-		// 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,
@@ -704,95 +804,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 () => {
@@ -970,7 +1032,7 @@ describe("execution loop", () => {
 		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/);
@@ -981,42 +1043,411 @@ describe("execution loop", () => {
 		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);
 	});
 });
 
-function makePreparation(reason: "manual" | "threshold" | "overflow", previousSummary: string | null): any {
-	return {
+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 {
 		firstKeptEntryId: "a-2",
 		messagesToSummarize: [],
 		turnPrefixMessages: [],
@@ -1027,3 +1458,139 @@ function makePreparation(reason: "manual" | "threshold" | "overflow", previousSu
 		settings: { enabled: true, reserveTokens: 16384, keepRecentTokens: 20000 },
 	};
 }
+
+describe("execution goal-wait continuation", () => {
+	// Fresh per-turn continuation flags, mirroring the before_agent_start reset.
+	const setup = (workdir: string) => {
+		resetGoalWaitTurnFlags();
+		const harness = makeHarness(workdir);
+		registerExecutionTurnHandlers(harness.pi);
+		return harness;
+	};
+
+	it("sends a goal-wait followUp when a turn ends with unpassed VCs", async () => {
+		const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-goal-wait-"));
+		const { pi, ctx, recorded, emit } = setup(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v1.md"), items("VC-001"));
+		recorded.userMessages.length = 0;
+		await emit("turn_end", { message: { role: "assistant", content: [{ type: "text", text: "still working" }] } });
+		assert.equal(recorded.userMessages.length, 1);
+		assert.match(recorded.userMessages[0], /Goal wait: 1\/1 verifier items still open/);
+		assert.match(recorded.userMessages[0], /\`VC-001\`/);
+		assert.equal(recorded.userMessageOptions.at(-1)?.deliverAs, "followUp");
+		assert.match(recorded.status ?? "", /goal-wait · 无进展 1\/3 · 等待 0\/6/);
+	});
+
+	it("sends the goal-wait followUp in headless sessions too", async () => {
+		const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-goal-wait-"));
+		const { pi, ctx, recorded, emit } = setup(workdir);
+		(ctx as any).hasUI = false;
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v1.md"), items("VC-001"));
+		recorded.userMessages.length = 0;
+		await emit("turn_end", { message: { role: "assistant", content: [{ type: "text", text: "still working" }] } });
+		assert.equal(recorded.userMessages.length, 1);
+		assert.match(recorded.userMessages[0], /Goal wait: 1\/1 verifier items still open/);
+	});
+
+	it("does not goal-wait when every VC is done (completion path)", async () => {
+		const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-goal-wait-"));
+		const { pi, ctx, recorded, emit } = setup(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v1.md"), items("VC-001"));
+		recorded.userMessages.length = 0;
+		await emit("turn_end", { message: { role: "assistant", content: [{ type: "text", text: "done [DONE:VC-001]" }] } });
+		assert.equal(recorded.userMessages.length, 0);
+		assert.ok(recorded.messages.some((message) => message.customType === "pi-plans-complete"));
+	});
+
+	it("skips goal-wait while any compaction continuation flag is active", async () => {
+		const variants = [
+			{ inFlight: true, resumeGuard: false, pendingFollowUpPrompt: null },
+			{ inFlight: false, resumeGuard: true, pendingFollowUpPrompt: null },
+			{ inFlight: false, resumeGuard: false, pendingFollowUpPrompt: "compaction follow-up" },
+		];
+		for (const flags of variants) {
+			const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-goal-wait-"));
+			const { pi, ctx, recorded, emit } = setup(workdir);
+			await startExecution(pi, ctx, path.join(workdir, "PLAN_v1.md"), items("VC-001"));
+			(ctx.sessionManager as any).__executionCompaction = { ...flags, cooldownActive: false };
+			recorded.userMessages.length = 0;
+			await emit("turn_end", { message: { role: "assistant", content: [{ type: "text", text: "working" }] } });
+			assert.equal(recorded.userMessages.length, 0, `flags ${JSON.stringify(flags)} must skip goal-wait`);
+		}
+	});
+
+	it("pauses after 3 no-progress rounds and resumes on kick", async () => {
+		const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-goal-wait-"));
+		const { pi, ctx, recorded, emit } = setup(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v1.md"), items("VC-001"));
+		recorded.userMessages.length = 0;
+		for (let round = 0; round < 3; round++) {
+			await emit("turn_end", { message: { role: "assistant", content: [{ type: "text", text: "still working" }] } });
+		}
+		assert.equal(getExecution()?.goalWait?.paused, true);
+		assert.equal(recorded.userMessages.length, 2, "third quiet round must not queue another followUp");
+		assert.ok(recorded.notifies.some((entry) => /goal-wait paused/.test(entry.message)));
+		assert.match(recorded.status ?? "", /⏸ goal-wait paused/);
+
+		resumeGoalWaitIfPaused(pi, ctx);
+		assert.equal(getExecution()?.goalWait?.paused, false);
+		await emit("turn_end", { message: { role: "assistant", content: [{ type: "text", text: "progress [DONE:VC-001]" }] } });
+		assert.match(recorded.userMessages.at(-1) ?? "", /Goal wait/);
+	});
+
+	it("waiting rounds are exempt until the sixth quiet waiting round", async () => {
+		const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-goal-wait-"));
+		const { pi, ctx, recorded, emit } = setup(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v1.md"), items("VC-001"));
+		for (let round = 1; round <= 5; round++) {
+			await emit("turn_end", { message: { role: "assistant", content: [{ type: "text", text: `waiting for CI (${round})` }] } });
+			assert.equal(getExecution()?.goalWait?.paused, false, `round ${round} must not pause`);
+		}
+		await emit("turn_end", { message: { role: "assistant", content: [{ type: "text", text: "waiting for CI (6)" }] } });
+		assert.equal(getExecution()?.goalWait?.paused, true);
+		assert.ok(recorded.notifies.some((entry) => /waiting without progress for 6 rounds/.test(entry.message)));
+	});
+
+	it("progress resets both guard counters", async () => {
+		const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-goal-wait-"));
+		const { pi, ctx, emit } = makeHarness(workdir);
+		await startExecution(pi, ctx, path.join(workdir, "PLAN_v1.md"), items("VC-001", "VC-002"));
+		await emit("turn_end", { message: { role: "assistant", content: [{ type: "text", text: "working" }] } });
+		await emit("turn_end", { message: { role: "assistant", content: [{ type: "text", text: "working" }] } });
+		await emit("turn_end", { message: { role: "assistant", content: [{ type: "text", text: "progress [DONE:VC-001]" }] } });
+		assert.equal(getExecution()?.goalWait?.noProgressRounds, 0);
+		assert.equal(getExecution()?.goalWait?.waitRounds, 0);
+	});
+
+	it("keeps goal-wait counters across restore", async () => {
+		const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-plans-goal-wait-"));
+		const { pi, ctx } = setup(workdir);
+		const planPath = path.join(workdir, "PLAN_v1.md");
+		fs.writeFileSync(planPath, "# plan");
+		const snapshot = {
+			planPath,
+			items: items("VC-001"),
+			startedAt: "2026-08-25T00:00:00Z",
+			usage: { inToks: 0, outToks: 0 },
+			implItems: [],
+			implStatus: {},
+			goalWait: { noProgressRounds: 2, waitRounds: 1, lastMarkers: null, paused: false },
+		};
+		const entries = [
+			{ type: "custom", customType: "pi-plans-exec", data: snapshot },
+			{ type: "message", message: { role: "assistant", content: [{ type: "text", text: "no new progress this turn" }] } },
+		];
+		await restoreFromSession(pi, ctx, entries as any);
+		// Replay advanced the marker snapshot past the persisted baseline → counters reset (D-010).
+		assert.equal(getExecution()?.goalWait?.noProgressRounds, 0);
+		assert.equal(getExecution()?.goalWait?.waitRounds, 0);
+	});
+});
+
+describe("amelioration termination prompt", () => {
+	it("recommends goal-wait first and keeps the round options", () => {
+		assert.match(AMELIORATION_PROMPT_TEXT, /goal wait: continue until no unpassed VCs remain/);
+		assert.match(AMELIORATION_PROMPT_TEXT, /until no high-severity finding \(hard cap 5 rounds\)/);
+		assert.match(AMELIORATION_PROMPT_TEXT, /How should the implementation-review loop terminate\?/);
+	});
+});