pi-plans 0.1.0 → 0.1.2

package/src/exec.ts

@@ -8,13 +8,23 @@
  */
 
 import * as fs from "node:fs";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type {
+	CompactionResult,
+	ExtensionAPI,
+	ExtensionContext,
+	SessionBeforeCompactEvent,
+	SessionBeforeCompactResult,
+	SessionCompactEvent,
+	SessionCompactFailedEvent,
+} from "@earendil-works/pi-coding-agent";
 import {
 	attachPanelBaseline,
 	clearExecutionPanel,
 	completeCompletedItems,
+	computeExecutionProgress,
 	createExecutionPanelState,
 	executionPanelFromEntryData,
+	formatExecutionStatusLine,
 	refreshExecutionPanel,
 	snapshotPanelState,
 	toggleExpanded,
@@ -22,12 +32,23 @@ import {
 	type ExecutionPanelState,
 	type ItemDiffSummary,
 } from "./execution-panel.ts";
-import { readActive, setRunStatus, utcNow } from "./state.ts";
-import { scanDoneMarkers, type CheckItem } from "./plan.ts";
+import { getRun, readActive, setRunStatus, utcNow, type ExecutionConfig } from "./state.ts";
+import {
+	latestPlanVersion,
+	scanDoneMarkers,
+	scanImplMarkers,
+	type CheckItem,
+	type ImplItem,
+	type ImplMarkerState,
+} from "./plan.ts";
 
 export interface ExecState extends ExecutionPanelExecutionLike {
 	startedAt: string;
 	panel?: ExecutionPanelState;
+	usage: { inToks: number; outToks: number };
+	modelState?: ExecutionModelState;
+	implItems?: ImplItem[];
+	implStatus?: Record<string, ImplMarkerState>;
 }
 
 let execution: ExecState | null = null;
@@ -42,30 +63,258 @@ export function consumePendingPanelSync(): boolean {
 	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).
+let pendingExecutionFlush = false;
+
+export function consumePendingExecutionFlush(): boolean {
+	const pending = pendingExecutionFlush;
+	pendingExecutionFlush = false;
+	return pending;
+}
+
+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.
+	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;
+	pendingExecutionFlush = false;
+	persist(pi);
+	syncExecutionPanel(ctx);
+	updateStatusWidget(ctx);
+}
+
 export function getExecution(): ExecState | null {
 	return execution;
 }
 
-export function executionProgress(): { done: number; total: number } | null {
-	if (!execution) return null;
+const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+const CURRENT_SESSION_MODEL_CHOICE = "Inherit current session model";
+
+export interface ExecutionModelState {
+	planningSelector: string | null;
+	executionSelector: string;
+}
+
+export interface ModelSelection {
+	provider: string;
+	modelId: string;
+	thinkingLevel: string | null;
+	selector: string;
+	model: any;
+}
+
+function buildModelSelector(provider: string, modelId: string, thinkingLevel?: string | null): string {
+	return thinkingLevel ? `${provider}/${modelId}:${thinkingLevel}` : `${provider}/${modelId}`;
+}
+
+export function currentModelSelection(ctx: Pick<ExtensionContext, "model" | "thinkingLevel">): ModelSelection | null {
+	if (!ctx.model) return null;
 	return {
-		done: execution.items.filter((item) => item.done).length,
-		total: execution.items.length,
+		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,
 	};
 }
 
+export function snapshotCurrentModelSelector(ctx: Pick<ExtensionContext, "model" | "thinkingLevel">): string | null {
+	return currentModelSelection(ctx)?.selector ?? null;
+}
+
+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);
+	}
+	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);
+		}
+		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 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;
+	}
+
+	if (configuredSelector) {
+		const resolved = resolveModelSelection(ctx, configuredSelector);
+		if (resolved) return resolved;
+	} else {
+		return current;
+	}
+
+	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;
+}
+
+export function executionProgress(): { done: number; total: number } | null {
+	if (!execution) return null;
+	return computeExecutionProgress(execution);
+}
+
 export function updateStatusWidget(ctx: ExtensionContext): void {
-	const progress = executionProgress();
-	if (progress) {
-		// The below-editor panel owns the in-execution progress display; keep the
-		// status bar free of a duplicate count (and clear stale ones from before).
-		ctx.ui.setStatus("pi-plans", undefined);
+	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;
 	}
 	const active = readActive(ctx.cwd);
 	if (active) {
-		ctx.ui.setStatus("pi-plans", ctx.ui.theme.fg("warning", `⏸ plans: ${active.run_id}`));
-		return;
+		// Idle indicator depends on the run's lifecycle, not just its existence:
+		// done reads as finished, abandoned as closed, stopped/accepted as paused.
+		const status = getRun(ctx.cwd, active.run_id)?.status;
+		if (status === "done") {
+			ctx.ui.setStatus("pi-plans", ctx.ui.theme.fg("success", `🎯 plans: ${active.run_id} (done)`));
+			return;
+		}
+		if (status === "abandoned") {
+			ctx.ui.setStatus("pi-plans", ctx.ui.theme.fg("error", `🚫 plans: ${active.run_id}`));
+			return;
+		}
+		if (status === "stopped") {
+			ctx.ui.setStatus("pi-plans", ctx.ui.theme.fg("warning", `⛔ plans: ${active.run_id}`));
+			return;
+		}
+		if (status === "accepted") {
+			ctx.ui.setStatus("pi-plans", ctx.ui.theme.fg("warning", `⌛ plans: ${active.run_id}`));
+			return;
+		}
+		if (status === "planning") {
+			// Planning phase: 💬 while still in Q&A, 📝 once a PLAN draft exists
+			// — kept until execution starts (then ⌛ takes over).
+			const emoji = latestPlanVersion(active.artifact_dir) ? "📝" : "💬";
+			ctx.ui.setStatus("pi-plans", ctx.ui.theme.fg("muted", `${emoji} plans: ${active.run_id}`));
+			return;
+		}
+		// unknown status: no indicator.
 	}
 	ctx.ui.setStatus("pi-plans", undefined);
 }
