one-code-extension 0.1.4 → 0.3.0

package/extensions/memory/entries.ts

@@ -0,0 +1,163 @@
+/**
+ * The entries shown in the `/memory` panel and checked by the startup size
+ * warning — mirroring Claude Code's picker, extended to the files One Code also
+ * loads. Pure (fs reads only), so ordering and labelling are unit-testable.
+ *
+ * The CLAUDE.md family and ONECODE.md come straight from `discoverContextFilePaths`
+ * (the single source of truth for "what's loaded into context"), so this never
+ * re-derives discovery or drifts from it. Layered on top, for the picker only:
+ * the two always-offered primaries (global + project `CLAUDE.md`, created on
+ * save), AGENTS.md **when a loaded file `@`-imports it** (a standalone AGENTS.md
+ * is not in our context, so trimming it changes nothing — CC has no AGENTS.md
+ * concept at all), and the auto-memory folder as the last entry.
+ */
+
+import { basename, dirname, join } from "node:path";
+import {
+	AGENTS_DESCRIPTOR,
+	ancestorDirs,
+	collectImportedPaths,
+	type ContextFilePath,
+	discoverContextFilePaths,
+	GLOBAL_DESCRIPTOR,
+	LOCAL_DESCRIPTOR,
+	ONECODE_DESCRIPTOR,
+	ONECODE_GLOBAL_DESCRIPTOR,
+	PROJECT_DESCRIPTOR,
+} from "../lib/claude-context.ts";
+import { tryReadFile } from "../lib/plugins.ts";
+
+export interface MemoryEntry {
+	/** Left-hand label: a friendly role name for known files, else the path. */
+	title: string;
+	/** Right-hand description, for the CC-known roles. */
+	description?: string;
+	/** Absolute path the entry opens. */
+	path: string;
+	kind: "file" | "folder";
+	/** File already on disk. The two create-on-open primaries may be false; folders are always true. */
+	exists: boolean;
+}
+
+/** Display form of a path: a file at the cwd as `./name`, under home as `~/…`, else absolute. */
+function displayPath(path: string, cwd: string, home: string): string {
+	if (path.startsWith(`${cwd}/`)) return `./${path.slice(cwd.length + 1)}`;
+	if (home && path === home) return "~";
+	if (home && path.startsWith(`${home}/`)) return `~${path.slice(home.length)}`;
+	return path;
+}
+
+/**
+ * The paths pulled into context by `@path` imports across the already-discovered
+ * context files (read once each). An AGENTS.md shows only if it is in here.
+ */
+function referencedImports(discovered: ContextFilePath[], home: string): Set<string> {
+	const refs = new Set<string>();
+	for (const { path } of discovered) {
+		const content = tryReadFile(path);
+		if (content === undefined) continue;
+		for (const p of collectImportedPaths(content, dirname(path), { home })) refs.add(p);
+	}
+	return refs;
+}
+
+export function buildMemoryEntries(opts: {
+	cwd: string;
+	home: string;
+	homeClaudeDir: string;
+	homeOneCodeDir: string;
+	memoryDir: string;
+}): MemoryEntry[] {
+	const { cwd, home, homeClaudeDir, homeOneCodeDir, memoryDir } = opts;
+	// agentsFallback so a directory's AGENTS.md (when it has no CLAUDE.md) is in the
+	// list, matching what the # claudeMd block sends.
+	const discovered = discoverContextFilePaths({ cwd, homeClaudeDir, homeOneCodeDir, agentsFallback: true });
+	const referenced = referencedImports(discovered, home);
+	// (descriptor, dir) → the discovered path, so per-dir lookups reuse the real
+	// on-disk casing discovery already resolved (no second stat/readdir here).
+	const found = new Map<string, string>();
+	for (const { path, descriptor } of discovered) found.set(`${descriptor}\0${dirname(path)}`, path);
+
+	const entries: MemoryEntry[] = [];
+	const seen = new Set<string>();
+	const add = (entry: MemoryEntry) => {
+		if (seen.has(entry.path)) return;
+		entries.push(entry);
+		seen.add(entry.path);
+	};
+	const disp = (path: string) => displayPath(path, cwd, home);
+
+	// Global user instructions — always offered, matching CC (created on save).
+	const globalClaude = join(homeClaudeDir, "CLAUDE.md");
+	add({
+		title: "User instructions",
+		description: `Saved in ${disp(globalClaude)}`,
+		path: globalClaude,
+		kind: "file",
+		exists: found.has(`${GLOBAL_DESCRIPTOR}\0${homeClaudeDir}`),
+	});
+	const globalOneCode = found.get(`${ONECODE_GLOBAL_DESCRIPTOR}\0${homeOneCodeDir}`);
+	if (globalOneCode) {
+		add({
+			title: "One Code user instructions",
+			description: `${disp(globalOneCode)} (One Code only)`,
+			path: globalOneCode,
+			kind: "file",
+			exists: true,
+		});
+	}
+
+	for (const d of ancestorDirs(cwd)) {
+		const isCwd = d === cwd;
+		const claude = join(d, "CLAUDE.md");
+		if (isCwd) {
+			// Project instructions — always offered (created on save).
+			add({
+				title: "Project instructions",
+				description: `Checked in at ${disp(claude)}`,
+				path: claude,
+				kind: "file",
+				exists: found.has(`${PROJECT_DESCRIPTOR}\0${d}`),
+			});
+		} else if (found.has(`${PROJECT_DESCRIPTOR}\0${d}`)) {
+			add({ title: disp(claude), path: claude, kind: "file", exists: true });
+		}
+
+		if (found.has(`${LOCAL_DESCRIPTOR}\0${d}`)) {
+			const local = join(d, "CLAUDE.local.md");
+			add({ title: disp(local), path: local, kind: "file", exists: true });
+		}
+
+		// AGENTS.md is editable when it's in context: the CLAUDE.md fallback for this
+		// directory (in `found`), or `@`-imported into a CLAUDE.md/ONECODE.md.
+		const agents = join(d, "AGENTS.md");
+		if (found.has(`${AGENTS_DESCRIPTOR}\0${d}`) || referenced.has(agents)) {
+			add({
+				title: isCwd ? "Agent instructions" : disp(agents),
+				description: isCwd ? `Checked in at ${disp(agents)}` : undefined,
+				path: agents,
+				kind: "file",
+				exists: true,
+			});
+		}
+
+		const oneCode = found.get(`${ONECODE_DESCRIPTOR}\0${d}`);
+		if (oneCode) {
+			add({
+				title: isCwd ? "One Code instructions" : disp(oneCode),
+				description: `${disp(oneCode)} (One Code only)`,
+				path: oneCode,
+				kind: "file",
+				exists: true,
+			});
+		}
+	}
+
+	add({ title: "Open auto-memory folder", path: memoryDir, kind: "folder", exists: true });
+	return entries;
+}
+
+/** The basename used in the startup size warning (e.g. `CLAUDE.md`). */
+export function entryName(entry: MemoryEntry): string {
+	return basename(entry.path);
+}

