pi-plans 0.1.2 → 0.2.0

package/src/exec.ts

@@ -3,10 +3,11 @@
  *
  * 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 { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import type {
 	CompactionResult,
@@ -17,56 +18,48 @@ import type {
 	SessionCompactEvent,
 	SessionCompactFailedEvent,
 } from "@earendil-works/pi-coding-agent";
+import { AUTOCOMPLETE_ENTRY } from "./autocomplete.ts";
 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";
+	compactText as boundedCompactionText,
+	compactionCurrentI,
+	currentIExceedsTrigger,
+	entryCurrentIMarkers,
+	extractReadRecords,
+	formatReadRecord,
+	mergeCompactionDetails,
+	planIAwareCompaction,
+	type CompactionDetailsLike,
+	type CompactionEntryLike,
+} from "./compaction.ts";
+import { getRun, readActive, setRunStatus, utcNow } from "./state.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 +68,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,173 +86,158 @@ 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_TRIGGER_PERCENT = 20;
+const EXECUTION_COMPACTION_REARM_PERCENT = 80;
+const EXECUTION_COMPACTION_REARM_HIGH_PERCENT = 95;
+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;
 }
 
-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,
+	});
 }
 
-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 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);
+function consumeExecutionCompactionResumeGuard(ctx: ExtensionContext): boolean {
+	const state = executionCompactionState(ctx);
+	if (!state?.resumeGuard) return false;
+	state.resumeGuard = false;
+	return true;
+}
+
+function refreshExecutionCompactionCooldown(ctx: ExtensionContext): void {
+	const state = executionCompactionState(ctx);
+	if (!state) return;
+	const percent = ctx.getContextUsage()?.percent ?? null;
+	if (percent !== null && percent < EXECUTION_COMPACTION_REARM_PERCENT && state.cooldownActive) {
+		state.cooldownActive = false;
+		state.rearmPending = true;
 	}
-	return unique;
 }
 
-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);
+function executionCurrentIUsage(ctx: ExtensionContext): { tokens: number; contextWindow: number; eligible?: boolean } | null {
+	const usage = ctx.getContextUsage();
+	if (!usage || typeof usage.contextWindow !== "number" || usage.contextWindow <= 0) return null;
+	const manager = ctx.sessionManager as unknown as { getBranch?: () => CompactionEntryLike[] };
+	if (execution?.implItems?.length && typeof manager.getBranch === "function") {
+		try {
+			const entries = manager.getBranch();
+			if (entries.length) {
+				const plan = planIAwareCompaction({
+					entries,
+					currentI: execution.currentI,
+					knownIIds: execution.implItems.map((item) => item.id),
+					contextWindow: usage.contextWindow,
+					tokensBefore: usage.tokens ?? undefined,
+				});
+				if (plan.currentI || execution.currentI) {
+					return {
+						tokens: plan.currentITokens,
+						contextWindow: usage.contextWindow,
+						eligible: plan.firstKeptEntryIndex !== null && plan.firstKeptEntryIndex > 0,
+					};
+				}
+			}
+		} catch {
+			// A read-only session projection is optional in test and startup contexts.
 		}
-		return true;
 	}
-	const success = await pi.setModel(selection.model);
-	if (!success) return false;
-	if (selection.thinkingLevel !== null) {
-		pi.setThinkingLevel(selection.thinkingLevel as never);
+	if (typeof usage.tokens !== "number") return null;
+	return { tokens: usage.tokens, contextWindow: usage.contextWindow };
+}
+export function shouldTriggerExecutionCompaction(ctx: ExtensionContext): boolean {
+	const currentUsage = executionCurrentIUsage(ctx);
+	if (!currentUsage || currentUsage.eligible === false || !currentIExceedsTrigger(currentUsage.tokens, currentUsage.contextWindow)) return false;
+	const percent = (currentUsage.tokens / currentUsage.contextWindow) * 100;
+	const state = executionCompactionState(ctx);
+	if (!state) return true;
+	if (state.inFlight || state.resumeGuard || state.cooldownActive) return false;
+	if (state.rearmPending) {
+		if (percent < EXECUTION_COMPACTION_REARM_HIGH_PERCENT) return false;
+		state.rearmPending = false;
 	}
 	return true;
 }
 
-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,
-		);
-		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;
+function requestExecutionCompaction(ctx: ExtensionContext): void {
+	const state = ensureExecutionCompactionState(ctx);
+	if (state.inFlight || state.resumeGuard) return;
+	state.inFlight = true;
+	state.lastAttemptReason = "threshold";
+	try {
+		ctx.compact({ customInstructions: "pi-plans execution auto compact" });
+	} catch (error) {
+		state.inFlight = false;
+		ctx.ui.notify(`pi-plans: could not request execution compaction (${String(error)}).`, "warning");
 	}
+}
 