@@ -76,7 +325,9 @@ function persist(pi: ExtensionAPI): void {
 		planPath: execution.planPath,
 		items: execution.items,
 		startedAt: execution.startedAt,
+		usage: execution.usage,
 		panel: snapshotPanelState(execution),
+		implItems: execution.implItems,
 	});
 }
 
@@ -88,16 +339,22 @@ export function syncExecutionPanel(ctx: ExtensionContext): void {
 	refreshExecutionPanel(ctx, execution);
 }
 
-export function startExecution(
+export async function startExecution(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
 	planPath: string,
 	items: CheckItem[],
-): void {
-	execution = { planPath, items, startedAt: utcNow(), panel: createExecutionPanelState() };
+	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
+	pendingExecutionFlush = false; // fresh run: no inherited flush debt
 	persist(pi);
+	if (modelState) {
+		await ensureExecutionModelActive(pi, ctx);
+	}
 	const active = readActive(ctx.cwd);
 	if (active) {
 		try {
@@ -109,7 +366,7 @@ export function startExecution(
 	pi.sendMessage(
 		{
 			customType: "pi-plans-exec-start",
-			content: `**pi-plans: executing** \`${planPath}\` — ${items.length} verifier item(s). Progress appears below the editor; mark verified items with \`[DONE:VC-xxx]\`.`,
+			content: `**pi-plans: executing** \`${planPath}\` — ${items.length} verifier item(s). Progress appears in the bottom status bar; mark verified items with \`[DONE:VC-xxx]\`.`,
 			display: true,
 		},
 		{ triggerTurn: false },
@@ -148,16 +405,556 @@ export function recordTouchedPaths(_workdir: string, paths: string[]): void {
 	panel.touchedPaths = [...merged];
 }
 
-export function recordExecutionCompletion(pi: ExtensionAPI, ctx: ExtensionContext, completedIds: string[]): ItemDiffSummary | null {
+/** Record one assistant turn: accumulate usage and mark any completed items. */
+export function recordExecutionTurn(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	completedIds: string[],
+	usage?: { input: number; output: number },
+): ItemDiffSummary | null {
 	if (!execution) return null;
+	if (usage) {
+		execution.usage.inToks += usage.input;
+		execution.usage.outToks += usage.output;
+	}
 	const summary = completeCompletedItems(execution, ctx.cwd, completedIds);
-	persist(pi);
-	syncExecutionPanel(ctx);
+	requestExecutionFlush(pi, ctx);
 	return summary;
 }
 
-export function stopExecution(pi: ExtensionAPI, ctx: ExtensionContext, reason: string): void {
+export function registerExecutionTurnHandlers(
+	pi: ExtensionAPI,
+	onTurnEnd?: (ctx: ExtensionContext) => Promise<void> | void,
+): void {
+	// The turn_end projection does not carry usage; message_end delivers the
+	// full assistant message, so cache it here and consume it per turn.
+	let lastAssistantUsage: { input: number; output: number } | null = null;
+	pi.on("message_end", async (event) => {
+		const message = event.message as { role?: string; usage?: { input?: number; output?: number } };
+		if (message?.role === "assistant" && message.usage) {
+			lastAssistantUsage = { input: message.usage.input ?? 0, output: message.usage.output ?? 0 };
+		}
+	});
+
+	pi.on("turn_end", async (event, ctx) => {
+		const message = event.message as { role?: string; content?: Array<{ type: string; text?: string }> };
+		if (!message || message.role !== "assistant") {
+			updateStatusWidget(ctx);
+			return;
+		}
+		const text = (message.content ?? [])
+			.filter((part) => part.type === "text")
+			.map((part) => part.text ?? "")
+			.join("\n");
+		const changedIds = applyDoneMarkers(text);
+		const changedImpls = applyImplMarkers(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) {
+			// Attribute this turn's usage now; `[DONE]` markers still only mark completion.
+			recordExecutionTurn(pi, ctx, changedIds, usage);
+		}
+		if (getExecution() && isExecutionComplete()) {
+			await completeExecution(pi, ctx);
+		}
+		await onTurnEnd?.(ctx);
+	});
+}
+
+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 messageText(message: CompactMessage | undefined): string {
+	if (!message) return "";
+	return (message.content ?? [])
+		.filter((part) => part.type === "text")
+		.map((part) => part.text ?? "")
+		.join("\n")
+		.trim();
+}
+
+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 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 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;
+}
+
+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;
+		}
+	}
+	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)}`);
+	}
+	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()}`);
+	}
+	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),
+		},
+	};
+}
+
+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 };
+}
+
+export function handleExecutionCompact(pi: ExtensionAPI, ctx: ExtensionContext, event: SessionCompactEvent): void {
+	if (!execution) return;
+	if (!event.willRetry) {
+		pi.sendMessage(
+			{
+				customType: EXECUTION_RESUME_CUSTOM_TYPE,
+				content: "Continue execution.",
+				display: false,
+			},
+			{ triggerTurn: true },
+		);
+	}
+	requestExecutionFlush(pi, ctx);
+	updateStatusWidget(ctx);
+}
+
+export function handleExecutionCompactFailed(pi: ExtensionAPI, ctx: ExtensionContext, event: SessionCompactFailedEvent): void {
+	if (!execution) return;
+	ctx.ui.notify(
+		`pi-plans: compaction failed (${event.reason}); execution remains active and will wait for the next eligible turn.`,
+		"warning",
+	);
+	requestExecutionFlush(pi, ctx);
+}
+
+export function filterExecutionResumeMessages<T extends { customType?: string }>(messages: T[]): T[] {
+	return messages.filter((message) => message.customType !== EXECUTION_RESUME_CUSTOM_TYPE);
+}
+
+// ---------------------------------------------------------------------------
+// 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.
+// ---------------------------------------------------------------------------
+
+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 {
+	inFlight: boolean;
+	resumeGuard: boolean;
+	cooldownActive: boolean;
+	lastAttemptReason: "manual" | "threshold" | "overflow" | null;
+	lastSuccessfulUsagePercent: number | null;
+	lastSuccessfulAt: string | null;
+}
+
+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 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 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}`;
+}
+
+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 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);
+	}
+	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 };
+}
+
+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 consumePlanningCompactionResumeGuard(ctx: ExtensionContext): boolean {
+	const session = ctx.sessionManager as unknown as { __planningCompaction?: PlanningCompactionState };
+	if (!session.__planningCompaction?.resumeGuard) return false;
+	session.__planningCompaction.resumeGuard = false;
+	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 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 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,
+		},
+	};
+}
+
+export function handlePlanningBeforeCompact(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	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 };
+	}
+	state.inFlight = true;
+	state.lastAttemptReason = event.reason;
+	if (percent !== null && percent < 85) {
+		state.cooldownActive = false;
+	}
+	const compaction = buildPlanningCompactionResult(event, ctx);
+	if (!compaction) {
+		state.inFlight = false;
+		return undefined;
+	}
+	return { compaction };
+}
+
+export function handlePlanningCompact(pi: ExtensionAPI, ctx: ExtensionContext, event: SessionCompactEvent): void {
+	if (getExecution()) return;
+	const session = ctx.sessionManager as unknown as { __planningCompaction?: PlanningCompactionState };
+	const state = session.__planningCompaction;
+	if (!state) return;
+	state.inFlight = false;
+	state.lastAttemptReason = event.reason;
+	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;
+	}
+}
+
+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) {
+		state.lastAttemptReason = event.reason;
+		return;
+	}
+	state.inFlight = false;
+	state.resumeGuard = false;
+	state.cooldownActive = false;
+	state.lastAttemptReason = event.reason;
+	ctx.ui.notify(
+		`pi-plans: planning compaction failed (${event.reason}); will try again on the next eligible turn.`,
+		"warning",
+	);
+}
+
+export function filterPlanningResumeMessages<T extends { customType?: string }>(messages: T[]): T[] {
+	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);
+	// 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 });
@@ -194,12 +991,35 @@ export function applyDoneMarkers(text: string): string[] {
 	return changed;
 }
 
+/**
+ * Apply [I-xxx:implemented|validating] markers from an assistant message.
+ * Unknown I-ids are silently ignored; later markers overwrite earlier ones.
+ * Returns the ids whose state actually changed.
+ */
+export function applyImplMarkers(text: string): string[] {
+	if (!execution?.implItems?.length) return [];
+	const known = new Set(execution.implItems.map((impl) => impl.id));
+	execution.implStatus ??= {};
+	const changed: string[] = [];
+	for (const marker of scanImplMarkers(text)) {
+		if (!known.has(marker.id)) continue;
+		const previous = execution.implStatus[marker.id];
+		execution.implStatus[marker.id] = marker.state;
+		if (previous !== marker.state) changed.push(marker.id);
+	}
+	return changed;
+}
+
 export function isExecutionComplete(): boolean {
 	return execution !== null && execution.items.length > 0 && execution.items.every((item) => item.done);
 }
 
-export function completeExecution(pi: ExtensionAPI, ctx: ExtensionContext): void {
+export async function completeExecution(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
 	if (!execution) return;
+	await restorePlanningModel(pi, 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);
@@ -237,8 +1057,11 @@ Remaining verifier items:
 ${list}
 
 Execution rules:
-- Implement implementation items in dependency order.
-- Ponytail discipline: for each item, take the laziest rung that holds (does it need to exist; already in this codebase; stdlib; native platform feature; already-installed dependency; one line). Mark deliberate simplifications with \`# ponytail: <ceiling>, <upgrade path>\`.
+- 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.
+- 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.
 - MINIMUM tests: trivial one-liners get no test; non-trivial logic gets exactly one minimal check; reuse the repo's test runner when one exists; when unsure, skip and emit \`[test skipped: <name>, add when <trigger>]\`.
 - After verifying an item's pass condition with its stated evidence, include \`[DONE:VC-xxx]\` in your reply.
 - When every item is done, report a completion summary.`;