package/extensions/memory/index.ts

@@ -5,6 +5,8 @@
  * - session start: create the per-project memory directory (the system prompt
  *   promises the model "this directory already exists") and inject the
  *   MEMORY.md index — capped like Claude Code caps it — via the reminder queue.
+ *   Also raise Claude Code's startup over-limit warning for any loaded context
+ *   file (CLAUDE.md family, AGENTS.md, ONECODE.md) past the char limit.
  * - write into the memory dir: stamp bookkeeping frontmatter (node_type,
  *   originSessionId, modified) into the tool input *before* execution, so the
  *   file lands stamped and file-tracker observes the same bytes that are on
@@ -13,19 +15,33 @@
  * - write/edit of MEMORY.md: check the load limits afterwards; near-limit
  *   nudges over the reminder queue, over-limit turns the result into an error
  *   (the write itself succeeded — the message says so), matching Claude Code.
+ * - /memory: Claude Code's Memory picker — a panel of the CLAUDE.md-family /
+ *   AGENTS.md / ONECODE.md files plus "Open auto-memory folder"; the selection
+ *   opens in the external $EDITOR/$VISUAL (or the OS opener), as CC does.
  */
 
 import { mkdirSync, readFileSync } from "node:fs";
+import os from "node:os";
 import { isAbsolute, join, resolve, sep } from "node:path";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
+	claudeMdLimitWarning,
+	combinedLimitWarning,
 	INDEX_NEAR_LIMIT_REMINDER,
 	INDEX_OVER_LIMIT_ERROR,
 	indexLimitStatus,
 	projectMemoryDir,
 	stampFrontmatter,
 } from "../lib/memory.ts";
+import { claudeConfigDir, oneCodeStateDir } from "../lib/paths.ts";
+import { tryReadFile } from "../lib/plugins.ts";
 import { REMINDER_CHANNEL } from "../lib/reminders.ts";
