pi-plans 0.1.2 → 0.3.0

package/src/exec.ts

@@ -3,8 +3,8 @@
  *
  * When the user approves the execution handoff, the extension switches into
  * execution mode: every agent turn is injected with the remaining verifier
- * checklist, assistant messages are scanned for [DONE:VC-xxx] markers, and the
- * below-editor panel tracks progress until every item passes.
+ * checklist, assistant messages are scanned for [DONE:VC-xxx] markers, and
+ * progress is reported through the bottom status bar until every item passes.
  */
 
 import * as fs from "node:fs";
@@ -17,56 +17,53 @@ import type {
 	SessionCompactEvent,
 	SessionCompactFailedEvent,
 } from "@earendil-works/pi-coding-agent";
+import { VERSION } from "@earendil-works/pi-coding-agent";
 import {
-	attachPanelBaseline,
-	clearExecutionPanel,
-	completeCompletedItems,
-	computeExecutionProgress,
-	createExecutionPanelState,
-	executionPanelFromEntryData,
-	formatExecutionStatusLine,
-	refreshExecutionPanel,
-	snapshotPanelState,
-	toggleExpanded,
-	type ExecutionPanelExecutionLike,
-	type ExecutionPanelState,
-	type ItemDiffSummary,
-} from "./execution-panel.ts";
-import { getRun, readActive, setRunStatus, utcNow, type ExecutionConfig } from "./state.ts";
+	buildPiPlansVccCompaction,
+	compactionCurrentI,
+	entryCurrentIMarkers,
+	formatVccCompactionStats,
+	loadVccSettings,
+	scaffoldVccSettings,
+	shouldScheduleAutoContinue,
+	type CompactionEntryLike,
+	type PiPlansCompactionPhase,
+	type PiPlansVccPhaseContext,
+	type PiPlansVccSettings,
+	type VccCompactionBuildResult,
+	type VccCompactionStats,
+} from "./compaction.ts";
+import { getRun, readActive, resolveStateRootOrNull, setRunStatus, utcNow } from "./state.ts";
+import { graphBlockForExecutor } from "./code-graph/prompts.ts";
+import { resolveGraphMode } from "./code-graph/mode.ts";
 import {
+	extractCoverage,
 	latestPlanVersion,
+	resolveImplStatuses,
 	scanDoneMarkers,
 	scanImplMarkers,
+	scanCurrentIMarkers,
+	resolveCurrentI,
+	inferCurrentI,
 	type CheckItem,
 	type ImplItem,
 	type ImplMarkerState,
 } from "./plan.ts";
 