@@ -256,7 +1079,8 @@ interface SessionEntry {
  * pi-plans-exec snapshot, then re-scans assistant messages after it for
  * [DONE:VC-xxx] markers so progress survives restarts.
  */
-export function restoreFromSession(pi: ExtensionAPI, ctx: ExtensionContext, entries: SessionEntry[]): void {
+export async function restoreFromSession(pi: ExtensionAPI, ctx: ExtensionContext, entries: SessionEntry[]): Promise<void> {
+	pendingExecutionFlush = false; // no flush debt survives a restart
 	let snapshotIndex = -1;
 	let snapshot: ExecState | null = null;
 	for (let i = entries.length - 1; i >= 0; i--) {
@@ -288,9 +1112,14 @@ export function restoreFromSession(pi: ExtensionAPI, ctx: ExtensionContext, entr
 		return;
 	}
 	execution = {
-		...snapshot,
+		planPath: snapshot.planPath,
 		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 ?? {}) },
 	};
 	for (let i = snapshotIndex + 1; i < entries.length; i++) {
 		const entry = entries[i];
@@ -306,11 +1135,15 @@ export function restoreFromSession(pi: ExtensionAPI, ctx: ExtensionContext, entr
 				.map((part) => part.text ?? "")
 				.join("\n");
 			applyDoneMarkers(text);
+			applyImplMarkers(text);
 		}
 	}
 	if (execution) {
 		persist(pi); // refresh snapshot so the next resume has less to rescan
-		if (isExecutionComplete()) completeExecution(pi, ctx);
+		if (isExecutionComplete()) {
+			// Completed during the rescan: restore the planning model on the way out.
+			await completeExecution(pi, ctx);
+		}
 	}
 	syncExecutionPanel(ctx);
 	updateStatusWidget(ctx);