-	if (configuredSelector) {
-		const resolved = resolveModelSelection(ctx, configuredSelector);
-		if (resolved) return resolved;
-	} else {
-		return current;
+export function handleExecutionTurnCompaction(ctx: ExtensionContext): void {
+	refreshExecutionCompactionCooldown(ctx);
+	if (consumeExecutionCompactionResumeGuard(ctx)) return;
+	if (shouldTriggerExecutionCompaction(ctx)) {
+		requestExecutionCompaction(ctx);
 	}
+}
 
-	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);
+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)),
+		);
+		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 resolveModelSelection(ctx, choice) ?? current;
+	return {
+		done: execution.items.filter((item) => item.done).length,
+		total: execution.items.length,
+	};
 }
 
 export function executionProgress(): { done: number; total: number } | null {
@@ -275,13 +245,26 @@ export function executionProgress(): { done: number; total: number } | null {
 	return computeExecutionProgress(execution);
 }
 
+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}`;
+}
+
+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 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 +309,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 +343,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 +387,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);
 		}
@@ -558,64 +498,264 @@ ${currentLines.length ? currentLines.join("\n") : "- (no transcript captured)"}`
 	return sections;
 }
 
-export function buildExecutionCompactionResult(event: SessionBeforeCompactEvent, ctx: ExtensionContext): CompactionResult | null {
-	if (!execution) return null;
+function splitTurnBoundaryIndex(event: SessionBeforeCompactEvent): number | undefined {
+	if (!event.preparation.isSplitTurn) return undefined;
+	const index = event.branchEntries.findIndex((entry) => entry.id === event.preparation.firstKeptEntryId);
+	return index >= 0 ? index : undefined;
+}
+
+function buildExecutionIPlan(event: SessionBeforeCompactEvent, ctx?: ExtensionContext): ReturnType<typeof planIAwareCompaction> {
+	if (!execution) throw new Error("execution state is unavailable");
+	const usage = eventPreparationUsage(event, ctx);
+	return planIAwareCompaction({
+		entries: event.branchEntries as unknown as CompactionEntryLike[],
+		currentI: execution.currentI,
+		knownIIds: execution.implItems?.map((item) => item.id),
+		contextWindow: usage.contextWindow,
+		tokensBefore: event.preparation.tokensBefore,
+		fallbackFirstKeptEntryId: event.preparation.firstKeptEntryId,
+		maxFirstKeptEntryIndex: splitTurnBoundaryIndex(event),
+	});
+}
+
+function eventPreparationUsage(event: SessionBeforeCompactEvent, ctx?: ExtensionContext): { contextWindow: number | null } {
+	const fromContext = ctx?.getContextUsage()?.contextWindow;
+	const contextWindow = (event as SessionBeforeCompactEvent & { contextWindow?: number }).contextWindow ?? fromContext;
+	return { contextWindow: typeof contextWindow === "number" && contextWindow > 0 ? contextWindow : null };
+}
+
+function previousCompactionDetails(entries: CompactionEntryLike[]): CompactionDetailsLike | undefined {
+	let merged: CompactionDetailsLike | undefined;
+	for (const entry of entries) {
+		if (entry.type !== "compaction") continue;
+		const raw = entry.details ?? entry.data;
+		if (!raw || typeof raw !== "object") continue;
+		const details = raw as CompactionDetailsLike;
+		if (!details.readRecords && !details.metrics && !details.iSections) continue;
+		merged = mergeCompactionDetails(merged, details);
+	}
+	return merged;
+}
+
+function buildImplementationSections(plan: ReturnType<typeof planIAwareCompaction>): string[] {
+	const sections: string[] = [];
+	for (const slice of plan.slices) {
+		if (slice.id === null) continue;
+		const lines = slice.entries
+			.filter((entry) => plan.summaryEntries.includes(entry))
+			.map((entry) => renderMessageLine(entry as CompactBranchEntry))
+			.filter(Boolean);
+		if (lines.length) {
+			sections.push(`### ${slice.current ? "Current I" : "Implementation I"} \`${slice.id}\`\n${lines.join("\\n")}`);
+		}
+	}
+	return sections;
+}
+
+function executionSummaryParts(
+	event: SessionBeforeCompactEvent,
+	ctx: ExtensionContext,
+	firstKeptEntryId: string,
+	boundaryIndex: number,
+	plan: ReturnType<typeof planIAwareCompaction> | null,
+): { parts: string[]; details: CompactionDetailsLike } {
+	if (!execution) return { parts: [], details: {} };
 	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 branchEntries = event.branchEntries as unknown as CompactionEntryLike[];
 	const summaryEntries = boundaryIndex >= 0
-		? (event.branchEntries.slice(0, boundaryIndex) as CompactBranchEntry[])
-		: (event.branchEntries as CompactBranchEntry[]);
+		? (branchEntries.slice(0, boundaryIndex) as CompactBranchEntry[])
+		: (branchEntries as CompactBranchEntry[]);
 	const sections = buildFinishedItemSections(summaryEntries);
+	const readRecords = plan?.readRecords ?? extractReadRecords(summaryEntries as unknown as CompactionEntryLike[]);
+	const priorDetails = previousCompactionDetails(branchEntries);
+	const metrics = plan?.metrics ?? {
+		contextWindow: ctx.getContextUsage()?.contextWindow ?? null,
+		tokensBefore: event.preparation.tokensBefore,
+		currentITokens: 0,
+		summaryTokens: 0,
+		keptSuffixTokens: 0,
+		estimatedAfterTokens: null,
+		targetRatio: 0.1,
+		currentI: execution.currentI ?? null,
+		firstKeptEntryId,
+		targetMet: false,
+		hardFloorReason: "I-aware budget unavailable for this legacy execution snapshot",
+	};
+	const details = mergeCompactionDetails(priorDetails, {
+		kind: "pi-plans-execution-compaction",
+		version: 1,
+		currentI: execution.currentI ?? plan?.currentI ?? null,
+		iSections: plan?.slices.map((slice) => ({ id: slice.id, entryIds: slice.entries.map((entry) => entry.id).filter((id): id is string => !!id) })) ?? [],
+		readRecords,
+		metrics: { ...metrics, firstKeptEntryId },
+		reason: event.reason,
+		willRetry: event.willRetry,
+		finishedItems: execution.items.filter((item) => item.done).map((item) => item.id),
+	});
 	const parts: string[] = [];
 	if (event.customInstructions?.trim()) {
-		parts.push(`## Compact Instructions
-${compactText(event.customInstructions, 1000)}`);
+		parts.push(`## Compact Instructions\n${compactText(event.customInstructions, 1000)}`);
 	}
-	parts.push(`## Plan Before This Run
-- Request: ${compactText(run?.request_text ?? execution.planPath, 280)}
-- Plan file: \`${execution.planPath}\``);
+	parts.push(`## Plan Before This Run\n- Request: ${compactText(run?.request_text ?? execution.planPath, 280)}\n- Plan file: \`${execution.planPath}\``);
 	if (event.preparation.previousSummary?.trim()) {
-		parts.push(`## Previous Compact Summary
-${event.preparation.previousSummary.trim()}`);
+		parts.push(`## Previous Compact Summary\n${event.preparation.previousSummary.trim()}`);
 	}
-	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." : ""}`);
+	parts.push(`## Implementation Items\n${plan?.slices.length ? (buildImplementationSections(plan).join("\\n\\n") || "- (no I transcript captured)") : "- Legacy snapshot: current I is inferred from the execution frontier."}`);
+	parts.push(`## Finished VC Items\n${sections.length ? sections.join("\\n\\n") : "- (none yet)"}`);
+	parts.push(`## Current I\n- \`${execution.currentI ?? plan?.currentI ?? "unknown"}\`\n- Recent legal suffix begins at \`${firstKeptEntryId}\`.`);
+	parts.push(`## Read Records\n${readRecords.length ? readRecords.map((record) => formatReadRecord(record)).join("\\n") : "- (none)"}`);
+	parts.push(`## Compaction Boundary\n- firstKeptEntryId: \`${firstKeptEntryId}\`\n- currentI: \`${execution.currentI ?? plan?.currentI ?? "unknown"}\`\n- tokensBefore: ${metrics.tokensBefore}\n- estimatedAfterTokens: ${metrics.estimatedAfterTokens ?? "unknown"}\n- targetRatio: ${metrics.targetRatio}\n- targetMet: ${metrics.targetMet}\n- hardFloorReason: ${metrics.hardFloorReason ?? "none"}`);
+	parts.push(`## Current Work\n- Raw tail preserved from \`${firstKeptEntryId}\` onward.${event.preparation.isSplitTurn ? "\\n- Split-turn prefix remains in the kept tail." : ""}`);
+	return { parts, details };
+}
+
+export function buildExecutionCompactionResult(event: SessionBeforeCompactEvent, ctx: ExtensionContext): CompactionResult | null {
+	if (!execution) return null;
+	const branchEntries = event.branchEntries as unknown as CompactionEntryLike[];
+	const hasIState = (execution.implItems?.length ?? 0) > 0;
+	const plan = hasIState ? buildExecutionIPlan(event, ctx) : null;
+	const firstKeptEntryId = plan?.firstKeptEntryId
+		?? findExecutionCompactionCutEntryId(event.branchEntries as CompactBranchEntry[], event.preparation.firstKeptEntryId);
+	const boundaryIndex = event.branchEntries.findIndex((entry) => entry.id === firstKeptEntryId);
+	const { parts, details } = executionSummaryParts(event, ctx, firstKeptEntryId, boundaryIndex, plan);
 	return {
-		summary: parts.join("\n\n"),
+		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),
-		},
+		estimatedTokensAfter: plan?.metrics.estimatedAfterTokens ?? undefined,
+		details,
 	};
 }
 
