pi-plans 0.1.2 → 0.2.0

package/src/plan.ts

@@ -35,6 +35,43 @@ export function scanDoneMarkers(text: string): string[] {
 	return [...text.matchAll(/\[DONE:(VC-\d+)\]/g)].map((match) => match[1]);
 }
 
+export interface CurrentIMarker {
+	id: string;
+}
+
+/** Extract current implementation-item anchors from an assistant message. */
+export function scanCurrentIMarkers(text: string): CurrentIMarker[] {
+	return [...text.matchAll(/\[(I-\d+):current\]/g)].map((match) => ({ id: match[1] }));
+}
+
+export const scanCurrentMarkers = scanCurrentIMarkers;
+
+/** Resolve the last known current-I marker, ignoring unknown ids. */
+export function resolveCurrentI(
+	implItems: ImplItem[],
+	markers: CurrentIMarker[] | string[],
+	fallback?: string,
+): string | undefined {
+	const known = new Set(implItems.map((item) => item.id));
+	let current: string | undefined;
+	for (const marker of markers) {
+		const id = typeof marker === "string" ? marker : marker.id;
+		if (known.has(id)) current = id;
+	}
+	return current ?? fallback;
+}
+
+/** Deterministic frontier used by snapshots written before currentI existed. */
+export function inferCurrentI(
+	implItems: ImplItem[] | undefined,
+	items: CheckItem[],
+	implStatus: Record<string, ImplMarkerState> | undefined,
+): string | undefined {
+	if (!implItems?.length) return undefined;
+	const statuses = resolveImplStatuses(implItems, items, implStatus);
+	return implItems.find((item) => statuses[item.id] !== "vc-passed")?.id ?? implItems.at(-1)?.id;
+}
+
 export type ImplMarkerState = "implemented" | "validating";
 
 export interface ImplMarker {

package/src/query-hook.ts

@@ -0,0 +1,82 @@
+import type { ExtensionAPI, ExtensionContext, InputEvent } from "@earendil-works/pi-coding-agent";
+
+export const QUERY_INTERVIEW_MESSAGE_CUSTOM_TYPE = "pi-plans-query-interview";
+export const QUERY_INTERVIEW_MESSAGE =
+	"Before implementing a new user request, if any requirement, constraint, expected behavior, or acceptance criterion is unclear, interview the user with focused clarification questions and confirm the answers before making changes. If the request is clear, proceed directly with the implementation.";
+
+interface QueryHookState {
+	pendingQueries: number;
+}
+
+type QueryHookSession = { __piPlansQueryHook?: QueryHookState };
+
+function sessionCarrier(ctx: ExtensionContext): QueryHookSession | undefined {
+	return ctx.sessionManager as unknown as QueryHookSession | undefined;
+}
+
+function ensureState(ctx: ExtensionContext): QueryHookState | undefined {
+	const session = sessionCarrier(ctx);
+	if (!session) return undefined;
+	return (session.__piPlansQueryHook ??= { pendingQueries: 0 });
+}
+
+export function isOrdinaryExternalQuery(
+	input: Pick<InputEvent, "text" | "source" | "streamingBehavior">,
+): boolean {
+	const text = input.text.trim();
+	return (
+		(input.source === "interactive" || input.source === "rpc")
+		&& input.streamingBehavior === undefined
+		&& text.length > 0
+		&& !text.startsWith("/")
+	);
+}
+
+export function recordOrdinaryQuery(
+	ctx: ExtensionContext,
+	input: Pick<InputEvent, "text" | "source" | "streamingBehavior">,
+): boolean {
+	if (!isOrdinaryExternalQuery(input)) return false;
+	const state = ensureState(ctx);
+	if (!state) return false;
+	state.pendingQueries += 1;
+	return true;
+}
+
+export function consumeOrdinaryQuery(ctx: ExtensionContext): boolean {
+	const session = sessionCarrier(ctx);
+	const state = session?.__piPlansQueryHook;
+	if (!state || state.pendingQueries <= 0) return false;
+	state.pendingQueries -= 1;
+	if (state.pendingQueries === 0) delete session.__piPlansQueryHook;
+	return true;
+}
+
+export function resetOrdinaryQueryState(ctx: ExtensionContext): void {
+	const session = sessionCarrier(ctx);
+	if (session) delete session.__piPlansQueryHook;
+}
+
+export function registerQueryInterviewHooks(
+	pi: ExtensionAPI,
+	suppressForWorkflow: (ctx: ExtensionContext) => boolean,
+): void {
+	pi.on("input", async (event, ctx) => {
+		recordOrdinaryQuery(ctx, event);
+	});
+
+	pi.on("before_agent_start", async (_event, ctx) => {
+		if (!consumeOrdinaryQuery(ctx) || suppressForWorkflow(ctx)) return;
+		return {
+			message: {
+				customType: QUERY_INTERVIEW_MESSAGE_CUSTOM_TYPE,
+				content: QUERY_INTERVIEW_MESSAGE,
+				display: false,
+			},
+		};
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		resetOrdinaryQueryState(ctx);
+	});
+}

package/src/refine-ui-helpers.ts

@@ -0,0 +1,89 @@
+/**
+ * Lightweight, dependency-free replacements for the pi-tui text utilities used
+ * by the refine overlay. Keeping these local lets the overlay render correctly
+ * in contexts where the pi-tui module is not on the resolver path (notably the
+ * standalone `node:test` runs in this repository, since `@earendil-works/pi-tui`
+ * is a peer of `@earendil-works/pi-coding-agent` rather than a direct
+ * dependency of pi-plans).
+ */
+
+const ELLIPSIS = "…";
+
+export function visibleWidth(text: string): number {
+	if (!text) return 0;
+	let width = 0;
+	for (const segment of new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(text)) {
+		const cp = segment.segment.codePointAt(0) ?? 0;
+		if (cp < 0x20) continue;
+		if (cp === 0x09) { width += 3; continue; }
+		if (cp >= 0x1100 && cp <= 0x115f) { width += 2; continue; }
+		if (cp >= 0x2e80 && cp <= 0x9fff) { width += 2; continue; }
+		if (cp >= 0xac00 && cp <= 0xd7a3) { width += 2; continue; }
+		if (cp >= 0xff00 && cp <= 0xff60) { width += 2; continue; }
+		if (cp >= 0x1f300 && cp <= 0x1faff) { width += 2; continue; }
+		width += 1;
+	}
+	return width;
+}
+
+export function truncateToWidth(text: string, maxWidth: number, ellipsis = ELLIPSIS): string {
+	const measured = visibleWidth(text);
+	if (measured <= maxWidth) return text;
+	const ellipsisWidth = ellipsis ? visibleWidth(ellipsis) : 0;
+	const target = Math.max(0, maxWidth - ellipsisWidth);
+	let result = "";
+	let used = 0;
+	for (const segment of new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(text)) {
+		const w = visibleWidth(segment.segment);
+		if (used + w > target) break;
+		result += segment.segment;
+		used += w;
+	}
+	return ellipsis ? `${result}${ellipsis}` : result;
+}
+
+export function wrapTextWithAnsi(text: string, maxWidth: number): string[] {
+	if (maxWidth <= 0) return [text];
+	const normalized = text.replace(/\r\n/g, "\n");
+	const words = normalized.split(/(\s+)/);
+	const lines: string[] = [];
+	let current = "";
+	let currentWidth = 0;
+	for (const word of words) {
+		if (word === "") continue;
+		const wordWidth = visibleWidth(word);
+		if (wordWidth > maxWidth) {
+			// Hard split a single overlong word.
+			if (current) { lines.push(current); current = ""; currentWidth = 0; }
+			let buffer = "";
+			let bufferWidth = 0;
+			for (const segment of new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(word)) {
+				const w = visibleWidth(segment.segment);
+				if (bufferWidth + w > maxWidth) {
+					lines.push(buffer);
+					buffer = segment.segment;
+					bufferWidth = w;
+				} else {
+					buffer += segment.segment;
+					bufferWidth += w;
+				}
+			}
+			if (buffer) { lines.push(buffer); buffer = ""; bufferWidth = 0; }
+			continue;
+		}
+		if (currentWidth + wordWidth > maxWidth) {
+			lines.push(current.trimEnd());
+			current = word.trimStart();
+			currentWidth = visibleWidth(current);
+		} else {
+			current += word;
+			currentWidth += wordWidth;
+		}
+	}
+	if (current.trim().length > 0) lines.push(current.trimEnd());
+	return lines;
+}
+
+export function matchesEscape(data: string): boolean {
+	return data === "\x1b" || data === "\x1b\x1b" || /^(\x1b\[\??\d*[A-Za-z])|(\x1bO[A-Za-z])$/.test(data);
+}

package/src/refine-ui-state.ts

@@ -0,0 +1,78 @@
+import type { SubagentProgressEvent, SubagentResult } from "./subagent.ts";
+
+export type RefineOverlayRole = "reviewer" | "criticizer";
+export type RefineLaneStatus = "queued" | "running" | "complete" | "failed" | "cancelled";
+
+export interface RefineLaneState {
+	id: string;
+	label: string;
+	status: RefineLaneStatus;
+	phase: string;
+	detail: string;
+}
+
+function shorten(text: string, maxLength: number): string {
+	const normalized = text.replace(/\s+/g, " ").trim();
+	return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 3)}...` : normalized;
+}
+
+export function statusLabel(status: RefineLaneStatus): string {
+	switch (status) {
+		case "queued":
+			return "queued";
+		case "running":
+			return "running";
+		case "complete":
+			return "done";
+		case "failed":
+			return "failed";
+		case "cancelled":
+			return "cancelled";
+	}
+}
+
+export function applyRefineProgress(lane: RefineLaneState, event: SubagentProgressEvent): void {
+	if (lane.status === "complete" || lane.status === "failed" || lane.status === "cancelled") return;
+
+	switch (event.type) {
+		case "process":
+			lane.phase = event.phase === "started" ? "starting" : "exiting";
+			return;
+		case "turn":
+			lane.status = "running";
+			lane.phase = event.phase === "start" ? "thinking" : "waiting";
+			return;
+		case "message":
+			lane.status = "running";
+			lane.phase = event.role === "assistant" ? "responding" : event.role;
+			if (event.text) lane.detail = shorten(event.text, 180);
+			return;
+		case "tool":
+			lane.status = "running";
+			lane.phase = `tool: ${event.toolName}`;
+			if (event.detail) lane.detail = shorten(event.detail, 180);
+			return;
+		case "stderr":
+			lane.phase = "diagnostic";
+			if (event.text) lane.detail = shorten(event.text, 180);
+			return;
+	}
+}
+
+export function applyRefineResult(lane: RefineLaneState, result: SubagentResult): void {
+	if (result.ok) {
+		lane.status = "complete";
+		lane.phase = "complete";
+		lane.detail = shorten(result.output, 180);
+		return;
+	}
+	if (result.cancelled) {
+		lane.status = "cancelled";
+		lane.phase = "cancelled";
+		lane.detail = shorten(result.errorMessage ?? "Subagent was aborted", 180);
+		return;
+	}
+	lane.status = "failed";
+	lane.phase = result.timedOut ? "timed out" : "failed";
+	lane.detail = shorten((result.errorMessage ?? result.stderr) || "Subagent failed", 180);
+}

package/src/refine-ui.ts

@@ -0,0 +1,322 @@
+import type { ExtensionCommandContext, ExtensionContext, Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import type { Component, OverlayHandle, TUI } from "@earendil-works/pi-tui";
+import type { SubagentProgressEvent, SubagentResult } from "./subagent.ts";
+import {
+	matchesEscape as localMatchesEscape,
+	truncateToWidth as localTruncateToWidth,
+	visibleWidth as localVisibleWidth,
+	wrapTextWithAnsi as localWrapTextWithAnsi,
+} from "./refine-ui-helpers.ts";
+
+let _piTui: typeof import("@earendil-works/pi-tui") | undefined;
+let _piTuiAttempted = false;
+
+async function loadPiTui(): Promise<typeof import("@earendil-works/pi-tui") | undefined> {
+	if (_piTuiAttempted) return _piTui;
+	_piTuiAttempted = true;
+	try {
+		_piTui = await import("@earendil-works/pi-tui");
+	} catch {
+		_piTui = undefined;
+	}
+	return _piTui;
+}
+
+void loadPiTui();
+
+function truncateToWidth(text: string, width: number, ellipsis?: string): string {
+	try {
+		return _piTui ? _piTui.truncateToWidth(text, width, ellipsis) : localTruncateToWidth(text, width, ellipsis);
+	} catch {
+		return localTruncateToWidth(text, width, ellipsis);
+	}
+}
+
+function visibleWidth(text: string): number {
+	try {
+		return _piTui ? _piTui.visibleWidth(text) : localVisibleWidth(text);
+	} catch {
+		return localVisibleWidth(text);
+	}
+}
+
+function wrapTextWithAnsi(text: string, width: number): string[] {
+	try {
+		return _piTui ? _piTui.wrapTextWithAnsi(text, width) : localWrapTextWithAnsi(text, width);
+	} catch {
+		return localWrapTextWithAnsi(text, width);
+	}
+}
+
+function handleEscape(data: string): boolean {
+	try {
+		return _piTui ? _piTui.matchesKey(data, "escape") : localMatchesEscape(data);
+	} catch {
+		return localMatchesEscape(data);
+	}
+}
+import {
+	applyRefineProgress,
+	applyRefineResult,
+	statusLabel,
+	type RefineLaneState,
+	type RefineOverlayRole,
+} from "./refine-ui-state.ts";
+
+export type { RefineLaneState, RefineLaneStatus, RefineOverlayRole } from "./refine-ui-state.ts";
+
+const OVERLAY_MIN_WIDTH = 44;
+const OVERLAY_MAX_WIDTH = 96;
+const OVERLAY_MIN_HEIGHT = 18;
+const OVERLAY_MAX_HEIGHT = 32;
+const OVERLAY_HEIGHT_RATIO = 0.78;
+const CHROME_LINES = 5; // top + title + (header rule + footer rule + hints)
+
+export function getTerminalRowCount(): number {
+	const raw = (process.stdout as { rows?: number }).rows;
+	return typeof raw === "number" && raw > 0 ? raw : 30;
+}
+
+export function pickOverlayHeight(): number {
+	const rows = getTerminalRowCount();
+	const target = Math.max(OVERLAY_MIN_HEIGHT, Math.floor(rows * OVERLAY_HEIGHT_RATIO));
+	return Math.min(OVERLAY_MAX_HEIGHT, target);
+}
+
+export function pickOverlayWidth(width: number): number {
+	const target = Math.max(OVERLAY_MIN_WIDTH, Math.min(OVERLAY_MAX_WIDTH, Math.floor(width * 0.78)));
+	return Math.max(OVERLAY_MIN_WIDTH, Math.min(OVERLAY_MAX_WIDTH, target));
+}
+
+/**
+ * Break a free-form assistant/tool detail blob into sentence-sized lines so the
+ * overlay stays readable even when the model streams raw fragments.
+ */
+export function chunkDetailForOverlay(text: string, innerWidth: number, maxLines = 6): string[] {
+	const normalized = text.replace(/\s+/g, " ").trim();
+	if (!normalized) return [];
+	const boundary = /(?<=[.!?])\s+/;
+	const sentences = normalized.split(boundary).map((sentence) => sentence.trim()).filter(Boolean);
+	if (sentences.length === 0) return [normalized];
+	const lines: string[] = [];
+	const usable = Math.max(8, innerWidth);
+	for (const sentence of sentences) {
+		for (const wrapped of wrapTextWithAnsi(sentence, usable)) {
+			lines.push(wrapped);
+			if (lines.length >= maxLines) return lines;
+		}
+	}
+	return lines;
+}
+
+function borderColor(theme: Theme): ThemeColor {
+	return "borderAccent";
+}
+
+function renderRow(theme: Theme, content: string, innerWidth: number): string {
+	const truncated = truncateToWidth(content, innerWidth, "...");
+	const width = visibleWidth(truncated);
+	const filler = innerWidth > width ? " ".repeat(innerWidth - width) : "";
+	return `${theme.fg(borderColor(theme), "│")}${truncated}${filler}${theme.fg(borderColor(theme), "│")}`;
+}
+
+function renderHorizontalRule(theme: Theme, innerWidth: number): string {
+	return theme.fg(borderColor(theme), `├${"─".repeat(innerWidth)}┤`);
+}
+
+function renderBorderLine(theme: Theme, innerWidth: number, edge: "top" | "bottom"): string {
+	const side = edge === "top" ? "┌" : "└";
+	const right = edge === "top" ? "┐" : "┘";
+	return theme.fg(borderColor(theme), `${side}${"─".repeat(innerWidth)}${right}`);
+}
+
+function fitLine(line: string, width: number): string {
+	return visibleWidth(line) > width ? truncateToWidth(line, width, "...") : line;
+}
+
+function laneColor(status: RefineLaneState["status"]): ThemeColor {
+	switch (status) {
+		case "complete": return "success";
+		case "failed": return "error";
+		case "cancelled": return "warning";
+		case "running": return "accent";
+		case "queued": return "muted";
+	}
+}
+
+export class RefineOverlayComponent implements Component {
+	private readonly theme: Theme;
+	private readonly role: RefineOverlayRole;
+	private readonly lanes: RefineLaneState[];
+	private readonly onCancel: () => void;
+
+	constructor(theme: Theme, role: RefineOverlayRole, lanes: RefineLaneState[], onCancel: () => void) {
+		this.theme = theme;
+		this.role = role;
+		this.lanes = lanes;
+		this.onCancel = onCancel;
+	}
+
+	handleInput(data: string): void {
+		if (handleEscape(data)) this.onCancel();
+	}
+
+	render(width: number): string[] {
+		const dialogWidth = pickOverlayWidth(width);
+		const innerWidth = Math.max(8, dialogWidth - 2);
+		const title = this.role === "reviewer" ? "Reviewer" : "Criticizer";
+
+		// Build lane rows (label + status + detail sentence chunk)
+		const laneRows: string[] = [];
+		for (const lane of this.lanes) {
+			const status = this.theme.fg(laneColor(lane.status), statusLabel(lane.status));
+			const phase = lane.phase ? this.theme.fg("muted", ` · ${lane.phase}`) : "";
+			laneRows.push(this.theme.fg("accent", `▸ ${lane.label}:`) + ` ${status}${phase}`);
+			for (const chunk of chunkDetailForOverlay(lane.detail, innerWidth - 4, 4)) {
+				laneRows.push(this.theme.fg("dim", `    ${chunk}`));
+			}
+		}
+
+		const runningCount = this.lanes.filter((lane) => lane.status === "running").length;
+		const summary = `${this.lanes.length} lane${this.lanes.length === 1 ? "" : "s"}` +
+			(runningCount > 0 ? ` · ${runningCount} running` : "") +
+			(this.lanes.every((lane) => lane.status === "complete") ? " · all done" : "");
+
+		const hint = "Esc cancel · ↑/↓ lanes scroll when more lines than viewport";
+
+		// Compose chrome + body, then enforce viewport height.
+		const body = [
+			this.theme.fg("accent", this.theme.bold(title)),
+			this.theme.fg("dim", "Independent read-only refinement in progress"),
+			...laneRows,
+		];
+		if (body.length === 0) body.push(this.theme.fg("dim", "(no active lanes)"));
+
+		const dialogHeight = pickOverlayHeight();
+		const available = Math.max(8, dialogHeight - CHROME_LINES);
+		const visibleBody = body.slice(Math.max(0, body.length - available));
+		const hiddenAbove = Math.max(0, body.length - visibleBody.length);
+		const summaryText = hiddenAbove > 0
+			? `${summary} · ↑${hiddenAbove}`
+			: summary;
+
+		const lines: string[] = [renderBorderLine(this.theme, innerWidth, "top")];
+		lines.push(renderRow(this.theme, this.theme.fg("accent", this.theme.bold(title)), innerWidth));
+		lines.push(renderRow(this.theme, this.theme.fg("dim", summaryText), innerWidth));
+		lines.push(renderHorizontalRule(this.theme, innerWidth));
+		for (const row of visibleBody) lines.push(renderRow(this.theme, row, innerWidth));
+		lines.push(renderHorizontalRule(this.theme, innerWidth));
+		lines.push(renderRow(this.theme, this.theme.fg("dim", hint), innerWidth));
+		lines.push(renderBorderLine(this.theme, innerWidth, "bottom"));
+
+		return lines.map((line) => fitLine(line, width));
+	}
+
+	invalidate(): void {}
+}
+
+export interface RefineOverlayContext {
+	ui: ExtensionContext["ui"];
+	hasUI: boolean;
+}
+
+/**
+ * Owns a one-shot overlay. Child processes remain owned by the caller; the
+ * controller only receives progress and supplies a single cancellation hook.
+ */
+export class RefineOverlayController {
+	readonly lanes: RefineLaneState[];
+	private readonly role: RefineOverlayRole;
+	private readonly onCancel: () => void;
+	private handle: OverlayHandle | undefined;
+	private done: ((result: undefined) => void) | undefined;
+	private component: RefineOverlayComponent | undefined;
+	private overlayPromise: Promise<void> | undefined;
+	private tui: TUI | undefined;
+	private closed = false;
+
+	constructor(role: RefineOverlayRole, laneIds: Array<{ id: string; label?: string }>, onCancel: () => void) {
+		this.role = role;
+		this.onCancel = onCancel;
+		this.lanes = laneIds.map((lane) => ({
+			id: lane.id,
+			label: lane.label ?? lane.id,
+			status: "queued",
+			phase: "queued",
+			detail: "",
+		}));
+	}
+
+	open(ctx: RefineOverlayContext): void {
+		if (!ctx.hasUI || this.overlayPromise) return;
+
+		this.overlayPromise = ctx.ui
+			.custom<void>(
+				(_tui, theme, _keybindings, done) => {
+					this.tui = _tui;
+					this.done = done;
+					this.component = new RefineOverlayComponent(theme, this.role, this.lanes, () => this.cancel());
+					if (this.closed) done(undefined);
+					return this.component;
+				},
+				{
+					overlay: true,
+					overlayOptions: {
+						width: "78%",
+						minWidth: OVERLAY_MIN_WIDTH,
+						maxHeight: "78%",
+						anchor: "top-center",
+						margin: { top: 1, left: 2, right: 2 },
+					},
+					onHandle: (handle) => {
+						this.handle = handle;
+						handle.focus();
+						if (this.closed) handle.hide();
+					},
+				},
+			)
+			.then(() => undefined)
+			.catch(() => undefined);
+	}
+
+	update(laneId: string, event: SubagentProgressEvent): void {
+		if (this.closed) return;
+		const lane = this.lanes.find((candidate) => candidate.id === laneId);
+		if (!lane) return;
+		applyRefineProgress(lane, event);
+		this.tui?.requestRender();
+	}
+
+	complete(laneId: string, result: SubagentResult): void {
+		if (this.closed) return;
+		const lane = this.lanes.find((candidate) => candidate.id === laneId);
+		if (lane) {
+			applyRefineResult(lane, result);
+			this.tui?.requestRender();
+		}
+	}
+
+	cancel(): void {
+		if (this.closed) return;
+		this.onCancel();
+		void this.close();
+	}
+
+	async close(): Promise<void> {
+		if (!this.closed) {
+			this.closed = true;
+			if (this.done) this.done(undefined);
+			else this.handle?.hide();
+			this.component = undefined;
+		}
+		await this.overlayPromise;
+	}
+
+	isClosed(): boolean {
+		return this.closed;
+	}
+}
+
+export function refineOverlayContext(ctx: ExtensionContext | ExtensionCommandContext): RefineOverlayContext {
+	return { ui: ctx.ui, hasUI: ctx.hasUI };
+}

package/src/state.ts

@@ -34,18 +34,12 @@ export interface RoleConfig {
 	confirmed_at: string | null;
 }
 
-export interface ExecutionConfig {
-	model_selector: string | null;
-	source: SettingSource;
-	updated_at: string | null;
-}
 
 export interface PlansConfig {
 	schema: number;
 	language: LanguageConfig;
 	reviewer: RoleConfig;
 	criticizer: RoleConfig;
-	execution: ExecutionConfig;
 	artifact_root: string;
 	artifact_root_source: SettingSource;
 	artifact_root_updated_at: string | null;
@@ -61,6 +55,13 @@ function normalizeArtifactRoot(config: PlansConfig): PlansConfig {
 	return config;
 }
 
+type LegacyPlansConfig = PlansConfig & { execution?: unknown };
+
+function normalizeLegacyExecutionConfig(config: LegacyPlansConfig): PlansConfig {
+	const { execution: _execution, ...rest } = config;
+	return rest as PlansConfig;
+}
+
 export const DEFAULT_CONFIG: PlansConfig = {
 	schema: 1,
 	language: { tag: null, source: "unset", updated_at: null },
@@ -76,11 +77,6 @@ export const DEFAULT_CONFIG: PlansConfig = {
 		name_prefix: "pi-plans-criticizer",
 		confirmed_at: null,
 	},
-	execution: {
-		model_selector: null,
-		source: "unset",
-		updated_at: null,
-	},
 	artifact_root: DEFAULT_ARTIFACT_ROOT,
 	artifact_root_source: "unset",
 	artifact_root_updated_at: null,
@@ -268,7 +264,8 @@ export function loadConfig(stateRoot: string): PlansConfig {
 	} catch (error) {
 		throw new StateError(`invalid config.json: ${(error as Error).message}`);
 	}
-	return normalizeArtifactRoot(deepMergeDefaults(data as PlansConfig, DEFAULT_CONFIG));
+	const merged = deepMergeDefaults(data as LegacyPlansConfig, DEFAULT_CONFIG as LegacyPlansConfig);
+	return normalizeLegacyExecutionConfig(normalizeArtifactRoot(merged as PlansConfig));
 }
 
 function noticeIfSubdir(workdir: string, notices: string[]): void {
@@ -328,21 +325,6 @@ export function setArtifactRoot(workdir: string, artifactRoot: string, source: "
 	return { config, stateRoot, notices };
 }
 
-export interface SetExecutionModelOptions {
-	modelSelector?: string;
-	source: "user" | "auto";
-}
-
-export function setExecutionModel(workdir: string, options: SetExecutionModelOptions): EnsureResult {
-	const { config, stateRoot, notices } = ensureState(workdir);
-	config.execution = {
-		model_selector: options.modelSelector === undefined || options.modelSelector === "inherit" ? null : options.modelSelector,
-		source: options.source,
-		updated_at: utcNow(),
-	};
-	atomicWriteJson(path.join(stateRoot, "config.json"), config);
-	return { config, stateRoot, notices };
-}
 
 export interface SetRoleOptions {
 	role: "reviewer" | "criticizer";