+import { boundedDockHeight, safeThemeBold, safeThemePaint, truncateLine } from "../lib/tui-render.ts";
+import { buildMemoryEntries, entryName, type MemoryEntry } from "./entries.ts";
+import { openPath } from "./open-external.ts";
+import { applyMemoryKey, decodeMemoryKey, initialMemoryState, renderMemoryPanel } from "./panel.ts";
+
+const MEMORY_PANEL_MAX_HEIGHT = 20;
 
 function inputPath(input: unknown, cwd: string): string | undefined {
 	const raw = (input as { path?: unknown })?.path;
@@ -33,13 +49,50 @@ function inputPath(input: unknown, cwd: string): string | undefined {
 	return isAbsolute(raw) ? raw : resolve(cwd, raw);
 }
 
+/** All the panel/warning entries for `cwd`, from One Code's real state dirs. */
+function memoryEntriesFor(cwd: string): MemoryEntry[] {
+	return buildMemoryEntries({
+		cwd,
+		home: os.homedir(),
+		homeClaudeDir: claudeConfigDir(),
+		homeOneCodeDir: oneCodeStateDir(),
+		memoryDir: projectMemoryDir(cwd),
+	});
+}
+
 export default function memoryExtension(pi: ExtensionAPI) {
 	let dir: string | undefined;
 
 	pi.on("session_start", (_event, ctx) => {
+		const candidate = projectMemoryDir(ctx.cwd);
+
+		// Claude Code's startup warning: an instruction file over the char limit
+		// bloats every turn's context. Warn once, pointing at /memory to trim it.
+		// Also warn when several files each fit but together blow the budget —
+		// suppressed if a single file already fired, so a lone big file isn't
+		// reported twice.
+		if (ctx.hasUI) {
+			let total = 0;
+			let anyPerFile = false;
+			for (const entry of memoryEntriesFor(ctx.cwd)) {
+				if (entry.kind !== "file" || !entry.exists) continue;
+				const content = tryReadFile(entry.path);
+				if (content == null) continue;
+				total += content.length;
+				const warning = claudeMdLimitWarning(entryName(entry), content.length);
+				if (warning) {
+					anyPerFile = true;
+					ctx.ui.notify(warning, "warning");
+				}
+			}
+			if (!anyPerFile) {
+				const combined = combinedLimitWarning(total);
+				if (combined) ctx.ui.notify(combined, "warning");
+			}
+		}
+
 		// Like Claude Code: one memory dir per git repo (shared by worktrees and
 		// subdirectories); outside a repo, per cwd.
-		const candidate = projectMemoryDir(ctx.cwd);
 		try {
 			mkdirSync(candidate, { recursive: true });
 		} catch {
@@ -87,4 +140,68 @@ export default function memoryExtension(pi: ExtensionAPI) {
 		}
 		return undefined;
 	});
+
+	// ---- /memory: Claude Code's Memory picker --------------------------------
+	// Pick a memory-related file (or the auto-memory folder) and open it in the
+	// external editor, matching CC. Pure panel logic lives in ./panel.ts.
+	pi.registerCommand("memory", {
+		description: "View or edit CLAUDE.md and memory files",
+		handler: async (_args, ctx) => {
+			const entries = memoryEntriesFor(ctx.cwd);
+			if (!ctx.hasUI) {
+				const lines = entries.map(
+					(e, i) => `${i + 1}. ${e.title}${e.description ? ` — ${e.description}` : ""}  [${e.path}]`,
+				);
+				ctx.ui.notify(`Memory / CLAUDE.md files:\n${lines.join("\n")}`, "info");
+				return;
+			}
+			const chosen = await openMemoryPanel(ctx, entries);
+			if (!chosen) return;
+			const result = await openPath(chosen.path, chosen.kind);
+			ctx.ui.notify(result.message, result.ok ? "info" : "error");
+			if (result.ok && result.hint) ctx.ui.notify(result.hint, "info");
+		},
+	});
+}
+
+/** Show the Memory panel as a focused overlay; resolve to the chosen entry or null. */
+function openMemoryPanel(ctx: ExtensionContext, entries: MemoryEntry[]): Promise<MemoryEntry | null> {
+	return ctx.ui.custom<MemoryEntry | null>((tui, theme, _keybindings, done) => {
+		const paint = { fg: safeThemePaint(theme), bold: safeThemeBold(theme) };
+		const state = initialMemoryState();
+		let cache: { width: number; lines: string[] } | undefined;
+		const repaint = () => {
+			cache = undefined;
+			tui.requestRender();
+		};
+		return {
+			render: (width: number) => {
+				if (cache?.width === width) return cache.lines;
+				const termRows = (tui as { terminal: { rows: number } }).terminal.rows;
+				const height = boundedDockHeight(termRows, MEMORY_PANEL_MAX_HEIGHT);
+				const lines = renderMemoryPanel({ state, entries, width, height }, paint).map((line) =>
+					truncateLine(line, width),
+				);
+				cache = { width, lines };
+				return lines;
+			},
+			handleInput: (data: string) => {
+				const key = decodeMemoryKey(data);
+				if (!key) return;
+				const effect = applyMemoryKey(state, key, entries);
+				if (effect?.kind === "close") {
+					done(null);
+					return;
+				}
+				if (effect?.kind === "open") {
+					done(effect.entry);
+					return;
+				}
+				repaint();
+			},
+			invalidate: () => {
+				cache = undefined;
+			},
+		};
+	});
 }

package/extensions/memory/open-external.ts

@@ -0,0 +1,97 @@
+/**
+ * Open a memory file or folder in the user's editor / OS opener, matching Claude
+ * Code's `/memory`: a file goes to `$VISUAL`/`$EDITOR` (or the OS default), a
+ * folder to the OS file manager. The child is detached and unref'd so the TUI is
+ * never blocked (as the MCP OAuth browser open does). Returns the status line and
+ * the editor hint to print, matching CC's "Opened <path>" + the $EDITOR nudge.
+ *
+ * Limitation: a terminal editor (vim/nano) needs the controlling tty, which the
+ * pi TUI owns, so it cannot run detached — this suits GUI editors (code, subl)
+ * and the OS opener, CC's common desktop case. We can detect a failed *spawn*
+ * (an unknown editor command) but not a GUI editor that opens a not-yet-created
+ * file (it materialises on save) — so `openPath` reports success once the child
+ * spawns. The command choice is pure and unit-tested via `resolveOpen`.
+ */
+
+import { spawn } from "node:child_process";
+
+export interface OpenPlan {
+	command: string;
+	args: string[];
+}
+
+/**
+ * Split an `$EDITOR`/`$VISUAL` value into command + flags, honouring single and
+ * double quotes so a spaced editor path works when quoted (`"/Apps/My Editor" -w`)
+ * — the same contract as a shell, and what tools like git expect. An unquoted
+ * space is a token boundary, so a spaced path must be quoted (as elsewhere).
+ */
+function tokenizeEditor(editor: string): string[] {
+	const tokens: string[] = [];
+	const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+	let m: RegExpExecArray | null;
+	while ((m = re.exec(editor)) !== null) tokens.push(m[1] ?? m[2] ?? m[3]);
+	return tokens;
+}
+
+/** Pure: decide the command + args to open `path`. `plat` defaults to the host platform. */
+export function resolveOpen(
+	path: string,
+	kind: "file" | "folder",
+	env: Record<string, string | undefined> = process.env,
+	plat: NodeJS.Platform = process.platform,
+): OpenPlan {
+	const editor = kind === "file" ? (env.VISUAL || env.EDITOR)?.trim() : undefined;
+	if (editor) {
+		const parts = tokenizeEditor(editor);
+		return { command: parts[0], args: [...parts.slice(1), path] };
+	}
+	if (plat === "darwin") return { command: "open", args: [path] };
+	if (plat === "win32") return { command: "cmd", args: ["/c", "start", "", path] };
+	return { command: "xdg-open", args: [path] };
+}
+
+export interface OpenResult {
+	message: string;
+	hint?: string;
+	ok: boolean;
+}
+
+/** The editor hint CC prints under an opened file. */
+export const EDITOR_HINT = "To use a different editor, set the $EDITOR or $VISUAL environment variable.";
+
+/**
+ * Spawn the opener/editor detached, resolving once the child either spawns
+ * (success) or fails to spawn (e.g. an unknown `$EDITOR` command — reported as an
+ * error instead of a false "Opened"). Both spawn outcomes always fire exactly one
+ * of these events, so the promise never hangs.
+ */
+export function openPath(path: string, kind: "file" | "folder"): Promise<OpenResult> {
+	const { command, args } = resolveOpen(path, kind);
+	return new Promise((resolve) => {
+		let settled = false;
+		const finish = (result: OpenResult) => {
+			if (!settled) {
+				settled = true;
+				resolve(result);
+			}
+		};
+		let child: ReturnType<typeof spawn>;
+		try {
+			child = spawn(command, args, { stdio: "ignore", detached: true });
+		} catch (error) {
+			finish({ message: `Could not open ${path}: ${error instanceof Error ? error.message : error}`, ok: false });
+			return;
+		}
+		child.on("error", (error) => finish({ message: `Could not open ${path}: ${error.message}`, ok: false }));
+		child.on("spawn", () => {
+			child.unref();
+			finish({
+				message: `Opened ${path}`,
+				// CC shows the hint on file opens (even when $EDITOR handled it); folders don't.
+				hint: kind === "file" ? EDITOR_HINT : undefined,
+				ok: true,
+			});
+		});
+	});
+}

package/extensions/memory/panel.ts

@@ -0,0 +1,124 @@
+/**
+ * Pure state, key decoding, and rendering for the `/memory` panel — Claude Code's
+ * Memory picker: a titled list of the CLAUDE.md-family / AGENTS.md / ONECODE.md
+ * files plus "Open auto-memory folder", with an Auto-memory status line and a
+ * learn-more link. Enter opens the selected entry (in `$EDITOR`); Esc closes.
+ *
+ * Kept free of pi imports so the layout and navigation are unit-tested; the
+ * extension owns repaint, the overlay, and the actual open.
+ */
+
+import type { MemoryEntry } from "./entries.ts";
+
+export const MEMORY_DOCS_URL = "https://github.com/IsuruMaduranga/one-code";
+
+export interface MemoryPanelState {
+	cursor: number;
+}
+
+export function initialMemoryState(): MemoryPanelState {
+	return { cursor: 0 };
+}
+
+export type MemoryKey = { kind: "up" | "down" | "enter" | "close" };
+
+export function decodeMemoryKey(data: string): MemoryKey | undefined {
+	switch (data) {
+		case "\x1b[A":
+		case "\x1bOA":
+		case "\x10": // ctrl+p
+			return { kind: "up" };
+		case "\x1b[B":
+		case "\x1bOB":
+		case "\x0e": // ctrl+n
+			return { kind: "down" };
+		case "\r":
+		case "\n":
+			return { kind: "enter" };
+		case "\x1b":
+		case "\x03": // ctrl+c
+			return { kind: "close" };
+		default:
+			return undefined;
+	}
+}
+
+export type MemoryEffect = { kind: "open"; entry: MemoryEntry } | { kind: "close" };
+
+export function applyMemoryKey(
+	state: MemoryPanelState,
+	key: MemoryKey,
+	entries: readonly MemoryEntry[],
+): MemoryEffect | undefined {
+	switch (key.kind) {
+		case "up":
+			state.cursor = Math.max(0, state.cursor - 1);
+			return undefined;
+		case "down":
+			state.cursor = Math.min(entries.length - 1, state.cursor + 1);
+			return undefined;
+		case "enter": {
+			const entry = entries[state.cursor];
+			return entry ? { kind: "open", entry } : undefined;
+		}
+		case "close":
+			return { kind: "close" };
+	}
+}
+
+export type PanelPaint = {
+	fg: (color: string, text: string) => string;
+	bold: (text: string) => string;
+};
+
+/** Column where descriptions begin (after "❯ N. Title"), padded on plain text. */
+const DESC_COL = 34;
+
+/**
+ * Render the panel to `height` lines. The header (title, status) and footer
+ * (learn-more, key hints) are fixed; the entry list scrolls within what's left so
+ * the cursor stays visible.
+ */
+export function renderMemoryPanel(
+	input: { state: MemoryPanelState; entries: readonly MemoryEntry[]; width: number; height: number },
+	paint: PanelPaint,
+): string[] {
+	const { state, entries, height } = input;
+
+	const header = [paint.bold("Memory"), "", `  ${paint.fg("muted", "Auto-memory: on")}`, ""];
+	const footer = [
+		"",
+		paint.fg("muted", `Learn more: ${MEMORY_DOCS_URL}`),
+		"",
+		paint.fg("muted", "Enter to open · Esc to close"),
+	];
+
+	const listCapacity = Math.max(1, height - header.length - footer.length);
+	const start = scrollStart(state.cursor, entries.length, listCapacity);
+	const rows: string[] = [];
+	for (let i = start; i < Math.min(entries.length, start + listCapacity); i++) {
+		rows.push(renderRow(entries[i], i, i === state.cursor, paint));
+	}
+
+	return [...header, ...rows, ...footer];
+}
+
+/** First index to show so `cursor` is within a `capacity`-tall window. */
+function scrollStart(cursor: number, total: number, capacity: number): number {
+	if (total <= capacity) return 0;
+	const start = Math.min(Math.max(0, cursor - Math.floor(capacity / 2)), total - capacity);
+	return Math.max(0, start);
+}
+
+function renderRow(entry: MemoryEntry, index: number, selected: boolean, paint: PanelPaint): string {
+	const prefix = selected ? "❯ " : "  ";
+	const left = `${prefix}${index + 1}. ${entry.title}`;
+	if (!entry.description) {
+		return selected ? paint.fg("accent", left) : left;
+	}
+	const pad = " ".repeat(Math.max(2, DESC_COL - left.length + 2));
+	if (selected) {
+		return `${paint.fg("accent", left)}${pad}${paint.fg("accent", entry.description)}`;
+	}
+	return `${left}${pad}${paint.fg("muted", entry.description)}`;
+}

package/extensions/model-default/index.ts

@@ -0,0 +1,74 @@
+/**
+ * model-default extension — remember the interactively chosen model across
+ * restarts (Claude Code parity: a /model selection sticks).
+ *
+ * pi's own selector persists only through its explicit "set as default" action;
+ * plain Enter and `/model <name>` switch the session only, so a restart forgets
+ * the choice. One Code persists every interactive model change instead:
+ * `model_select` fires only for real in-session switches ("set"/"cycle") —
+ * never for the startup model, a `--model` launch, or a resumed session's
+ * restore — so those paths keep their pi semantics.
+ *
+ * The value lands in pi's OWN settings.json under getAgentDir()
+ * (`defaultProvider`/`defaultModel`), which pi loads natively at the next
+ * startup with its normal precedence (an explicit --model still wins). Safe to
+ * write externally: pi's settings save re-reads the file under its lock and
+ * merges only the fields pi itself modified, so this key survives pi's writes.
+ */
+
+import { join } from "node:path";
+import { getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { readSettingsForWrite, writeSettings } from "../lib/one-code-settings.ts";
+
+/** Pure merge: set the default model, preserving every other settings key. */
+export function applyDefaultModel(
+	file: Record<string, unknown>,
+	provider: string,
+	modelId: string,
+): Record<string, unknown> {
+	return { ...file, defaultProvider: provider, defaultModel: modelId };
+}
+
+/** Quiet period after the last switch before it is written (ctrl+p cycles fire one event per step). */
+export const PERSIST_DEBOUNCE_MS = 400;
+
+export default function modelDefaultExtension(pi: ExtensionAPI) {
+	let pending: { provider: string; id: string; notify: (message: string) => void } | undefined;
+	let timer: ReturnType<typeof setTimeout> | undefined;
+
+	const flush = () => {
+		if (timer !== undefined) clearTimeout(timer);
+		timer = undefined;
+		const choice = pending;
+		pending = undefined;
+		if (!choice) return;
+		const path = join(getAgentDir(), "settings.json");
+		try {
+			writeSettings(path, applyDefaultModel(readSettingsForWrite(path), choice.provider, choice.id));
+		} catch (error) {
+			// Persisting a preference must not break the model switch itself, but
+			// say why it will be forgotten (typically a malformed settings.json).
+			choice.notify(`Could not save ${choice.provider}/${choice.id} as the default model: ${(error as Error).message}`);
+		}
+	};
+
+	// Debounced: a ctrl+p cycle emits model_select per step, and only the model
+	// the user settles on should hit the disk (last one wins).
+	pi.on("model_select", (event, ctx) => {
+		const model = event.model as { provider?: string; id?: string } | undefined;
+		if (!model?.provider || !model.id) return;
+		pending = {
+			provider: model.provider,
+			id: model.id,
+			notify: (message) => {
+				if (ctx.hasUI) ctx.ui.notify(message, "warning");
+			},
+		};
+		if (timer !== undefined) clearTimeout(timer);
+		timer = setTimeout(flush, PERSIST_DEBOUNCE_MS);
+		timer.unref?.();
+	});
+
+	// A quit inside the quiet period must not lose the choice.
+	pi.on("session_shutdown", () => flush());
+}