-export interface ExecState extends ExecutionPanelExecutionLike {
+export interface ExecState {
+	planPath: string;
+	items: CheckItem[];
 	startedAt: string;
-	panel?: ExecutionPanelState;
 	usage: { inToks: number; outToks: number };
-	modelState?: ExecutionModelState;
 	implItems?: ImplItem[];
 	implStatus?: Record<string, ImplMarkerState>;
+	currentI?: string;
 }
 
 let execution: ExecState | null = null;
 
-// Set when the user toggles the panel while a turn is streaming; consumed by
-// index.ts on turn_end so view state converges without touching the live run.
-let pendingPanelSync = false;
-
-export function consumePendingPanelSync(): boolean {
-	const pending = pendingPanelSync;
-	pendingPanelSync = false;
-	return pending;
-}
-
-// Execution-loop UI churn deferral: mid-agent appendEntry forces a TUI
-// relayout (see toggleExecutionPanelView), so while the agent runs we only
-// arm a pending flag and flush once at a settle boundary (agent_settled,
-// next before_agent_start, stop/complete).
+// Execution-loop persistence is deferred until the agent settles so turn_end
+// never causes session writes during a streaming run.
 let pendingExecutionFlush = false;
 
 export function consumePendingExecutionFlush(): boolean {
@@ -75,25 +72,17 @@ export function consumePendingExecutionFlush(): boolean {
 	return pending;
 }
 
-function requestExecutionFlush(pi: ExtensionAPI, ctx: ExtensionContext): void {
+function requestExecutionFlush(_pi: ExtensionAPI, _ctx: ExtensionContext): void {
 	// Unconditional defer. turn_end fires mid-run in a gap between agent
-	// operations where isIdle() reads true — a busy/idle gate never defers
-	// there (the 60-writes-in-23-minutes flashing regression). Persistence
-	// happens only at the drain points: agent_settled, the next
-	// before_agent_start, and stop/complete.
+	// operations where isIdle() reads true; persistence happens only at the
+	// drain points: agent_settled, the next before_agent_start, and stop/complete.
 	pendingExecutionFlush = true;
-	// Keep both execution views current without persisting or re-registering the
-	// panel widget. Collapsed refresh is idempotent; expanded refresh invalidates
-	// the live widget's render cache.
-	syncExecutionPanel(ctx);
 }
 
 export function drainExecutionFlush(pi: ExtensionAPI, ctx: ExtensionContext): void {
-	if (!execution) return;
-	if (!pendingExecutionFlush && !consumePendingPanelSync()) return;
+	if (!execution || !pendingExecutionFlush) return;
 	pendingExecutionFlush = false;
 	persist(pi);
-	syncExecutionPanel(ctx);
 	updateStatusWidget(ctx);
 }
 
@@ -101,187 +90,119 @@ export function getExecution(): ExecState | null {
 	return execution;
 }
 
-const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
-const CURRENT_SESSION_MODEL_CHOICE = "Inherit current session model";
+const EXECUTION_COMPACTION_RESUME_MESSAGE = "Continue execution.";
 
-export interface ExecutionModelState {
-	planningSelector: string | null;
-	executionSelector: string;
+interface ExecutionCompactionState {
+	inFlight: boolean;
+	resumeGuard: boolean;
+	cooldownActive: boolean;
+	lastAttemptReason: string | null;
+	lastSuccessfulUsagePercent: number | null;
+	lastSuccessfulAt: string | null;
+	rearmPending: boolean;
+	/** Terminal failure metadata is retained for diagnostics, not proactive retry. */
+	terminalBackoffTokens: number | null;
+	pendingStats: VccCompactionStats | null;
+	pendingFollowUpPrompt: string | null;
+	pendingContinueAfterThresholdCompact: boolean;
 }
 
-export interface ModelSelection {
-	provider: string;
-	modelId: string;
-	thinkingLevel: string | null;
-	selector: string;
-	model: any;
+type ExecutionCompactionSession = { __executionCompaction?: ExecutionCompactionState };
+type ExecutionCompactionContext = ExtensionContext & { sessionManager?: ExecutionCompactionSession };
+
+function getExecutionCompactionSession(ctx: ExtensionContext, create = false): ExecutionCompactionSession | undefined {
+	const carrier = ctx as ExecutionCompactionContext;
+	if (carrier.sessionManager) return carrier.sessionManager;
+	if (!create) return undefined;
+	carrier.sessionManager = {};
+	return carrier.sessionManager;
 }
 
-function buildModelSelector(provider: string, modelId: string, thinkingLevel?: string | null): string {
-	return thinkingLevel ? `${provider}/${modelId}:${thinkingLevel}` : `${provider}/${modelId}`;
+function executionCompactionState(ctx: ExtensionContext): ExecutionCompactionState | undefined {
+	return getExecutionCompactionSession(ctx)?.__executionCompaction;
 }
 
-export function currentModelSelection(ctx: Pick<ExtensionContext, "model" | "thinkingLevel">): ModelSelection | null {
-	if (!ctx.model) return null;
-	return {
-		provider: ctx.model.provider,
-		modelId: ctx.model.id,
-		thinkingLevel: ctx.thinkingLevel ?? null,
-		selector: buildModelSelector(ctx.model.provider, ctx.model.id, ctx.thinkingLevel ?? null),
-		model: ctx.model,
-	};
+function ensureExecutionCompactionState(ctx: ExtensionContext): ExecutionCompactionState {
+	const session = getExecutionCompactionSession(ctx, true)!;
+	return (session.__executionCompaction ??= {
+		inFlight: false,
+		resumeGuard: false,
+		cooldownActive: false,
+		lastAttemptReason: null,
+		lastSuccessfulUsagePercent: null,
+		lastSuccessfulAt: null,
+		rearmPending: false,
+		terminalBackoffTokens: null,
+		pendingStats: null,
+		pendingFollowUpPrompt: null,
+		pendingContinueAfterThresholdCompact: false,
+	});
 }
 
-export function snapshotCurrentModelSelector(ctx: Pick<ExtensionContext, "model" | "thinkingLevel">): string | null {
-	return currentModelSelection(ctx)?.selector ?? null;
+function resetExecutionCompactionState(ctx: ExtensionContext): void {
+	const session = getExecutionCompactionSession(ctx);
+	if (!session) return;
+	delete session.__executionCompaction;
 }
 
-export function resolveModelSelection(ctx: ExtensionContext, selector: string): ModelSelection | null {
-	const slash = selector.indexOf("/");
-	if (slash <= 0 || slash === selector.length - 1) return null;
-	const provider = selector.slice(0, slash);
-	const rawModelId = selector.slice(slash + 1);
-	const exact = ctx.modelRegistry.find(provider, rawModelId);
-	if (exact) {
-		return { provider, modelId: rawModelId, thinkingLevel: null, selector, model: exact };
-	}
-	const colon = rawModelId.lastIndexOf(":");
-	if (colon > 0) {
-		const modelId = rawModelId.slice(0, colon);
-		const thinkingLevel = rawModelId.slice(colon + 1);
-		if (THINKING_LEVELS.has(thinkingLevel)) {
-			const model = ctx.modelRegistry.find(provider, modelId);
-			if (model) {
-				return { provider, modelId, thinkingLevel, selector, model };
-			}
-		}
-	}
-	return null;
+function consumeExecutionCompactionResumeGuard(ctx: ExtensionContext): boolean {
+	const state = executionCompactionState(ctx);
+	if (!state?.resumeGuard) return false;
+	state.resumeGuard = false;
+	return true;
 }
 
-function listAvailableModelSelections(ctx: ExtensionContext): ModelSelection[] {
-	const rawSelections = ctx.scopedModels.length > 0
-		? ctx.scopedModels.map((entry) => ({
-			provider: entry.model.provider,
-			modelId: entry.model.id,
-			thinkingLevel: entry.thinkingLevel ?? null,
-			selector: buildModelSelector(entry.model.provider, entry.model.id, entry.thinkingLevel ?? null),
-			model: entry.model,
-		}))
-		: ctx.modelRegistry.getAvailable().map((model) => ({
-			provider: model.provider,
-			modelId: model.id,
-			thinkingLevel: null,
-			selector: buildModelSelector(model.provider, model.id),
-			model,
-		}));
-	const seen = new Set<string>();
-	const unique: ModelSelection[] = [];
-	for (const selection of rawSelections) {
-		if (seen.has(selection.selector)) continue;
-		seen.add(selection.selector);
-		unique.push(selection);
-	}
-	return unique;
+export function shouldTriggerExecutionCompaction(_ctx: ExtensionContext): boolean {
+	return false;
 }
 
-export async function applyModelSelection(pi: ExtensionAPI, ctx: ExtensionContext, selection: ModelSelection): Promise<boolean> {
-	if (ctx.model && ctx.model.provider === selection.provider && ctx.model.id === selection.modelId) {
-		if (selection.thinkingLevel !== null && ctx.thinkingLevel !== selection.thinkingLevel) {
-			pi.setThinkingLevel(selection.thinkingLevel as never);
-		}
-		return true;
-	}
-	const success = await pi.setModel(selection.model);
-	if (!success) return false;
-	if (selection.thinkingLevel !== null) {
-		pi.setThinkingLevel(selection.thinkingLevel as never);
-	}
-	return true;
+export function handleExecutionTurnCompaction(ctx: ExtensionContext): void {
+	consumeExecutionCompactionResumeGuard(ctx);
 }
 
-export async function chooseExecutionModelSelection(
-	ctx: ExtensionContext,
-	prompt: string,
-	configured: Pick<ExecutionConfig, "model_selector" | "source"> | null | undefined,
-	onChosenSelector?: (selector: string) => Promise<void> | void,
-): Promise<ModelSelection | null> {
-	const current = currentModelSelection(ctx);
-	const available = listAvailableModelSelections(ctx);
-	const configuredSelector = configured?.model_selector ?? null;
-	const configuredSource = configured?.source ?? "unset";
-
-	if (configuredSource === "unset") {
-		const choices = current
-			? [
-				CURRENT_SESSION_MODEL_CHOICE,
-				...available
-					.filter((selection) => selection.selector !== current.selector)
-					.map((selection) => selection.selector),
-			]
-			: available.map((selection) => selection.selector);
-		if (!ctx.hasUI || choices.length === 0) {
-			ctx.ui.notify(`${prompt}: execution model is not set; continuing with the current session model.`, "warning");
-			return current;
-		}
-		const choice = await ctx.ui.select(
-			`${prompt} — execution model is not set. ${current ? "Inherit the current session model or choose another model:" : "Choose a model:"}`,
-			choices,
+export function computeExecutionProgress(execution: ExecState): { done: number; total: number } {
+	const implItems = execution.implItems ?? [];
+	if (implItems.length) {
+		const statuses = resolveImplStatuses(implItems, execution.items, execution.implStatus);
+		const counted = implItems.filter((impl) =>
+			execution.items.some((item) => extractCoverage(item.text).includes(impl.id)),
 		);
-		if (!choice) return current;
-		if (choice === CURRENT_SESSION_MODEL_CHOICE) {
-			if (onChosenSelector) {
-				await onChosenSelector("inherit");
-			}
-			return current;
-		}
-		if (onChosenSelector) {
-			await onChosenSelector(choice);
-		}
-		return resolveModelSelection(ctx, choice) ?? current;
+		const total = counted.length > 0 ? counted.length : implItems.length;
+		const vcDone = counted.filter((impl) => statuses[impl.id] === "vc-passed").length;
+		const currentIndex = execution.currentI
+			? implItems.findIndex((impl) => impl.id === execution.currentI)
+			: -1;
+		return {
+			done: Math.min(total, Math.max(vcDone, currentIndex < 0 ? 0 : currentIndex)),
+			total,
+		};
 	}
+	return {
+		done: execution.items.filter((item) => item.done).length,
+		total: execution.items.length,
+	};
+}
 
-	if (configuredSelector) {
-		const resolved = resolveModelSelection(ctx, configuredSelector);
-		if (resolved) return resolved;
-	} else {
-		return current;
-	}
+function formatElapsed(startedAt: string): string {
+	const total = Math.max(0, Math.floor((Date.now() - Date.parse(startedAt)) / 1000));
+	const h = String(Math.floor(total / 3600)).padStart(2, "0");
+	const m = String(Math.floor((total % 3600) / 60)).padStart(2, "0");
+	const sec = String(total % 60).padStart(2, "0");
+	return `${h}:${m}:${sec}`;
+}
 
-	if (!ctx.hasUI || available.length === 0) {
-		ctx.ui.notify(`${prompt}: configured execution model "${configuredSelector}" is unavailable; continuing with the current session model.`, "warning");
-		return current;
-	}
-	const choice = await ctx.ui.select(
-		`${prompt} — "${configuredSelector}" is unavailable. Pick a model:`,
-		[
-			CURRENT_SESSION_MODEL_CHOICE,
-			...available
-				.filter((selection) => selection.selector !== current?.selector)
-				.map((selection) => selection.selector),
-		],
-	);
-	if (!choice || choice === CURRENT_SESSION_MODEL_CHOICE) {
-		return current;
-	}
-	if (onChosenSelector) {
-		await onChosenSelector(choice);
-	}
-	return resolveModelSelection(ctx, choice) ?? current;
+function formatToks(tokens: number): string {
+	const n = Math.max(0, Math.round(tokens));
+	return n < 1000 ? String(n) : `${(n / 1000).toFixed(1)}k`;
 }
 
-export function executionProgress(): { done: number; total: number } | null {
-	if (!execution) return null;
-	return computeExecutionProgress(execution);
+export function formatExecutionStatusLine(execution: ExecState): string {
+	const progress = computeExecutionProgress(execution);
+	return `⌛ plans ${progress.done}/${progress.total}: spent ${formatElapsed(execution.startedAt)} · ${formatToks(execution.usage.inToks)} in-toks · ${formatToks(execution.usage.outToks)} out-toks`;
 }
 
 export function updateStatusWidget(ctx: ExtensionContext): void {
 	if (execution) {
-		if (execution.panel?.expanded) {
-			// The expanded panel renders the ⌛ header itself; the footer copy is
-			// cleared by refreshExecutionPanel. Write nothing here.
-			return;
-		}
 		const line = formatExecutionStatusLine(execution);
 		ctx.ui.setStatus("pi-plans", ctx.ui.theme.fg("accent", line));
 		return;
@@ -326,35 +247,23 @@ function persist(pi: ExtensionAPI): void {
 		items: execution.items,
 		startedAt: execution.startedAt,
 		usage: execution.usage,
-		panel: snapshotPanelState(execution),
 		implItems: execution.implItems,
+		implStatus: execution.implStatus,
+		currentI: execution.currentI,
 	});
 }
 
-export function syncExecutionPanel(ctx: ExtensionContext): void {
-	if (!execution) {
-		clearExecutionPanel(ctx);
-		return;
-	}
-	refreshExecutionPanel(ctx, execution);
-}
-
 export async function startExecution(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
 	planPath: string,
 	items: CheckItem[],
-	modelState?: ExecutionModelState,
 	implItems?: ImplItem[],
 ): Promise<void> {
-	execution = { planPath, items, startedAt: utcNow(), panel: createExecutionPanelState(), usage: { inToks: 0, outToks: 0 }, modelState, implItems: implItems ?? [], implStatus: {} };
-	attachPanelBaseline(execution, ctx.cwd);
-	consumePendingPanelSync(); // fresh run: drop any stale deferral from a previous one
+	execution = { planPath, items, startedAt: utcNow(), usage: { inToks: 0, outToks: 0 }, implItems: implItems ?? [], implStatus: {} };
 	pendingExecutionFlush = false; // fresh run: no inherited flush debt
+	resetExecutionCompactionState(ctx);
 	persist(pi);
-	if (modelState) {
-		await ensureExecutionModelActive(pi, ctx);
-	}
 	const active = readActive(ctx.cwd);
 	if (active) {
 		try {
@@ -372,54 +281,22 @@ export async function startExecution(
 		{ triggerTurn: false },
 	);
 	updateStatusWidget(ctx);
-	syncExecutionPanel(ctx);
-}
-
-export function toggleExecutionPanelView(pi: ExtensionAPI, ctx: ExtensionContext): boolean | null {
-	if (!execution) return null;
-	const expanded = toggleExpanded(execution);
-	// While a turn is streaming keep this zero-side-effect: flipping the flag is
-	// pure memory; persisting and re-rendering here would write to the session
-	// file and force a TUI relayout under the running agent. The next turn_end
-	// consumes the pending marker and brings the view in line.
-	const idle = typeof ctx.isIdle !== "function" || ctx.isIdle();
-	if (idle) {
-		persist(pi);
-		syncExecutionPanel(ctx);
-	} else {
-		pendingPanelSync = true;
-	}
-	return expanded;
-}
-
-export function recordTouchedPaths(_workdir: string, paths: string[]): void {
-	if (!execution || !paths.length) return;
-	const panel = execution.panel ?? createExecutionPanelState();
-	execution.panel = panel;
-	const merged = new Set(panel.touchedPaths);
-	for (const raw of paths) {
-		const normalized = raw.trim().replace(/[\u0000]+/g, "");
-		if (!normalized) continue;
-		merged.add(normalized);
-	}
-	panel.touchedPaths = [...merged];
 }
 
 /** Record one assistant turn: accumulate usage and mark any completed items. */
 export function recordExecutionTurn(
 	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	completedIds: string[],
+	_ctx: ExtensionContext,
+	_completedIds: string[],
 	usage?: { input: number; output: number },
-): ItemDiffSummary | null {
-	if (!execution) return null;
+): void {
+	if (!execution) return;
 	if (usage) {
 		execution.usage.inToks += usage.input;
 		execution.usage.outToks += usage.output;
 	}
-	const summary = completeCompletedItems(execution, ctx.cwd, completedIds);
-	requestExecutionFlush(pi, ctx);
-	return summary;
+	requestExecutionFlush(pi, _ctx);
+	updateStatusWidget(_ctx);
 }
 
 export function registerExecutionTurnHandlers(
@@ -448,11 +325,12 @@ export function registerExecutionTurnHandlers(
 			.join("\n");
 		const changedIds = applyDoneMarkers(text);
 		const changedImpls = applyImplMarkers(text);
+		const changedCurrentI = applyCurrentIMarker(text);
 		const projection = (event.message as { usage?: { input?: number; output?: number } }).usage;
 		const raw = projection ?? lastAssistantUsage;
 		lastAssistantUsage = null; // consumed: never re-attribute a stale turn
 		const usage = raw ? { input: raw.input ?? 0, output: raw.output ?? 0 } : undefined;
-		if (usage || changedIds.length > 0 || changedImpls.length > 0) {
+		if (usage || changedIds.length > 0 || changedImpls.length > 0 || changedCurrentI) {
 			// Attribute this turn's usage now; `[DONE]` markers still only mark completion.
 			recordExecutionTurn(pi, ctx, changedIds, usage);
 		}
@@ -465,164 +343,182 @@ export function registerExecutionTurnHandlers(
 
 const EXECUTION_RESUME_CUSTOM_TYPE = "pi-plans-exec-resume";
 
-type CompactBranchEntry = SessionBeforeCompactEvent["branchEntries"][number];
-type CompactMessage = { role?: string; content?: Array<{ type: string; text?: string }> };
-
-function compactText(text: string, limit = 180): string {
-	const normalized = text.replace(/\s+/g, " ").trim();
-	if (normalized.length <= limit) return normalized;
-	return `${normalized.slice(0, Math.max(0, limit - 1))}…`;
+function activeVccSettings(ctx: ExtensionContext, phase: PiPlansCompactionPhase): { settings: PiPlansVccSettings; runId: string; artifactDir: string } | null {
+	const stateRoot = resolveStateRootOrNull(ctx.cwd);
+	if (!stateRoot) return null;
+	const active = readActive(ctx.cwd);
+	if (!active) return null;
+	const run = getRun(ctx.cwd, active.run_id);
+	if (!run) return null;
+	if (phase === "planning" && run.status !== "planning") return null;
+	if (phase === "execution" && run.status !== "executing") return null;
+	scaffoldVccSettings(stateRoot);
+	return { settings: loadVccSettings(stateRoot), runId: run.run_id, artifactDir: run.artifact_dir };
 }
 
-function messageText(message: CompactMessage | undefined): string {
-	if (!message) return "";
-	return (message.content ?? [])
-		.filter((part) => part.type === "text")
-		.map((part) => part.text ?? "")
-		.join("\n")
-		.trim();
+function executionVccContext(): PiPlansVccPhaseContext {
+	return {
+		phase: "execution",
+		planPath: execution?.planPath ?? null,
+		currentI: execution?.currentI ?? null,
+		remainingVerifierIds: execution?.items.filter((item) => !item.done).map((item) => item.id) ?? [],
+		implementationIds: execution?.implItems?.map((item) => item.id) ?? [],
+	};
 }
 
-function messageRoleLabel(role?: string): string {
-	switch (role) {
-		case "assistant": return "Assistant";
-		case "user": return "User";
-		case "toolResult": return "Tool";
-		case "custom": return "Custom";
-		default: return role ? role : "Message";
+function planningVccContext(branchEntries: CompactionEntryLike[], fallback: { runId?: string; artifactDir?: string }): PiPlansVccPhaseContext {
+	let runId: string | null = fallback.runId ?? null;
+	let artifactDir: string | null = fallback.artifactDir ?? null;
+	let planPath: string | null = null;
+	let currentI: string | null = null;
+	for (const entry of branchEntries) {
+		if (entry.type === "custom" && entry.customType === PLANNING_RUN_START_CUSTOM_TYPE) {
+			runId = typeof entry.data?.runId === "string" ? entry.data.runId : runId;
+			artifactDir = typeof entry.data?.artifactDir === "string" ? entry.data.artifactDir : artifactDir;
+		}
+		if (entry.type === "custom" && entry.customType === PLANNING_PLAN_WRITTEN_CUSTOM_TYPE) {
+			planPath = typeof entry.data?.planPath === "string" ? entry.data.planPath : planPath;
+		}
+		for (const id of entryCurrentIMarkers(entry)) currentI = id;
+		currentI = compactionCurrentI(entry) ?? currentI;
 	}
+	return { phase: "planning", runId, artifactDir, planPath, currentI };
 }
 
-function isInternalExecutionCustomType(customType?: string): boolean {
-	return customType === "pi-plans-exec"
-		|| customType === "pi-plans-exec-cleared"
-		|| customType === "pi-plans-exec-start"
-		|| customType === "pi-plans-exec-context"
-		|| customType === EXECUTION_RESUME_CUSTOM_TYPE;
-}
-
-function isSummarizableEntry(entry: CompactBranchEntry): boolean {
-	return entry.type === "message" && !!entry.message;
-}
-
-function renderMessageLine(entry: CompactBranchEntry): string {
-	if (!isSummarizableEntry(entry)) return "";
-	const text = messageText(entry.message);
-	if (!text) return "";
-	return `- [${messageRoleLabel(entry.message?.role)}] ${compactText(text)}`;
+function buildExecutionVccResult(event: SessionBeforeCompactEvent, ctx: ExtensionContext): VccCompactionBuildResult | null {
+	if (!execution) return null;
+	const active = activeVccSettings(ctx, "execution");
+	if (!active) return null;
+	return buildPiPlansVccCompaction({
+		branchEntries: event.branchEntries as unknown as CompactionEntryLike[],
+		preparation: event.preparation,
+		customInstructions: event.customInstructions,
+		reason: event.reason,
+		willRetry: event.willRetry,
+		settings: active.settings,
+		phaseContext: executionVccContext(),
+	});
 }
 
-function findExecutionCompactionCutEntryId(branchEntries: CompactBranchEntry[], fallback: string): string {
-	const completionIds = new Set(execution?.items.filter((item) => item.done).map((item) => item.id) ?? []);
-	let lastCompletionIndex = -1;
-	for (let i = 0; i < branchEntries.length; i++) {
-		const entry = branchEntries[i];
-		if (!isSummarizableEntry(entry)) continue;
-		const markers = scanDoneMarkers(messageText(entry.message));
-		if (markers.some((marker) => completionIds.has(marker))) {
-			lastCompletionIndex = i;
-		}
-	}
-	if (lastCompletionIndex >= 0) {
-		const next = branchEntries.slice(lastCompletionIndex + 1).find((entry) => entry.id && !isInternalExecutionCustomType(entry.customType));
-		if (next?.id) return next.id;
-	}
-	const startIndex = branchEntries.findIndex((entry) => entry.type === "custom" && entry.customType === "pi-plans-exec-start");
-	if (startIndex >= 0) {
-		const next = branchEntries.slice(startIndex + 1).find((entry) => entry.id && !isInternalExecutionCustomType(entry.customType));
-		if (next?.id) return next.id;
-	}
-	return fallback;
+export function buildExecutionCompactionResult(event: SessionBeforeCompactEvent, ctx: ExtensionContext): CompactionResult | null {
+	const built = buildExecutionVccResult(event, ctx);
+	return built?.kind === "compaction" ? built.compaction : null;
 }
 
-function buildFinishedItemSections(summaryEntries: CompactBranchEntry[]): string[] {
-	if (!execution) return [];
-	const completedItems = execution.items.filter((item) => item.done);
-	const sections: string[] = [];
-	let completedIndex = 0;
-	let currentLines: string[] = [];
-	for (const entry of summaryEntries) {
-		if (!isSummarizableEntry(entry)) continue;
-		const line = renderMessageLine(entry);
-		if (line) currentLines.push(line);
-		for (const marker of scanDoneMarkers(messageText(entry.message))) {
-			const itemIndex = completedItems.findIndex((item, index) => index >= completedIndex && item.id === marker);
-			if (itemIndex < 0) continue;
-			const item = completedItems[itemIndex];
-			sections.push(`### \`${item.id}\` ${item.text.split(";")[0]}
-${currentLines.length ? currentLines.join("\n") : "- (no transcript captured)"}`);
-			currentLines = [];
-			completedIndex = itemIndex + 1;
-		}
+export function handleExecutionBeforeCompact(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	event: SessionBeforeCompactEvent,
+): SessionBeforeCompactResult | undefined {
+	if (!execution) return undefined;
+	const state = ensureExecutionCompactionState(ctx);
+	state.inFlight = true;
+	state.lastAttemptReason = event.reason;
+	state.pendingStats = null;
+	state.pendingFollowUpPrompt = null;
+	state.pendingContinueAfterThresholdCompact = false;
+	let built: VccCompactionBuildResult | null;
+	try {
+		built = buildExecutionVccResult(event, ctx);
+	} catch (error) {
+		state.inFlight = false;
+		ctx.ui.notify(`pi-plans: VCC compaction preparation failed; using Pi default compaction (${String(error)}).`, "warning");
+		return undefined;
 	}
-	return sections;
-}
-
-export function buildExecutionCompactionResult(event: SessionBeforeCompactEvent, ctx: ExtensionContext): CompactionResult | null {
-	if (!execution) return null;
-	const active = readActive(ctx.cwd);
-	const run = active ? getRun(ctx.cwd, active.run_id) : null;
-	const firstKeptEntryId = findExecutionCompactionCutEntryId(event.branchEntries as CompactBranchEntry[], event.preparation.firstKeptEntryId);
-	const boundaryIndex = event.branchEntries.findIndex((entry) => entry.id === firstKeptEntryId);
-	const summaryEntries = boundaryIndex >= 0
-		? (event.branchEntries.slice(0, boundaryIndex) as CompactBranchEntry[])
-		: (event.branchEntries as CompactBranchEntry[]);
-	const sections = buildFinishedItemSections(summaryEntries);
-	const parts: string[] = [];
-	if (event.customInstructions?.trim()) {
-		parts.push(`## Compact Instructions
-${compactText(event.customInstructions, 1000)}`);
+	if (!built || built.kind === "fallback") {
+		state.inFlight = false;
+		return undefined;
 	}
-	parts.push(`## Plan Before This Run
-- Request: ${compactText(run?.request_text ?? execution.planPath, 280)}
-- Plan file: \`${execution.planPath}\``);
-	if (event.preparation.previousSummary?.trim()) {
-		parts.push(`## Previous Compact Summary
-${event.preparation.previousSummary.trim()}`);
+	if (built.kind === "cancel") {
+		state.inFlight = false;
+		ctx.ui.notify(built.message, "warning");
+		return { cancel: true };
 	}
-	parts.push(`## Finished VC Items
-${sections.length ? sections.join("\n\n") : "- (none yet)"}`);
-	parts.push(`## Current Work
-- Raw tail preserved from \`${firstKeptEntryId}\` onward.${event.preparation.isSplitTurn ? "\n- Split-turn prefix remains in the kept tail." : ""}`);
-	return {
-		summary: parts.join("\n\n"),
-		firstKeptEntryId,
-		tokensBefore: event.preparation.tokensBefore,
-		details: {
-			kind: "pi-plans-execution-compaction",
-			reason: event.reason,
-			willRetry: event.willRetry,
-			finishedItems: execution.items.filter((item) => item.done).map((item) => item.id),
-		},
-	};
+	state.pendingStats = built.stats;
+	state.pendingFollowUpPrompt = built.followUpPrompt;
+	state.pendingContinueAfterThresholdCompact = built.settings.continueAfterThresholdCompact;
+	requestExecutionFlush(pi, ctx);
+	return { compaction: built.compaction };
 }
 
-export function handleExecutionBeforeCompact(pi: ExtensionAPI, ctx: ExtensionContext, event: SessionBeforeCompactEvent): SessionBeforeCompactResult | undefined {
-	if (!execution) return undefined;
-	const compaction = buildExecutionCompactionResult(event, ctx);
-	if (!compaction) return undefined;
-	requestExecutionFlush(pi, ctx);
-	return { compaction };
+function runtimePiVersion(ctx: ExtensionContext): unknown {
+	return (ctx as ExtensionContext & { piVersion?: unknown }).piVersion ?? VERSION;
 }
 
-export function handleExecutionCompact(pi: ExtensionAPI, ctx: ExtensionContext, event: SessionCompactEvent): void {
+export async function handleExecutionCompact(pi: ExtensionAPI, ctx: ExtensionContext, event: SessionCompactEvent): Promise<void> {
 	if (!execution) return;
-	if (!event.willRetry) {
-		pi.sendMessage(
-			{
-				customType: EXECUTION_RESUME_CUSTOM_TYPE,
-				content: "Continue execution.",
-				display: false,
-			},
-			{ triggerTurn: true },
-		);
+	const state = ensureExecutionCompactionState(ctx);
+	const stats = state.pendingStats;
+	const followUpPrompt = state.pendingFollowUpPrompt;
+	const continueAfterThresholdCompact = state.pendingContinueAfterThresholdCompact;
+	state.pendingStats = null;
+	state.pendingFollowUpPrompt = null;
+	state.pendingContinueAfterThresholdCompact = false;
+	state.inFlight = false;
+	state.lastAttemptReason = event.reason;
+	state.cooldownActive = true;
+	state.rearmPending = false;
+	state.terminalBackoffTokens = null;
+	state.lastSuccessfulAt = utcNow();
+	state.lastSuccessfulUsagePercent = ctx.getContextUsage()?.percent ?? state.lastSuccessfulUsagePercent;
+	state.resumeGuard = false;
+	if (!event.willRetry && stats) {
+		ctx.ui.notify(formatVccCompactionStats(stats), "info");
+		if (followUpPrompt) {
+			await pi.sendUserMessage?.(followUpPrompt);
+		} else if ((event.reason === "threshold" || event.reason === "overflow") && shouldScheduleAutoContinue(continueAfterThresholdCompact, runtimePiVersion(ctx))) {
+			state.resumeGuard = true;
+			pi.sendMessage(
+				{
+					customType: EXECUTION_RESUME_CUSTOM_TYPE,
+					content: EXECUTION_COMPACTION_RESUME_MESSAGE,
+					display: false,
+				},
+				{ triggerTurn: true },
+			);
+		}
 	}
 	requestExecutionFlush(pi, ctx);
 	updateStatusWidget(ctx);
 }
 
+
 export function handleExecutionCompactFailed(pi: ExtensionAPI, ctx: ExtensionContext, event: SessionCompactFailedEvent): void {
 	if (!execution) return;
+	const state = executionCompactionState(ctx);
+	const terminal = isTerminalCompactionFailure(event);
+	if (terminal) {
+		// Pi refused or aborted the compaction. Hold the cooldown and re-arm
+		// only after real growth or high-watermark pressure so the loop stops.
+		if (state) {
+			state.inFlight = false;
+			state.resumeGuard = false;
+			state.cooldownActive = true;
+			state.rearmPending = false;
+			state.lastAttemptReason = event.reason;
+			const tokens = ctx.getContextUsage()?.tokens;
+			state.terminalBackoffTokens = typeof tokens === "number" ? tokens : Number.POSITIVE_INFINITY;
+			state.pendingStats = null;
+			state.pendingFollowUpPrompt = null;
+			state.pendingContinueAfterThresholdCompact = false;
+		}
+		const message = terminal.kind === "content"
+			? "pi-plans: compaction found nothing to summarize; backing off until the session grows past the keep-recent window."
+			: "pi-plans: compaction was aborted (provider interruption, user cancel, or a competing manual compact); backing off until the session grows or usage nears the window.";
+		ctx.ui.notify(message, "info");
+		requestExecutionFlush(pi, ctx);
+		return;
+	}
+	if (state) {
+		state.inFlight = false;
+		state.resumeGuard = false;
+		state.cooldownActive = false;
+		state.rearmPending = false;
+		state.lastAttemptReason = event.reason;
+		state.pendingStats = null;
+		state.pendingFollowUpPrompt = null;
+		state.pendingContinueAfterThresholdCompact = false;
+	}
 	ctx.ui.notify(
 		`pi-plans: compaction failed (${event.reason}); execution remains active and will wait for the next eligible turn.`,
 		"warning",
@@ -635,15 +531,14 @@ export function filterExecutionResumeMessages<T extends { customType?: string }>
 }
 
 // ---------------------------------------------------------------------------
-// Planning-phase auto compaction: same trigger rules and resume pattern as
-// the execution side, but with a different cut-point algorithm and summary
-// shape. The two state machines are kept independent (different memory slot
-// and snapshot key) so execution never bleeds into planning.
+// Planning-phase compaction: Pi core owns scheduling; this hook customizes
+// active planning compact events with the same VCC builder used by execution.
+// The two state machines are kept independent (different memory slot and
+// snapshot key) so execution never bleeds into planning.
 // ---------------------------------------------------------------------------
 
 export const PLANNING_RUN_START_CUSTOM_TYPE = "pi-plans-run-start";
 export const PLANNING_PLAN_WRITTEN_CUSTOM_TYPE = "pi-plans-plan-written";
-const PLANNING_QA_SECTION_HEADER = "## Q&A During Planning";
 const PLANNING_RESUME_CUSTOM_TYPE = "pi-plans-plan-resume";
 
 interface PlanningCompactionState {
@@ -653,107 +548,114 @@ interface PlanningCompactionState {
 	lastAttemptReason: "manual" | "threshold" | "overflow" | null;
 	lastSuccessfulUsagePercent: number | null;
 	lastSuccessfulAt: string | null;
+	/** Terminal "nothing to compact" backoff: tokens observed when Pi refused. */
+	terminalBackoffTokens: number | null;
+	pendingStats: VccCompactionStats | null;
+	pendingFollowUpPrompt: string | null;
+	pendingContinueAfterThresholdCompact: boolean;
 }
 
-interface PlanningBranchEntry {
-	id?: string;
-	type?: string;
-	customType?: string;
-	data?: { planPath?: string; runId?: string; artifactDir?: string };
-	message?: { role?: string; content?: Array<{ type: string; text?: string }> };
+function ensurePlanningCompactionState(ctx: ExtensionContext): PlanningCompactionState {
+	const session = ctx.sessionManager as unknown as { __planningCompaction?: PlanningCompactionState };
+	return (session.__planningCompaction ??= {
+		inFlight: false,
+		resumeGuard: false,
+		cooldownActive: false,
+		lastAttemptReason: null,
+		lastSuccessfulUsagePercent: null,
+		lastSuccessfulAt: null,
+		terminalBackoffTokens: null,
+		pendingStats: null,
+		pendingFollowUpPrompt: null,
+		pendingContinueAfterThresholdCompact: false,
+	});
 }
 
-function isPlanningInternalCustomType(customType?: string): boolean {
-	return (
-		customType === "pi-plans-exec"
-		|| customType === "pi-plans-exec-cleared"
-		|| customType === "pi-plans-exec-start"
-		|| customType === "pi-plans-exec-context"
-		|| customType === EXECUTION_RESUME_CUSTOM_TYPE
-		|| customType === PLANNING_RUN_START_CUSTOM_TYPE
-		|| customType === PLANNING_PLAN_WRITTEN_CUSTOM_TYPE
-		|| customType === PLANNING_RESUME_CUSTOM_TYPE
-	);
+function isTerminalCompactionFailure(event: { errorMessage?: string; aborted?: boolean }): { kind: "content" | "abort-stream" } | null {
+	const message = (event.errorMessage ?? "").toLowerCase();
+	if (message.includes("nothing to compact") || message.includes("already compacted") || message.includes("session too small")) {
+		return { kind: "content" };
+	}
+	// abort/stream class: explicit event names only, so that provider blips
+	// (network down, etc.) stay retryable.
+	const abortPatterns = [
+		"this operation was aborted",
+		"aborted",
+		"stream ended before a terminal response event",
+		"turn prefix summarization failed",
+		"auto-compaction failed",
+		"context overflow recovery failed",
+	];
+	if (abortPatterns.some((pattern) => message.includes(pattern))) {
+		return { kind: "abort-stream" };
+	}
+	// Aborted with no recognized message: still an abort-class terminal so the
+	// next eligible turn does not immediately retry the same operation.
+	if (event.aborted === true) {
+		return { kind: "abort-stream" };
+	}
+	return null;
 }
 
-function summarizePlanningMessageLine(entry: PlanningBranchEntry): string | null {
-	if (!entry.message) return null;
-	const text = (entry.message.content ?? [])
-		.filter((part) => part.type === "text")
-		.map((part) => part.text ?? "")
-		.join("\n")
-		.trim();
-	if (!text) return null;
-	const role = entry.message.role ?? "message";
-	const normalized = text.replace(/\s+/g, " ").trim();
-	const limit = 180;
-	const clipped = normalized.length > limit ? `${normalized.slice(0, limit - 1)}…` : normalized;
-	return `- [${role}] ${clipped}`;
+/** Session-scoped phase-local "compaction in flight" guard.
+ *  - Set on `session_before_compact` for the phase attributed by the custom
+ *    instructions hint; auto-compaction (no hint) marks both phases defensively.
+ *  - Cleared on `session_compact` and `session_compact_failed`.
+ *  - Retained so lifecycle events expose the same phase-local state to tests
+ *    and future Pi core schema additions. */
+type CompactionPhase = "planning" | "execution";
+
+function compactionLifecycleStore(ctx: ExtensionContext): {
+	planning: boolean;
+	execution: boolean;
+} {
+	const carrier = ctx.sessionManager as unknown as {
+		__piPlansCompactionInFlight?: { planning: boolean; execution: boolean };
+	};
+	carrier.__piPlansCompactionInFlight ??= { planning: false, execution: false };
+	return carrier.__piPlansCompactionInFlight;
 }
 
-function findPlanningCutEntryId(
-	branchEntries: PlanningBranchEntry[],
-	fallback: string,
-): { id: string; qaWindowEntries: PlanningBranchEntry[]; hasMarker: boolean } {
-	const planWrittenIndexes: number[] = [];
-	const runStartIndexes: number[] = [];
-	for (let i = 0; i < branchEntries.length; i++) {
-		const entry = branchEntries[i];
-		if (entry.type === "custom" && entry.customType === PLANNING_PLAN_WRITTEN_CUSTOM_TYPE) {
-			planWrittenIndexes.push(i);
-		} else if (entry.type === "custom" && entry.customType === PLANNING_RUN_START_CUSTOM_TYPE) {
-			runStartIndexes.push(i);
-		}
-	}
-	const planIndex = planWrittenIndexes[planWrittenIndexes.length - 1] ?? -1;
-	const startIndex = runStartIndexes[runStartIndexes.length - 1] ?? -1;
-	const anchorIndex = planIndex >= 0 ? planIndex : startIndex;
-	if (anchorIndex < 0) {
-		return { id: fallback, qaWindowEntries: [], hasMarker: false };
-	}
-	const next = branchEntries
-		.slice(anchorIndex + 1)
-		.find((entry) => entry.id && !isPlanningInternalCustomType(entry.customType));
-	if (!next?.id) {
-		return { id: fallback, qaWindowEntries: [], hasMarker: true };
-	}
-	const qaWindowEntries = branchEntries
-		.slice(startIndex >= 0 ? startIndex + 1 : 0, anchorIndex)
-		.filter((entry) => entry.type === "message" && entry.message);
-	return { id: next.id, qaWindowEntries, hasMarker: true };
+function isPlanningCustomInstructions(hint: unknown): boolean {
+	return typeof hint === "string" && hint.startsWith("pi-plans planning");
+}
+
+function isExecutionCustomInstructions(hint: unknown): boolean {
+	return typeof hint === "string" && hint.startsWith("pi-plans execution");
 }
 
-function buildPlanningQASection(qaWindowEntries: PlanningBranchEntry[]): string | null {
-	if (!qaWindowEntries.length) return null;
-	const lines: string[] = [];
-	for (const entry of qaWindowEntries) {
-		const line = summarizePlanningMessageLine(entry);
-		if (line) lines.push(line);
+export function noteCompactionStarted(ctx: ExtensionContext, customInstructions: unknown): void {
+	const store = compactionLifecycleStore(ctx);
+	if (isPlanningCustomInstructions(customInstructions)) {
+		store.planning = true;
+	} else if (isExecutionCustomInstructions(customInstructions)) {
+		store.execution = true;
+	} else {
+		// Auto-compaction (threshold/overflow/manual without our hint) marks both.
+		store.planning = true;
+		store.execution = true;
 	}
-	if (!lines.length) return null;
-	return `${PLANNING_QA_SECTION_HEADER}
-${lines.join("\n")}`;
 }
 
-function resolvePlanningCompactionContext(workdir: string): { runId: string; artifactDir: string } | null {
-	const active = readActive(workdir);
-	if (!active) return null;
-	const run = getRun(workdir, active.run_id);
-	if (!run || run.status !== "planning") return null;
-	return { runId: run.run_id, artifactDir: run.artifact_dir };
+/** Pi core's `SessionCompactEvent` / `SessionCompactFailedEvent` do not carry
+ *  `customInstructions` in any emission site, so the END side has no way to
+ *  know which phase the compaction belonged to. Clearing both phases is the
+ *  safe default — the per-phase start side (above) already encodes the hint
+ *  attribution. The hint parameter is retained for API symmetry and future
+ *  Pi core schema additions. */
+export function noteCompactionEnded(ctx: ExtensionContext, _customInstructions: unknown): void {
+	const store = compactionLifecycleStore(ctx);
+	store.planning = false;
+	store.execution = false;
 }
 
-export function shouldTriggerPlanningCompaction(ctx: ExtensionContext): boolean {
-	if (getExecution()) return false;
-	const ctxWorkdir = ctx.cwd;
-	if (!resolvePlanningCompactionContext(ctxWorkdir)) return false;
-	const percent = ctx.getContextUsage()?.percent ?? null;
-	if (percent === null || percent < 100) return false;
-	const session = ctx.sessionManager as unknown as { __planningCompaction?: PlanningCompactionState };
-	const state = session.__planningCompaction;
-	if (!state) return true;
-	if (state.inFlight || state.resumeGuard || state.cooldownActive) return false;
-	return true;
+export function compactionInFlight(ctx: ExtensionContext, phase: CompactionPhase): boolean {
+	const store = compactionLifecycleStore(ctx);
+	return store[phase];
+}
+
+export function shouldTriggerPlanningCompaction(_ctx: ExtensionContext): boolean {
+	return false;
 }
 
 export function consumePlanningCompactionResumeGuard(ctx: ExtensionContext): boolean {
@@ -763,78 +665,34 @@ export function consumePlanningCompactionResumeGuard(ctx: ExtensionContext): boo
 	return true;
 }
 
-export function refreshPlanningCompactionCooldown(ctx: ExtensionContext): void {
-	const session = ctx.sessionManager as unknown as { __planningCompaction?: PlanningCompactionState };
-	const state = session.__planningCompaction;
-	if (!state) return;
-	const percent = ctx.getContextUsage()?.percent ?? null;
-	if (percent !== null && percent < 85 && state.cooldownActive) {
-		state.cooldownActive = false;
-	}
+export function refreshPlanningCompactionCooldown(_ctx: ExtensionContext): void {
+	// Pi core owns scheduling; retained for lifecycle compatibility only.
 }
 
-export function requestPlanningCompaction(ctx: ExtensionContext): void {
-	const session = ctx.sessionManager as unknown as { __planningCompaction?: PlanningCompactionState };
-	const state = (session.__planningCompaction ??= {
-		inFlight: false,
-		resumeGuard: false,
-		cooldownActive: false,
-		lastAttemptReason: null,
-		lastSuccessfulUsagePercent: null,
-		lastSuccessfulAt: null,
-	} satisfies PlanningCompactionState);
-	if (state.inFlight || state.resumeGuard) return;
-	state.inFlight = true;
-	state.lastAttemptReason = "threshold";
-	ctx.compact({ customInstructions: "pi-plans planning auto compact" });
+export function requestPlanningCompaction(_ctx: ExtensionContext): void {
+	// Proactive pi-plans compaction is intentionally disabled. Manual,
+	// threshold, and overflow compactions are handled by session_before_compact.
+}
+
+function buildPlanningVccResult(event: SessionBeforeCompactEvent, ctx: ExtensionContext): VccCompactionBuildResult | null {
+	if (getExecution()) return null;
+	const active = activeVccSettings(ctx, "planning");
+	if (!active) return null;
+	const branchEntries = event.branchEntries as unknown as CompactionEntryLike[];
+	return buildPiPlansVccCompaction({
+		branchEntries,
+		preparation: event.preparation,
+		customInstructions: event.customInstructions,
+		reason: event.reason,
+		willRetry: event.willRetry,
+		settings: active.settings,
+		phaseContext: planningVccContext(branchEntries, active),
+	});
 }
 
 export function buildPlanningCompactionResult(event: SessionBeforeCompactEvent, ctx: ExtensionContext): CompactionResult | null {
-	const ctxWorkdir = ctx.cwd;
-	const planningCtx = resolvePlanningCompactionContext(ctxWorkdir);
-	if (!planningCtx) return null;
-	const branchEntries = event.branchEntries as unknown as PlanningBranchEntry[];
-	const { id: firstKeptEntryId, qaWindowEntries, hasMarker } = findPlanningCutEntryId(branchEntries, event.preparation.firstKeptEntryId);
-	const qaSection = hasMarker ? buildPlanningQASection(qaWindowEntries) : null;
-	const parts: string[] = [];
-	if (event.customInstructions?.trim()) {
-		parts.push(`## Compact Instructions
-${compactText(event.customInstructions, 1000)}`);
-	}
-	if (qaSection) {
-		parts.push(qaSection);
-	}
-	const previousSummary = event.preparation.previousSummary?.trim();
-	parts.push(`## Goal
-${compactText(planningCtx.runId, 80)} — keep current planning progress.`);
-	parts.push(`## Constraints & Preferences
-- Stay in the active planning run (\`${planningCtx.runId}\`).
-- Plan files live under \`${planningCtx.artifactDir}\`.`);
-	parts.push(`## Progress
-### Done
-- Pre-plan history compressed below.
-
-### In Progress
-- Current planning question or open decision.
-
-### Blocked
-- ${hasMarker ? "None" : "Planning cut-point marker missing; falling back to default."}`);
-	if (previousSummary) {
-		parts.push(`## Previous Compact Summary
-${previousSummary}`);
-	}
-	parts.push(`## Next Steps
-- Resume the active planning turn from the raw tail.`);
-	return {
-		summary: parts.join("\n\n"),
-		firstKeptEntryId,
-		tokensBefore: event.preparation.tokensBefore,
-		details: {
-			kind: "pi-plans-planning-compaction",
-			reason: event.reason,
-			hasMarker,
-		},
-	};
+	const built = buildPlanningVccResult(event, ctx);
+	return built?.kind === "compaction" ? built.compaction : null;
 }
 
 export function handlePlanningBeforeCompact(
@@ -843,74 +701,103 @@ export function handlePlanningBeforeCompact(
 	event: SessionBeforeCompactEvent,
 ): SessionBeforeCompactResult | undefined {
 	if (getExecution()) return undefined;
-	if (!resolvePlanningCompactionContext(ctx.cwd)) return undefined;
-	const session = ctx.sessionManager as unknown as { __planningCompaction?: PlanningCompactionState };
-	const state = (session.__planningCompaction ??= {
-		inFlight: false,
-		resumeGuard: false,
-		cooldownActive: false,
-		lastAttemptReason: null,
-		lastSuccessfulUsagePercent: null,
-		lastSuccessfulAt: null,
-	} satisfies PlanningCompactionState);
-	const percent = ctx.getContextUsage()?.percent ?? null;
-	if (event.reason === "threshold" && (percent === null || percent < 100)) {
-		state.inFlight = false;
-		state.lastAttemptReason = event.reason;
-		return { cancel: true };
-	}
+	const state = ensurePlanningCompactionState(ctx);
 	state.inFlight = true;
 	state.lastAttemptReason = event.reason;
-	if (percent !== null && percent < 85) {
-		state.cooldownActive = false;
+	state.pendingStats = null;
+	state.pendingFollowUpPrompt = null;
+	state.pendingContinueAfterThresholdCompact = false;
+	let built: VccCompactionBuildResult | null;
+	try {
+		built = buildPlanningVccResult(event, ctx);
+	} catch (error) {
+		state.inFlight = false;
+		ctx.ui.notify(`pi-plans: VCC planning compaction preparation failed; using Pi default compaction (${String(error)}).`, "warning");
+		return undefined;
 	}
-	const compaction = buildPlanningCompactionResult(event, ctx);
-	if (!compaction) {
+	if (!built || built.kind === "fallback") {
 		state.inFlight = false;
 		return undefined;
 	}
-	return { compaction };
+	if (built.kind === "cancel") {
+		state.inFlight = false;
+		ctx.ui.notify(built.message, "warning");
+		return { cancel: true };
+	}
+	state.pendingStats = built.stats;
+	state.pendingFollowUpPrompt = built.followUpPrompt;
+	state.pendingContinueAfterThresholdCompact = built.settings.continueAfterThresholdCompact;
+	return { compaction: built.compaction };
 }
 
-export function handlePlanningCompact(pi: ExtensionAPI, ctx: ExtensionContext, event: SessionCompactEvent): void {
+export async function handlePlanningCompact(pi: ExtensionAPI, ctx: ExtensionContext, event: SessionCompactEvent): Promise<void> {
 	if (getExecution()) return;
 	const session = ctx.sessionManager as unknown as { __planningCompaction?: PlanningCompactionState };
 	const state = session.__planningCompaction;
 	if (!state) return;
+	const stats = state.pendingStats;
+	const followUpPrompt = state.pendingFollowUpPrompt;
+	const continueAfterThresholdCompact = state.pendingContinueAfterThresholdCompact;
+	state.pendingStats = null;
+	state.pendingFollowUpPrompt = null;
+	state.pendingContinueAfterThresholdCompact = false;
 	state.inFlight = false;
 	state.lastAttemptReason = event.reason;
+	state.terminalBackoffTokens = null;
 	state.cooldownActive = true;
 	state.lastSuccessfulAt = utcNow();
 	state.lastSuccessfulUsagePercent = ctx.getContextUsage()?.percent ?? state.lastSuccessfulUsagePercent;
-	if (!event.willRetry) {
-		state.resumeGuard = true;
-		pi.sendMessage(
-			{
-				customType: PLANNING_RESUME_CUSTOM_TYPE,
-				content: "Continue planning.",
-				display: false,
-			},
-			{ triggerTurn: true },
-		);
-	} else {
-		state.resumeGuard = false;
+	state.resumeGuard = false;
+	if (!event.willRetry && stats) {
+		ctx.ui.notify(formatVccCompactionStats(stats), "info");
+		if (followUpPrompt) {
+			await pi.sendUserMessage?.(followUpPrompt);
+		} else if ((event.reason === "threshold" || event.reason === "overflow") && shouldScheduleAutoContinue(continueAfterThresholdCompact, runtimePiVersion(ctx))) {
+			state.resumeGuard = true;
+			pi.sendMessage(
+				{
+					customType: PLANNING_RESUME_CUSTOM_TYPE,
+					content: "Continue planning.",
+					display: false,
+				},
+				{ triggerTurn: true },
+			);
+		}
 	}
 }
 
+
 export function handlePlanningCompactFailed(pi: ExtensionAPI, ctx: ExtensionContext, event: SessionCompactFailedEvent): void {
 	if (getExecution()) return;
 	const session = ctx.sessionManager as unknown as { __planningCompaction?: PlanningCompactionState };
 	const state = session.__planningCompaction;
 	if (!state) return;
-	const expectedThresholdCancel = event.reason === "threshold" && event.aborted && !state.inFlight;
-	if (expectedThresholdCancel) {
+	const terminal = isTerminalCompactionFailure(event);
+	if (terminal) {
+		// Pi refused or aborted the compaction. Hold the cooldown and re-arm
+		// only after real growth or high-watermark pressure so the loop stops.
+		state.inFlight = false;
+		state.resumeGuard = false;
+		state.cooldownActive = true;
 		state.lastAttemptReason = event.reason;
+		const tokens = ctx.getContextUsage()?.tokens;
+		state.terminalBackoffTokens = typeof tokens === "number" ? tokens : Number.POSITIVE_INFINITY;
+		state.pendingStats = null;
+		state.pendingFollowUpPrompt = null;
+		state.pendingContinueAfterThresholdCompact = false;
+		const message = terminal.kind === "content"
+			? "pi-plans: compaction found nothing to summarize; backing off until the session grows past the keep-recent window."
+			: "pi-plans: compaction was aborted (provider interruption, user cancel, or a competing manual compact); backing off until the session grows or usage nears the window.";
+		ctx.ui.notify(message, "info");
 		return;
 	}
 	state.inFlight = false;
 	state.resumeGuard = false;
 	state.cooldownActive = false;
 	state.lastAttemptReason = event.reason;
+	state.pendingStats = null;
+	state.pendingFollowUpPrompt = null;
+	state.pendingContinueAfterThresholdCompact = false;
 	ctx.ui.notify(
 		`pi-plans: planning compaction failed (${event.reason}); will try again on the next eligible turn.`,
 		"warning",
@@ -921,41 +808,12 @@ export function filterPlanningResumeMessages<T extends { customType?: string }>(
 	return messages.filter((message) => message.customType !== PLANNING_RESUME_CUSTOM_TYPE);
 }
 
-export async function ensureExecutionModelActive(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
-	const state = execution?.modelState;
-	if (!state) return;
-	const selection = resolveModelSelection(ctx, state.executionSelector);
-	if (!selection) {
-		ctx.ui.notify(`pi-plans: execution model ${state.executionSelector} not found; continuing on the current model.`, "warning");
-		return;
-	}
-	const switched = await applyModelSelection(pi, ctx, selection);
-	if (!switched) {
-		ctx.ui.notify(`pi-plans: could not switch to execution model ${state.executionSelector} (no API key?); continuing on the current model.`, "warning");
-	}
-}
-
-async function restorePlanningModel(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
-	const state = execution?.modelState;
-	if (!state?.planningSelector) return;
-	const selection = resolveModelSelection(ctx, state.planningSelector);
-	if (!selection) {
-		ctx.ui.notify(`pi-plans: planning model ${state.planningSelector} not found; keeping the current model.`, "warning");
-		return;
-	}
-	const restored = await applyModelSelection(pi, ctx, selection);
-	if (!restored) {
-		ctx.ui.notify(`pi-plans: could not restore planning model ${state.planningSelector} (no API key?); keeping the current model.`, "warning");
-	}
-}
-
 export async function stopExecution(pi: ExtensionAPI, ctx: ExtensionContext, reason: string): Promise<void> {
 	if (!execution) return;
-	await restorePlanningModel(pi, ctx);
+	resetExecutionCompactionState(ctx);
 	// Final synchronous write: drain any deferred flush and land the last snapshot.
 	pendingExecutionFlush = false;
 	persist(pi);
-	clearExecutionPanel(ctx);
 	execution = null;
 	pi.appendEntry("pi-plans-exec-cleared", { reason });
 	pi.sendMessage(
@@ -1010,29 +868,50 @@ export function applyImplMarkers(text: string): string[] {
 	return changed;
 }
 
+export function applyCurrentIMarker(text: string): boolean {
+	if (!execution?.implItems?.length) return false;
+	const markers = scanCurrentIMarkers(text);
+	const resolved = resolveCurrentI(execution.implItems, markers, execution.currentI);
+	if (!resolved || resolved === execution.currentI) return false;
+	execution.currentI = resolved;
+	return true;
+}
+
 export function isExecutionComplete(): boolean {
 	return execution !== null && execution.items.length > 0 && execution.items.every((item) => item.done);
 }
 
 export async function completeExecution(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
 	if (!execution) return;
-	await restorePlanningModel(pi, ctx);
+	resetExecutionCompactionState(ctx);
 	// Final synchronous write: drain any deferred flush and land the last snapshot.
 	pendingExecutionFlush = false;
 	persist(pi);
+
 	const summary = execution.items.map((item) => `- ✅ \`${item.id}\` ${item.text.split(";")[0]}`).join("\n");
 	const planPath = execution.planPath;
-	clearExecutionPanel(ctx);
 	execution = null;
 	pi.appendEntry("pi-plans-exec-cleared", { reason: "complete" });
+	// Post-execution goal-running continuation: in interactive sessions, attach
+	// the continuation block and trigger a new turn so the agent immediately
+	// enters the implementation-review loop. Headless sessions keep the silent
+	// completion behavior. Both completeExecution call sites (turn_end and the
+	// restoreFromSession recovery path) share this behavior.
+	const interactive = ctx.hasUI === true;
+	const content = interactive
+		? `**Plan complete!** ✅ \`${planPath}\`\n\n${summary}\n\n${AMELIORATION_PROMPT_TEXT}`
+		: `**Plan complete!** ✅ \`${planPath}\`\n\n${summary}`;
 	pi.sendMessage(
 		{
 			customType: "pi-plans-complete",
-			content: `**Plan complete!** ✅ \`${planPath}\`\n\n${summary}`,
+			content,
 			display: true,
 		},
-		{ triggerTurn: false },
+		{ triggerTurn: interactive },
 	);
+	if (interactive) {
+		pi.appendEntry("pi-plans-ameliorate", { planPath, phase: "goal-started", rounds: null, currentRound: 0 });
+	}
 	const active = readActive(ctx.cwd);
 	if (active) {
 		try {
@@ -1044,21 +923,40 @@ export async function completeExecution(pi: ExtensionAPI, ctx: ExtensionContext)
 	updateStatusWidget(ctx);
 }
 
+/** Instructions appended to the post-execution completion message in
+ * interactive sessions, telling the agent to enter the goal-running
+ * implementation-review loop. */
+export const AMELIORATION_PROMPT_TEXT = `---
+Goal-running continuation: immediately ask the user now via ask_choice (autoComplete: false, in the session language) for the termination condition of the implementation-review loop: until no high-severity finding (hard cap 5 rounds, recommended) / 1 round / 2 rounds / 3 rounds. Then keep running the loop without asking whether to continue: each round calls refine (role: "reviewer", target: "implementation"), accepts findings on evidence, applies fixes, re-runs relevant tests, and repeats until the chosen termination condition or the 5-round cap.`;
+
 /** Injection text for before_agent_start while executing. */
-export function executionContextMessage(): string | null {
+export function executionContextMessage(ctx: ExtensionContext): string | null {
 	if (!execution) return null;
 	const remaining = execution.items.filter((item) => !item.done);
 	const list =
 		remaining.map((item) => `- \`${item.id}\` ${item.text}`).join("\n") || "(none — report completion now)";
+	// Live read: the injected guidance and the tool wrappers share the same
+	// tri-state, so they can never contradict each other mid-run.
+	const mode = resolveGraphMode(ctx?.cwd ?? process.cwd());
+	const graphLine =
+		mode === "config-unavailable"
+			? `${graphBlockForExecutor(false)}\n[pi-plans: config unreadable this turn; graph features are off until .git/pi_plans/config.json is repaired]`
+			: graphBlockForExecutor(mode === "enabled");
+	const implementationItems = execution.implItems?.length
+		? `\nImplementation items: ${execution.implItems.map((item) => item.id).join(", ")}${execution.currentI ? `\nCurrent implementation item: \`${execution.currentI}\`` : ""}\nWhen beginning an implementation item, emit its current anchor exactly once as \`[I-###:current]\`; then use \`[I-###:implemented]\` or \`[I-###:validating]\` for progress.`
+		: "";
 	return `[PI-PLANS EXECUTION — write access enabled]
 Implement the accepted plan at ${execution.planPath} (${execution.items.length - remaining.length}/${execution.items.length} verifier items done).
 
 Remaining verifier items:
-${list}
+${list}${implementationItems}
+
+${graphLine}
 
 Execution rules:
 - Implement implementation items in dependency order; grow the change in layers — smallest end-to-end slice first, then stack each new capability on top of what already works.
-- Report implementation-item progress with lightweight markers in your reply: write \`[I-001:implemented]\` when an item's code is done, \`[I-001:validating]\` when you start verifying it. The status panel tracks these states.
+- Report implementation-item progress with lightweight markers in your reply: write \`[I-001:implemented]\` when an item's code is done, \`[I-001:validating]\` when you start verifying it. The execution status bar tracks these states.
+- For subprocess-backed verification, when a step starts a subprocess and needs its result before verifying, use literal \`waiting for\` with backoff \`5s -> 10s -> 20s -> 40s -> 80s\`, then keep polling at 80s; restart at 5s for each new subprocess.
 - Simplest implementation that fully meets the item: no speculative abstractions, configuration, or indirection; keep components modular with clearly separated concerns.
 - Architectural decisions are for the long term: no stopgaps. Do not add backward-compatibility layers, fallbacks, or migrations — remove the obsolete paths this change obsoletes.
 - Prefer established, well-maintained libraries when they reduce complexity or improve reliability; before writing your own implementation or adding a package, check the project's existing dependencies (docs and types) — never reimplement common functionality without a clear reason.
@@ -1081,6 +979,7 @@ interface SessionEntry {
  */
 export async function restoreFromSession(pi: ExtensionAPI, ctx: ExtensionContext, entries: SessionEntry[]): Promise<void> {
 	pendingExecutionFlush = false; // no flush debt survives a restart
+	resetExecutionCompactionState(ctx);
 	let snapshotIndex = -1;
 	let snapshot: ExecState | null = null;
 	for (let i = entries.length - 1; i >= 0; i--) {
@@ -1093,21 +992,18 @@ export async function restoreFromSession(pi: ExtensionAPI, ctx: ExtensionContext
 		if (entry.type === "custom" && entry.customType === "pi-plans-exec-cleared") {
 			// Execution was explicitly stopped or completed after the last snapshot.
 			execution = null;
-			syncExecutionPanel(ctx);
 			updateStatusWidget(ctx);
 			return;
 		}
 	}
 	if (!snapshot) {
 		execution = null;
-		syncExecutionPanel(ctx);
 		updateStatusWidget(ctx);
 		return;
 	}
 	// Ignore stale plans whose file vanished.
 	if (!fs.existsSync(snapshot.planPath)) {
 		execution = null;
-		syncExecutionPanel(ctx);
 		updateStatusWidget(ctx);
 		return;
 	}
@@ -1116,16 +1012,14 @@ export async function restoreFromSession(pi: ExtensionAPI, ctx: ExtensionContext
 		items: snapshot.items.map((item) => ({ ...item })),
 		startedAt: snapshot.startedAt,
 		usage: snapshot.usage ?? { inToks: 0, outToks: 0 },
-		panel: executionPanelFromEntryData(snapshot.panel) ?? createExecutionPanelState(),
-		modelState: snapshot.modelState,
 		implItems: snapshot.implItems ?? [],
 		implStatus: { ...(snapshot.implStatus ?? {}) },
+		currentI: snapshot.currentI ?? inferCurrentI(snapshot.implItems, snapshot.items, snapshot.implStatus),
 	};
 	for (let i = snapshotIndex + 1; i < entries.length; i++) {
 		const entry = entries[i];
 		if (entry.type === "custom" && entry.customType === "pi-plans-exec-cleared") {
 			execution = null;
-			syncExecutionPanel(ctx);
 			break;
 		}
 		const message = entry.message;
@@ -1136,6 +1030,7 @@ export async function restoreFromSession(pi: ExtensionAPI, ctx: ExtensionContext
 				.join("\n");
 			applyDoneMarkers(text);
 			applyImplMarkers(text);
+			applyCurrentIMarker(text);
 		}
 	}
 	if (execution) {
@@ -1145,6 +1040,5 @@ export async function restoreFromSession(pi: ExtensionAPI, ctx: ExtensionContext
 			await completeExecution(pi, ctx);
 		}
 	}
-	syncExecutionPanel(ctx);
 	updateStatusWidget(ctx);
 }