-export function handleExecutionBeforeCompact(pi: ExtensionAPI, ctx: ExtensionContext, event: SessionBeforeCompactEvent): SessionBeforeCompactResult | undefined {
+function assistantResponseText(response: { content?: Array<{ type?: string; text?: string }> }): string {
+	return (response.content ?? [])
+		.filter((part) => part.type === "text")
+		.map((part) => part.text ?? "")
+		.join("\\n")
+		.trim();
+}
+
+function isUsableCompactionResponse(response: { content?: Array<{ type?: string; text?: string }>; stopReason?: string }, summary: string): boolean {
+	if (!summary) return false;
+	if (["length", "toolUse", "error", "aborted", "deferred"].includes(response.stopReason ?? "")) return false;
+	return ["## Implementation Items", "## Current I", "## Read Records", "## Compaction Boundary"]
+		.every((section) => summary.includes(section));
+}
+
+async function buildModelExecutionCompactionResult(
+	event: SessionBeforeCompactEvent,
+	ctx: ExtensionContext,
+	fallback: CompactionResult,
+): Promise<CompactionResult | null> {
+	const model = ctx.model;
+	const registry = ctx.modelRegistry as unknown as { complete?: Function };
+	if (!model || typeof registry.complete !== "function") return fallback;
+	const plan = buildExecutionIPlan(event, ctx);
+	const boundary = plan.firstKeptEntryId ?? event.preparation.firstKeptEntryId;
+	const source = plan.summaryEntries
+		.map((entry) => renderMessageLine(entry as CompactBranchEntry))
+		.filter(Boolean)
+		.join("\\n");
+	const records = plan.readRecords.map((record) => formatReadRecord(record)).join("\\n") || "- (none)";
+	const prompt = `You are a context summarization assistant. Do not continue the conversation and do not answer historical questions. Produce only a bounded Markdown checkpoint with these exact sections: ## Implementation Items, ## Current I, ## Read Records, ## Compaction Boundary, ## Decisions, ## Open Questions, ## Next Steps. Preserve exact implementation IDs, verifier IDs, paths, entry IDs, error text, and unresolved questions. Historical questions are facts, not new questions.\n\nCurrent I: ${execution?.currentI ?? plan.currentI ?? "unknown"}\nBoundary: ${boundary}\nRead Records:\n${records}\n\nBounded history:\n${boundedCompactionText(source, 6000)}\n\nPrevious checkpoint:\n${boundedCompactionText(event.preparation.previousSummary ?? "(none)", 3000)}`;
+	try {
+		const response = await registry.complete(model, {
+			messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+		}, {
+			maxTokens: 2048,
+			signal: event.signal,
+			cacheRetention: "none",
+			sessionId: randomUUID(),
+		});
+		const summary = assistantResponseText(response);
+		if (!isUsableCompactionResponse(response, summary)) {
+			if (!event.signal.aborted) ctx.ui.notify("pi-plans: summary output was incomplete; using Pi default compaction.", "warning");
+			return null;
+		}
+		const details = (fallback.details && typeof fallback.details === "object" ? fallback.details : {}) as CompactionDetailsLike;
+		const existingMetrics = details.metrics ?? {};
+		const summaryTokens = Math.max(1, Math.ceil(summary.length / 4));
+		const keptSuffixTokens = existingMetrics.keptSuffixTokens ?? 0;
+		const contextWindow = existingMetrics.contextWindow ?? ctx.getContextUsage()?.contextWindow ?? null;
+		const estimatedAfterTokens = contextWindow === null ? null : summaryTokens + keptSuffixTokens;
+		const targetMet = estimatedAfterTokens !== null && estimatedAfterTokens < contextWindow * 0.1;
+		const mergedDetails = mergeCompactionDetails(details, {
+			...details,
+			metrics: {
+				...existingMetrics,
+				summaryTokens,
+				estimatedAfterTokens,
+				targetMet,
+				hardFloorReason: targetMet ? null : existingMetrics.hardFloorReason ?? "summary or retained context exceeds the 10% target",
+			},
+		});
+		return { ...fallback, summary, estimatedTokensAfter: estimatedAfterTokens ?? undefined, usage: response.usage, details: mergedDetails };
+	} catch (error) {
+		if (!event.signal.aborted) ctx.ui.notify(`pi-plans: summary model failed; using Pi default compaction (${String(error)}).`, "warning");
+		return null;
+	}
+}
+
+function notifyHardFloor(ctx: ExtensionContext, compaction: CompactionResult): void {
+	const metrics = (compaction.details as CompactionDetailsLike | undefined)?.metrics;
+	if (!metrics || metrics.targetMet !== false) return;
+	ctx.ui.notify(
+		`pi-plans: compaction target <10% is unreachable; retaining the legal floor (${metrics.hardFloorReason ?? "unknown reason"}).`,
+		"warning",
+	);
+}
+
+export function handleExecutionBeforeCompact(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	event: SessionBeforeCompactEvent,
+): SessionBeforeCompactResult | Promise<SessionBeforeCompactResult | undefined> | undefined {
 	if (!execution) return undefined;
-	const compaction = buildExecutionCompactionResult(event, ctx);
-	if (!compaction) return undefined;
-	requestExecutionFlush(pi, ctx);
-	return { compaction };
+	let fallback: CompactionResult | null;
+	try {
+		fallback = buildExecutionCompactionResult(event, ctx);
+	} catch (error) {
+		const state = executionCompactionState(ctx);
+		if (state) state.inFlight = false;
+		ctx.ui.notify(`pi-plans: compaction preparation failed; using Pi default compaction (${String(error)}).`, "warning");
+		return undefined;
+	}
+	if (!fallback) return undefined;
+	notifyHardFloor(ctx, fallback);
+	const registry = ctx.modelRegistry as unknown as { complete?: Function };
+	if (!ctx.model || typeof registry.complete !== "function") {
+		requestExecutionFlush(pi, ctx);
+		return { compaction: fallback };
+	}
+	return buildModelExecutionCompactionResult(event, ctx, fallback).then((compaction) => {
+		if (!compaction) return undefined;
+		requestExecutionFlush(pi, ctx);
+		return { compaction };
+	});
 }
 
 export function handleExecutionCompact(pi: ExtensionAPI, ctx: ExtensionContext, event: SessionCompactEvent): void {
 	if (!execution) return;
+	const state = ensureExecutionCompactionState(ctx);
+	state.inFlight = false;
+	state.lastAttemptReason = event.reason;
+	state.cooldownActive = true;
+	state.rearmPending = false;
+	state.lastSuccessfulAt = utcNow();
+	state.lastSuccessfulUsagePercent = ctx.getContextUsage()?.percent ?? state.lastSuccessfulUsagePercent;
 	if (!event.willRetry) {
+		state.resumeGuard = true;
 		pi.sendMessage(
 			{
 				customType: EXECUTION_RESUME_CUSTOM_TYPE,
-				content: "Continue execution.",
+				content: EXECUTION_COMPACTION_RESUME_MESSAGE,
 				display: false,
 			},
 			{ triggerTurn: true },
 		);
+	} else {
+		state.resumeGuard = false;
 	}
 	requestExecutionFlush(pi, ctx);
 	updateStatusWidget(ctx);
@@ -623,6 +763,19 @@ export function handleExecutionCompact(pi: ExtensionAPI, ctx: ExtensionContext,
 
 export function handleExecutionCompactFailed(pi: ExtensionAPI, ctx: ExtensionContext, event: SessionCompactFailedEvent): void {
 	if (!execution) return;
+	const state = executionCompactionState(ctx);
+	const expectedThresholdCancel = event.reason === "threshold" && event.aborted && !state?.inFlight;
+	if (expectedThresholdCancel) {
+		if (state) state.lastAttemptReason = event.reason;
+		return;
+	}
+	if (state) {
+		state.inFlight = false;
+		state.resumeGuard = false;
+		state.cooldownActive = false;
+		state.rearmPending = false;
+		state.lastAttemptReason = event.reason;
+	}
 	ctx.ui.notify(
 		`pi-plans: compaction failed (${event.reason}); execution remains active and will wait for the next eligible turn.`,
 		"warning",
@@ -673,9 +826,22 @@ function isPlanningInternalCustomType(customType?: string): boolean {
 		|| customType === PLANNING_RUN_START_CUSTOM_TYPE
 		|| customType === PLANNING_PLAN_WRITTEN_CUSTOM_TYPE
 		|| customType === PLANNING_RESUME_CUSTOM_TYPE
+		|| customType === AUTOCOMPLETE_ENTRY
 	);
 }
 
+function summarizePlanningEntryText(entry: PlanningBranchEntry): string {
+	return (entry.message?.content ?? [])
+		.filter((part) => part.type === "text")
+		.map((part) => part.text ?? "")
+		.join("\n")
+		.trim();
+}
+
+function summarizePlanningEntryLine(entry: PlanningBranchEntry): string | null {
+	return summarizePlanningMessageLine(entry);
+}
+
 function summarizePlanningMessageLine(entry: PlanningBranchEntry): string | null {
 	if (!entry.message) return null;
 	const text = (entry.message.content ?? [])
@@ -743,12 +909,41 @@ function resolvePlanningCompactionContext(workdir: string): { runId: string; art
 	return { runId: run.run_id, artifactDir: run.artifact_dir };
 }
 
+function planningCurrentIUsage(ctx: ExtensionContext): { tokens: number; contextWindow: number; eligible?: boolean } | null {
+	const usage = ctx.getContextUsage();
+	if (!usage || typeof usage.contextWindow !== "number" || usage.contextWindow <= 0) return null;
+	const manager = ctx.sessionManager as unknown as { getBranch?: () => CompactionEntryLike[] };
+	if (typeof manager.getBranch === "function") {
+		try {
+			const entries = manager.getBranch();
+			const currentI = entries.flatMap((entry) => entryCurrentIMarkers(entry)).at(-1)
+				?? entries.map((entry) => compactionCurrentI(entry)).filter((id): id is string => !!id).at(-1);
+			if (currentI) {
+				const plan = planIAwareCompaction({
+					entries,
+					currentI,
+					contextWindow: usage.contextWindow,
+					tokensBefore: usage.tokens ?? undefined,
+				});
+				return {
+					tokens: plan.currentITokens,
+					contextWindow: usage.contextWindow,
+					eligible: plan.firstKeptEntryIndex !== null && plan.firstKeptEntryIndex > 0,
+				};
+			}
+		} catch {
+			// Session projection is unavailable during startup in some hosts.
+		}
+	}
+	if (typeof usage.tokens !== "number") return null;
+	return { tokens: usage.tokens, contextWindow: usage.contextWindow };
+}
 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 currentUsage = planningCurrentIUsage(ctx);
+	if (!currentUsage || currentUsage.eligible === false || !currentIExceedsTrigger(currentUsage.tokens, currentUsage.contextWindow)) return false;
 	const session = ctx.sessionManager as unknown as { __planningCompaction?: PlanningCompactionState };
 	const state = session.__planningCompaction;
 	if (!state) return true;
@@ -786,7 +981,12 @@ export function requestPlanningCompaction(ctx: ExtensionContext): void {
 	if (state.inFlight || state.resumeGuard) return;
 	state.inFlight = true;
 	state.lastAttemptReason = "threshold";
-	ctx.compact({ customInstructions: "pi-plans planning auto compact" });
+	try {
+		ctx.compact({ customInstructions: "pi-plans planning auto compact" });
+	} catch (error) {
+		state.inFlight = false;
+		ctx.ui.notify(`pi-plans: could not request planning compaction (${String(error)}).`, "warning");
+	}
 }
 
 export function buildPlanningCompactionResult(event: SessionBeforeCompactEvent, ctx: ExtensionContext): CompactionResult | null {
@@ -794,8 +994,26 @@ export function buildPlanningCompactionResult(event: SessionBeforeCompactEvent,
 	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 legacyCut = findPlanningCutEntryId(branchEntries, event.preparation.firstKeptEntryId);
+	const markerIds = branchEntries.flatMap((entry) => scanCurrentIMarkers(summarizePlanningEntryText(entry)));
+	const currentI = markerIds.at(-1)?.id
+		?? branchEntries.map((entry) => compactionCurrentI(entry)).filter((id): id is string => !!id).at(-1)
+		?? null;
+	const iPlan = currentI
+		? planIAwareCompaction({
+			entries: branchEntries as unknown as CompactionEntryLike[],
+			currentI,
+			contextWindow: eventPreparationUsage(event, ctx).contextWindow,
+			tokensBefore: event.preparation.tokensBefore,
+			fallbackFirstKeptEntryId: event.preparation.firstKeptEntryId,
+			maxFirstKeptEntryIndex: splitTurnBoundaryIndex(event),
+		})
+		: null;
+	const firstKeptEntryId = iPlan?.firstKeptEntryId ?? legacyCut.id;
+	const qaSection = legacyCut.hasMarker ? buildPlanningQASection(legacyCut.qaWindowEntries) : null;
+	const boundaryIndex = event.branchEntries.findIndex((entry) => entry.id === firstKeptEntryId);
+	const summaryEntries = boundaryIndex >= 0 ? branchEntries.slice(0, boundaryIndex) : branchEntries;
+	const readRecords = iPlan?.readRecords ?? extractReadRecords(summaryEntries as unknown as CompactionEntryLike[]);
 	const parts: string[] = [];
 	if (event.customInstructions?.trim()) {
 		parts.push(`## Compact Instructions
@@ -818,22 +1036,40 @@ ${compactText(planningCtx.runId, 80)} — keep current planning progress.`);
 - Current planning question or open decision.
 
 ### Blocked
-- ${hasMarker ? "None" : "Planning cut-point marker missing; falling back to default."}`);
+- ${legacyCut.hasMarker ? "None" : "Planning cut-point marker missing; falling back to default."}`);
+	if (iPlan) {
+		const iSections = iPlan.slices
+			.map((slice) => {
+				const lines = slice.entries.filter((entry) => iPlan.summaryEntries.includes(entry)).map((entry) => summarizePlanningEntryLine(entry)).filter(Boolean);
+				return slice.id && lines.length ? `### ${slice.current ? "Current I" : "Implementation I"} \`${slice.id}\`\n${lines.join("\\n")}` : "";
+			})
+			.filter(Boolean);
+		parts.push(`## Current I\n- \`${currentI}\`\n${iSections.join("\\n\\n") || "- Current I transcript is in the retained suffix."}`);
+		parts.push(`## Read Records\n${readRecords.length ? readRecords.map((record) => formatReadRecord(record)).join("\\n") : "- (none)"}`);
+		parts.push(`## Compaction Boundary\n- firstKeptEntryId: \`${firstKeptEntryId}\`\n- currentI: \`${currentI}\`\n- targetMet: ${iPlan.metrics.targetMet}\n- hardFloorReason: ${iPlan.metrics.hardFloorReason ?? "none"}`);
+	}
 	if (previousSummary) {
-		parts.push(`## Previous Compact Summary
-${previousSummary}`);
+		parts.push(`## Previous Compact Summary\n${previousSummary}`);
 	}
 	parts.push(`## Next Steps
 - Resume the active planning turn from the raw tail.`);
+	const priorDetails = previousCompactionDetails(branchEntries as unknown as CompactionEntryLike[]);
+	const details = mergeCompactionDetails(priorDetails, {
+		kind: "pi-plans-planning-compaction",
+		version: 1,
+		currentI,
+		iSections: iPlan?.slices.map((slice) => ({ id: slice.id, entryIds: slice.entries.map((entry) => entry.id).filter((id): id is string => !!id) })),
+		readRecords,
+		metrics: iPlan?.metrics,
+		reason: event.reason,
+		hasMarker: legacyCut.hasMarker,
+	});
 	return {
 		summary: parts.join("\n\n"),
 		firstKeptEntryId,
 		tokensBefore: event.preparation.tokensBefore,
-		details: {
-			kind: "pi-plans-planning-compaction",
-			reason: event.reason,
-			hasMarker,
-		},
+		estimatedTokensAfter: iPlan?.metrics.estimatedAfterTokens ?? undefined,
+		details,
 	};
 }
 
@@ -864,11 +1100,19 @@ export function handlePlanningBeforeCompact(
 	if (percent !== null && percent < 85) {
 		state.cooldownActive = false;
 	}
-	const compaction = buildPlanningCompactionResult(event, ctx);
+	let compaction: CompactionResult | null;
+	try {
+		compaction = buildPlanningCompactionResult(event, ctx);
+	} catch (error) {
+		state.inFlight = false;
+		ctx.ui.notify(`pi-plans: planning compaction preparation failed; using Pi default compaction (${String(error)}).`, "warning");
+		return undefined;
+	}
 	if (!compaction) {
 		state.inFlight = false;
 		return undefined;
 	}
+	notifyHardFloor(ctx, compaction);
 	return { compaction };
 }
 
@@ -921,41 +1165,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,19 +1225,28 @@ 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" });
 	pi.sendMessage(
@@ -1050,15 +1274,19 @@ export function executionContextMessage(): string | null {
 	const remaining = execution.items.filter((item) => !item.done);
 	const list =
 		remaining.map((item) => `- \`${item.id}\` ${item.text}`).join("\n") || "(none — report completion now)";
+	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}
 
 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 +1309,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 +1322,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 +1342,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 +1360,7 @@ export async function restoreFromSession(pi: ExtensionAPI, ctx: ExtensionContext
 				.join("\n");
 			applyDoneMarkers(text);
 			applyImplMarkers(text);
+			applyCurrentIMarker(text);
 		}
 	}
 	if (execution) {
@@ -1145,6 +1370,5 @@ export async function restoreFromSession(pi: ExtensionAPI, ctx: ExtensionContext
 			await completeExecution(pi, ctx);
 		}
 	}
-	syncExecutionPanel(ctx);
 	updateStatusWidget(ctx);
 }