@faiku/pi-default-model-switcher 0.0.1

package/README.md

@@ -0,0 +1,64 @@
+# pi-default-model-switcher
+
+A [pi](https://github.com/earendil-works/pi) extension that adds commands for changing the **default startup model**, globally or per project, and for switching the model of the running session.
+
+## Commands
+
+| Command | Effect |
+|---|---|
+| `/model-session` | Switch the model for this session only. Nothing is written to disk. |
+| `/model-global` | Switch the model and write `defaultProvider` / `defaultModel` / `defaultThinkingLevel` to `<agent-dir>/settings.json` (default `~/.pi/agent/settings.json`). |
+| `/model-project` | Same, but writes to `<cwd>/.pi/settings.json`, so the default applies only in this project directory. |
+| `/model-show` | Print the current session model plus the effective global and project defaults. |
+
+All model commands accept an optional argument to skip the pickers:
+
+```
+/model-global anthropic/claude-sonnet-4-5
+/model-project openai/gpt-5:high        # ":high" also sets the thinking level
+/model-session opus                     # bare model id works when unambiguous
+```
+
+## Behavior
+
+- The model picker is a centered overlay with a search box. Typing fuzzy-matches provider, model id, and name (`sonnet`, `openai gpt`, `1m`); `↑↓`/`j`/`k` move, `enter` selects, `esc` cancels, mouse wheel and click work in fullscreen mode.
+- The list is scrollable and clamped: it shows at most 15 rows and never more than the terminal height allows (`min(15, rows - 7)`), with a `(3/87)` position indicator, so navigation cannot push the selection off screen.
+- A trailing `Other…` row appears whenever the search text is not an exact model match, so any `provider/model` in your registry can be entered by hand.
+- Models without extended thinking are stored with `defaultThinkingLevel: "off"`; reasoning models prompt for a level limited to what the model supports.
+- The chosen model is applied to the running session immediately (`pi.setModel` + `pi.setThinkingLevel`), and persisted when the command is `/model-global` or `/model-project`.
+- Settings files are merged, never rewritten: unrelated keys, formatting-free but stable 2-space JSON, and a trailing newline are preserved. Writes go through pi's file mutation queue.
+- `/model-project` refuses to write when the project is not trusted, because pi would ignore `.pi/settings.json`.
+- Project settings override global settings, so a project default wins over your user default in that directory.
+- Non-TUI clients (RPC, print mode) fall back to the plain `ctx.ui.select` dialog.
+
+## Install
+
+Personal (all projects):
+
+```bash
+ln -s "$PWD" ~/.pi/agent/extensions/pi-default-model-switcher
+```
+
+Per project, or for one run:
+
+```bash
+pi --extension ./index.ts
+```
+
+```bash
+# add to <project>/.pi/settings.json
+{ "extensions": ["/Users/adam/Documents/Coding/pi-default-model-switcher"] }
+```
+
+Startup defaults are read when a session starts, so run `/reload` or start a new pi session for the persisted default to take effect everywhere; the current session already uses the new model.
+
+## Development
+
+```bash
+npm install          # dev-only: types for typechecking
+npm test             # unit tests for settings, model refs, fuzzy search, layout
+npm run typecheck    # tsc --noEmit
+```
+
+Layout: `index.ts` (commands), `lib/settings.ts` (settings paths + merge/write), `lib/models.ts` (model refs, thinking levels), `lib/fuzzy.ts` (search ranking), `lib/picker.ts` (pure item/window math), `lib/model-picker.ts` (overlay component).
+# pi-default-model-switcher

package/index.ts

@@ -0,0 +1,210 @@
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+	defaultsFromSettings,
+	describeDefaults,
+	globalSettingsPath,
+	projectSettingsPath,
+	readSettings,
+	writeSettings,
+} from "./lib/settings.ts";
+import {
+	modelRef,
+	parseModelRef,
+	sortModels,
+	supportedThinkingLevels,
+	OTHER_OPTION,
+	type ModelLike,
+} from "./lib/models.ts";
+import { buildPickerItems } from "./lib/picker.ts";
+import { ModelPickerComponent } from "./lib/model-picker.ts";
+
+type Target = "session" | "global" | "project";
+
+const TARGET_LABEL: Record<Target, string> = {
+	session: "this session (not saved)",
+	global: "global settings",
+	project: "project settings",
+};
+
+export default function defaultModelSwitcher(pi: ExtensionAPI) {
+	pi.registerCommand("model-session", {
+		description: "Switch model for this session only (not saved to settings)",
+		handler: (args, ctx) => runSwitch(pi, "session", args, ctx),
+	});
+
+	pi.registerCommand("model-global", {
+		description: "Change the global (agent directory) default startup model",
+		handler: (args, ctx) => runSwitch(pi, "global", args, ctx),
+	});
+
+	pi.registerCommand("model-project", {
+		description: "Change the default startup model for the current project (.pi/settings.json)",
+		handler: (args, ctx) => runSwitch(pi, "project", args, ctx),
+	});
+
+	pi.registerCommand("model-show", {
+		description: "Show the current session model plus global and project model defaults",
+		handler: async (_args, ctx) => {
+			const current = ctx.model as ModelLike | undefined;
+			const thinking = ctx.thinkingLevel ?? (await safeThinkingLevel(pi));
+			ctx.ui.notify(
+				`Session: ${current ? `${modelRef(current)} (${current.name})` : "(none)"}  thinking=${thinking ?? "unset"}`,
+				"info",
+			);
+			const global = await readSettings(globalSettingsPath());
+			ctx.ui.notify(`Global  ${globalSettingsPath()}\n  ${describeDefaults(global)}`, "info");
+			const projectFile = projectSettingsPath(ctx.cwd);
+			const project = await readSettings(projectFile);
+			ctx.ui.notify(`Project ${projectFile}\n  ${describeDefaults(project)}`, "info");
+			const projectOverride = defaultsFromSettings(project);
+			if (projectOverride.defaultModel) {
+				ctx.ui.notify("Project settings take precedence over global settings in this directory.", "info");
+			}
+		},
+	});
+}
+
+async function safeThinkingLevel(pi: ExtensionAPI): Promise<string | undefined> {
+	try {
+		return pi.getThinkingLevel();
+	} catch {
+		return undefined;
+	}
+}
+
+async function runSwitch(pi: ExtensionAPI, target: Target, args: string, ctx: ExtensionCommandContext): Promise<void> {
+	if (target === "project" && !ctx.isProjectTrusted()) {
+		ctx.ui.notify(
+			"This project is not trusted, so .pi/settings.json would be ignored. Trust the project first, or use /model-global.",
+			"warning",
+		);
+		return;
+	}
+	if (!ctx.hasUI) {
+		ctx.ui.notify("No interactive UI available. Pass a model reference as an argument, e.g. /model-global anthropic/claude-sonnet-4-5", "warning");
+	}
+
+	const current = ctx.model as ModelLike | undefined;
+	const models = sortModels(ctx.modelRegistry.getAvailable() as ModelLike[]);
+
+	let chosen: ModelLike | undefined;
+	let thinkingHint: string | undefined;
+
+	if (args.trim() !== "") {
+		const ref = parseModelRef(args);
+		thinkingHint = ref?.thinkingLevel;
+		chosen = models.find((m) => modelRef(m) === `${ref?.provider}/${ref?.id}`) ?? (ref ? matchById(models, ref.id, ref.provider) : undefined);
+		if (!chosen) {
+			ctx.ui.notify(`No configured model matches "${args.trim()}". Use provider/model, e.g. anthropic/claude-sonnet-4-5.`, "error");
+			return;
+		}
+	} else {
+		if (!ctx.hasUI) return;
+		if (models.length === 0) {
+			ctx.ui.notify("No models with configured credentials are available.", "error");
+			return;
+		}
+		const selection = await pickModel(`Select model for ${TARGET_LABEL[target]}`, models, current, ctx);
+		if (selection.kind === "cancel") return;
+		if (selection.kind === "model") {
+			chosen = models.find((m) => modelRef(m) === selection.value);
+		} else {
+			const ref = parseModelRef(selection.value);
+			thinkingHint = ref?.thinkingLevel;
+			chosen = ref ? matchById(models, ref.id, ref.provider) : undefined;
+			if (!chosen) {
+				ctx.ui.notify(
+					`No configured model matches "${selection.value}". It must exist in your model registry with credentials.`,
+					"error",
+				);
+				return;
+			}
+		}
+	}
+
+	if (!chosen) return;
+
+	let thinkingLevel = thinkingHint;
+	if (!thinkingLevel) {
+		thinkingLevel = await pickThinkingLevel(chosen, ctx);
+		if (thinkingLevel === undefined) return;
+	}
+
+	// Persist when a settings file backs this target.
+	if (target !== "session") {
+		const file = target === "global" ? globalSettingsPath() : projectSettingsPath(ctx.cwd);
+		const patch: Record<string, unknown> = {
+			defaultProvider: chosen.provider,
+			defaultModel: chosen.id,
+		};
+		if (thinkingLevel) patch.defaultThinkingLevel = thinkingLevel;
+		try {
+			await withFileMutationQueue(file, async () => {
+				await writeSettings(file, patch);
+			});
+		} catch (error) {
+			ctx.ui.notify(`Failed to write ${file}: ${error instanceof Error ? error.message : String(error)}`, "error");
+			return;
+		}
+	}
+
+	// Apply to the running session.
+	const switched = await pi.setModel(chosen as never);
+	if (!switched) {
+		ctx.ui.notify(`Pi refused to switch to ${modelRef(chosen)} in this session.`, "warning");
+	}
+	if (thinkingLevel) pi.setThinkingLevel(thinkingLevel as never);
+
+	const where = target === "session" ? "this session only" : target === "global" ? globalSettingsPath() : projectSettingsPath(ctx.cwd);
+	ctx.ui.notify(
+		`Model set to ${modelRef(chosen)} (${chosen.name}), thinking=${thinkingLevel ?? "unchanged"} — ${where}.`,
+		"info",
+	);
+	if (target === "project") {
+		ctx.ui.notify("Project .pi/settings.json is read at startup; run /reload after switching projects.", "info");
+	}
+}
+
+/**
+ * Show the searchable, scrollable model picker.
+ *
+ * TUI sessions get the overlay component; other clients fall back to the plain
+ * `ctx.ui.select` dialog.
+ */
+async function pickModel(
+	title: string,
+	models: ModelLike[],
+	current: ModelLike | undefined,
+	ctx: ExtensionCommandContext,
+): Promise<{ kind: "model"; value: string } | { kind: "other"; value: string } | { kind: "cancel" }> {
+	if (ctx.mode === "tui") {
+		return ctx.ui.custom((tui, theme, _kb, done) => new ModelPickerComponent(tui, theme, title, buildPickerItems(models, current), done), {
+			overlay: true,
+			overlayOptions: { anchor: "center", width: "70%", minWidth: 50, maxHeight: "90%", margin: 1 },
+		});
+	}
+	const options = [...models.map((m) => `${m.provider}  ${m.name}  [${m.id}]`), OTHER_OPTION];
+	const picked = await ctx.ui.select(title, options);
+	if (picked === undefined) return { kind: "cancel" };
+	if (picked === OTHER_OPTION) {
+		const typed = await ctx.ui.input("Model reference", "provider/model");
+		if (typed === undefined) return { kind: "cancel" };
+		return { kind: "other", value: typed.trim() };
+	}
+	const model = models[options.indexOf(picked)];
+	return model ? { kind: "model", value: modelRef(model) } : { kind: "cancel" };
+}
+
+function matchById(models: ModelLike[], id: string, provider?: string): ModelLike | undefined {
+	if (provider) return models.find((m) => m.provider === provider && m.id === id);
+	const matches = models.filter((m) => m.id === id);
+	return matches.length === 1 ? matches[0] : undefined;
+}
+
+async function pickThinkingLevel(model: ModelLike, ctx: ExtensionCommandContext): Promise<string | undefined> {
+	const levels = supportedThinkingLevels(model);
+	if (levels.length <= 1) return levels[0];
+	if (!ctx.hasUI) return undefined;
+	return ctx.ui.select(`Thinking level for ${modelRef(model)}`, levels);
+}

package/lib/fuzzy.ts

@@ -0,0 +1,55 @@
+/**
+ * Small fuzzy matcher used by the model picker.
+ *
+ * A query matches when every token (whitespace- or slash-separated) appears as a
+ * subsequence of the candidate text, in order. Lower scores rank first.
+ */
+
+function tokenize(query: string): string[] {
+	return query
+		.toLowerCase()
+		.split(/[\s/]+/)
+		.filter((token) => token.length > 0);
+}
+
+/** Score a query against text. Returns `undefined` when the query does not match. */
+export function fuzzyScore(query: string, text: string): number | undefined {
+	const tokens = tokenize(query);
+	if (tokens.length === 0) return 0;
+	const haystack = text.toLowerCase();
+	let total = 0;
+	let cursor = 0;
+	for (const token of tokens) {
+		let tokenIndex = 0;
+		let first = -1;
+		let found = -1;
+		for (let i = cursor; i < haystack.length && tokenIndex < token.length; i++) {
+			if (haystack[i] === token[tokenIndex]) {
+				if (first < 0) first = i;
+				found = i;
+				tokenIndex++;
+			}
+		}
+		if (tokenIndex < token.length) return undefined;
+		// A literal substring hit always beats a scattered subsequence hit, then
+		// earlier and tighter matches win.
+		const literal = haystack.indexOf(token, cursor) >= 0;
+		const gaps = found - first + 1 - token.length;
+		total += (literal ? 0 : 200) + first + gaps * 2;
+		cursor = found + 1;
+	}
+	return total;
+}
+
+/** Filter and rank items by fuzzy match quality against `getText(item)`. */
+export function fuzzyFilterItems<T>(items: readonly T[], query: string, getText: (item: T) => string): T[] {
+	const tokens = tokenize(query);
+	if (tokens.length === 0) return [...items];
+	const scored: Array<{ item: T; score: number; index: number }> = [];
+	items.forEach((item, index) => {
+		const score = fuzzyScore(query, getText(item));
+		if (score !== undefined) scored.push({ item, score, index });
+	});
+	scored.sort((a, b) => (a.score === b.score ? a.index - b.index : a.score - b.score));
+	return scored.map((entry) => entry.item);
+}

package/lib/model-picker.ts

@@ -0,0 +1,179 @@
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Container, Input, type Component, type TuiMouseEvent, type TuiMouseEventResult, type TUI, Text, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import { clampIndex, filterPickerItems, pickerMaxVisible, visibleRange, type PickerItem } from "./picker.ts";
+
+const OTHER_LABEL = "Other…";
+const OTHER_DESCRIPTION = "use provider/model typed above";
+
+type PickerResult = { kind: "model"; value: string } | { kind: "other"; value: string } | { kind: "cancel" };
+
+/**
+ * Scrollable, searchable model picker rendered as a centered overlay.
+ *
+ * The list shows at most `pickerMaxVisible` rows for the current terminal size, so
+ * navigation never runs the selection past the bottom of the screen.
+ */
+export class ModelPickerComponent implements Component {
+	private readonly container = new Container();
+	private readonly input: Input;
+	private readonly listContainer = new Container();
+	private items: PickerItem[];
+	private selectedIndex = 0;
+	private listStartRow = 0;
+	private _focused = false;
+
+	constructor(
+		private readonly tui: TUI,
+		private readonly theme: Theme,
+		private readonly title: string,
+		items: PickerItem[],
+		private readonly done: (result: PickerResult) => void,
+	) {
+		this.items = items;
+		this.selectedIndex = 0;
+
+		this.container.addChild(new DynamicBorder((str) => this.theme.fg("accent", str)));
+		this.container.addChild(new Text(this.theme.fg("accent", this.theme.bold(this.title)), 1, 0));
+		this.container.addChild(new Text(this.theme.fg("muted", "type to search · ↑↓ move · enter select · esc cancel"), 1, 0));
+
+		this.input = new Input({ prompt: this.theme.fg("accent", "> ") });
+		this.input.onSubmit = () => this.select();
+		this.container.addChild(this.input);
+		this.container.addChild(this.listContainer);
+		this.container.addChild(new Text(this.theme.fg("muted", "  "), 1, 0));
+		this.container.addChild(new DynamicBorder((str) => this.theme.fg("accent", str)));
+
+		this.updateList();
+	}
+
+	get focused(): boolean {
+		return this._focused;
+	}
+
+	set focused(value: boolean) {
+		this._focused = value;
+		this.input.focused = value;
+	}
+
+	/** Filtered items plus the manual-entry row when the query is not an exact match. */
+	private visibleItems(): PickerItem[] {
+		const query = this.input.getValue();
+		const filtered = filterPickerItems(this.items, query);
+		const exact = filtered.some((item) => item.value.toLowerCase() === query.trim().toLowerCase());
+		if (exact) return filtered;
+		return [
+			...filtered,
+			{
+				value: OTHER_LABEL,
+				label: OTHER_LABEL,
+				description: query.trim() === "" ? OTHER_DESCRIPTION : `use "${query.trim()}" as provider/model`,
+				searchText: OTHER_LABEL,
+			},
+		];
+	}
+
+	private updateList(): void {
+		const items = this.visibleItems();
+		const maxVisible = pickerMaxVisible(items.length, this.tui.terminal.rows);
+		this.selectedIndex = clampIndex(this.selectedIndex, items.length);
+		const { start, end } = visibleRange(items.length, this.selectedIndex, maxVisible);
+
+		this.listContainer.clear();
+		for (let i = start; i < end; i++) {
+			const item = items[i];
+			if (!item) continue;
+			const selected = i === this.selectedIndex;
+			const prefix = selected ? this.theme.fg("accent", "→ ") : "  ";
+			const label = selected ? this.theme.fg("accent", this.theme.bold(item.label)) : this.theme.fg("text", item.label);
+			const description = this.theme.fg("muted", `  ${item.description}`);
+			this.listContainer.addChild(new Text(prefix + label + description, 1, 0));
+		}
+		if (items.length === 0) {
+			this.listContainer.addChild(new Text(this.theme.fg("warning", "  No matching models"), 1, 0));
+		}
+
+		this.listStartRow = PICKER_LIST_ROW;
+		const position = items.length === 0 ? "(0/0)" : `(${this.selectedIndex + 1}/${items.length})`;
+		this.listContainer.addChild(new Text(this.theme.fg("dim", `  ${position}`), 1, 0));
+	}
+
+	private move(delta: number): void {
+		const items = this.visibleItems();
+		if (items.length === 0) return;
+		this.selectedIndex = (this.selectedIndex + delta + items.length) % items.length;
+		this.updateList();
+		this.tui.requestRender();
+	}
+
+	private select(): void {
+		const items = this.visibleItems();
+		const item = items[this.selectedIndex];
+		if (!item) return;
+		if (item.value === OTHER_LABEL) {
+			const typed = this.input.getValue().trim();
+			if (typed === "") return;
+			this.done({ kind: "other", value: typed });
+			return;
+		}
+		this.done({ kind: "model", value: item.value });
+	}
+
+	render(width: number): string[] {
+		return this.container.render(width).map((line) => truncateToWidth(line, width, "…"));
+	}
+
+	invalidate(): void {
+		this.container.invalidate();
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, "up")) {
+			this.move(-1);
+			return;
+		}
+		if (matchesKey(data, "down")) {
+			this.move(1);
+			return;
+		}
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+			this.done({ kind: "cancel" });
+			return;
+		}
+		this.input.handleInput(data);
+		// A new query re-ranks the list, so the best match is selected.
+		if (this.input.getValue() !== this.lastQuery) {
+			this.lastQuery = this.input.getValue();
+			this.selectedIndex = 0;
+		}
+		this.updateList();
+		this.tui.requestRender();
+	}
+
+	private lastQuery = "";
+
+	handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+		const items = this.visibleItems();
+		if (items.length === 0) return undefined;
+		if (event.type === "wheel" && event.wheelDelta) {
+			this.move(event.wheelDelta < 0 ? -1 : 1);
+			return { handled: true, render: true };
+		}
+		if (event.button === "left" && (event.type === "press" || event.type === "click")) {
+			const index = this.listStartRow + event.y;
+			if (index < 0 || index >= items.length) return undefined;
+			this.selectedIndex = index;
+			if (event.type === "click") {
+				this.select();
+			} else {
+				this.updateList();
+				this.tui.requestRender();
+			}
+			return { handled: true, focus: true };
+		}
+		return undefined;
+	}
+}
+
+/** Row index of the first list entry (border, title, hint, search input). */
+const PICKER_LIST_ROW = 4;

package/lib/models.ts

@@ -0,0 +1,63 @@
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+export type ThinkingLevelName = (typeof THINKING_LEVELS)[number];
+
+export interface ModelLike {
+	id: string;
+	name: string;
+	provider: string;
+	reasoning?: boolean;
+	thinkingLevelMap?: Record<string, unknown> | null;
+}
+
+export const OTHER_OPTION = "Other… (enter provider/model manually)";
+
+/** Format a model as `provider/id` (the settings-file format). */
+export function modelRef(model: Pick<ModelLike, "provider" | "id">): string {
+	return `${model.provider}/${model.id}`;
+}
+
+/** Parse `provider/id`, `id`, optionally with a `:thinking` suffix. */
+export function parseModelRef(
+	ref: string,
+): { provider?: string; id: string; thinkingLevel?: string } | undefined {
+	const trimmed = ref.trim();
+	if (trimmed === "") return undefined;
+	let body = trimmed;
+	let thinkingLevel: string | undefined;
+	const colon = body.lastIndexOf(":");
+	if (colon > 0) {
+		const suffix = body.slice(colon + 1);
+		if ((THINKING_LEVELS as readonly string[]).includes(suffix)) {
+			thinkingLevel = suffix;
+			body = body.slice(0, colon);
+		}
+	}
+	const slash = body.indexOf("/");
+	if (slash > 0) {
+		return { provider: body.slice(0, slash), id: body.slice(slash + 1), thinkingLevel };
+	}
+	return { id: body, thinkingLevel };
+}
+
+/** Sort models by provider, then by name. */
+export function sortModels<T extends ModelLike>(models: readonly T[]): T[] {
+	return [...models].sort((a, b) => {
+		const byProvider = a.provider.localeCompare(b.provider);
+		if (byProvider !== 0) return byProvider;
+		return a.name.localeCompare(b.name);
+	});
+}
+
+/** Thinking levels a model supports (all levels when the model declares no map). */
+export function supportedThinkingLevels(model: ModelLike): ThinkingLevelName[] {
+	if (!model.reasoning) return ["off"];
+	const map = model.thinkingLevelMap as Record<string, unknown> | null | undefined;
+	if (!map) return [...THINKING_LEVELS];
+	return THINKING_LEVELS.filter((level) => map[level] !== null);
+}
+
+/** Label shown in the model picker. */
+export function modelOptionLabel(model: ModelLike, current?: ModelLike): string {
+	const currentMark = current && current.provider === model.provider && current.id === model.id ? " (current)" : "";
+	return `${model.provider}  ${model.name}  [${model.id}]${currentMark}`;
+}

package/lib/picker.ts

@@ -0,0 +1,67 @@
+import { fuzzyFilterItems } from "./fuzzy.ts";
+import { modelRef, sortModels, type ModelLike } from "./models.ts";
+
+export interface PickerItem {
+	/** `provider/model`, the value written to settings. */
+	value: string;
+	/** Primary column text. */
+	label: string;
+	/** Secondary column text (model id, markers). */
+	description: string;
+	/** Text the fuzzy search runs against. */
+	searchText: string;
+}
+
+/** Build picker items, current model first, then sorted by provider and name. */
+export function buildPickerItems(models: readonly ModelLike[], current?: ModelLike): PickerItem[] {
+	const sorted = sortModels(models);
+	return sorted.map((model) => {
+		const isCurrent = !!current && current.provider === model.provider && current.id === model.id;
+		const description = [model.id, isCurrent ? "current" : undefined].filter(Boolean).join("  ");
+		return {
+			value: modelRef(model),
+			label: model.name,
+			description,
+			searchText: `${model.provider} ${model.id} ${model.name}`.toLowerCase(),
+		};
+	});
+}
+
+/** Rank items against a search query. An empty query keeps the original order. */
+export function filterPickerItems(items: readonly PickerItem[], query: string): PickerItem[] {
+	return fuzzyFilterItems(items, query, (item) => item.searchText);
+}
+
+export interface VisibleRange {
+	start: number;
+	end: number;
+}
+
+/** Window of items to render so the selected item stays visible. */
+export function visibleRange(total: number, selected: number, maxVisible: number): VisibleRange {
+	if (total <= 0) return { start: 0, end: 0 };
+	const size = Math.max(1, Math.min(maxVisible, total));
+	const start = Math.max(0, Math.min(selected - Math.floor(size / 2), total - size));
+	return { start, end: Math.min(start + size, total) };
+}
+
+/** Rows used by everything except the list itself (title, search, hints, borders). */
+export const PICKER_CHROME_ROWS = 7;
+/** Hard cap on visible model rows, regardless of terminal size. */
+export const PICKER_MAX_ROWS = 15;
+
+/**
+ * How many model rows to show: the item count, capped, and never more than the
+ * terminal can display without pushing the picker off screen.
+ */
+export function pickerMaxVisible(itemCount: number, terminalRows: number, maxRows = PICKER_MAX_ROWS): number {
+	if (itemCount <= 0) return 0;
+	const byHeight = Math.max(3, terminalRows - PICKER_CHROME_ROWS);
+	return Math.max(1, Math.min(itemCount, maxRows, byHeight));
+}
+
+/** Clamp a selected index into the current item list. */
+export function clampIndex(index: number, total: number): number {
+	if (total <= 0) return 0;
+	return Math.max(0, Math.min(index, total - 1));
+}

package/lib/settings.ts

@@ -0,0 +1,83 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export interface ModelDefaults {
+	defaultProvider?: string;
+	defaultModel?: string;
+	defaultThinkingLevel?: string;
+}
+
+/** Resolve the pi agent directory (`PI_CODING_AGENT_DIR` or `~/.pi/agent`). */
+export function agentDir(env: NodeJS.ProcessEnv = process.env): string {
+	const configured = env.PI_CODING_AGENT_DIR;
+	if (configured && configured.trim() !== "") {
+		return expandHome(configured.trim(), env);
+	}
+	return join(homedir(), ".pi", "agent");
+}
+
+export function expandHome(path: string, env: NodeJS.ProcessEnv = process.env): string {
+	if (path === "~") return homedir();
+	if (path.startsWith("~/")) return join(homedir(), path.slice(2));
+	const home = env.HOME ?? env.USERPROFILE;
+	if (path.startsWith("~") && home) return join(home, path.slice(1));
+	return path;
+}
+
+export function globalSettingsPath(env: NodeJS.ProcessEnv = process.env): string {
+	return join(agentDir(env), "settings.json");
+}
+
+export function projectSettingsPath(cwd: string): string {
+	return join(cwd, ".pi", "settings.json");
+}
+
+/** Read a settings file, returning `{}` when it is missing or malformed. */
+export async function readSettings(file: string): Promise<Record<string, unknown>> {
+	let text: string;
+	try {
+		text = await readFile(file, "utf8");
+	} catch {
+		return {};
+	}
+	try {
+		const parsed: unknown = JSON.parse(text);
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+			return parsed as Record<string, unknown>;
+		}
+		return {};
+	} catch {
+		return {};
+	}
+}
+
+/** Merge `patch` into a settings file, preserving unrelated keys. Returns the merged object. */
+export async function writeSettings(file: string, patch: Record<string, unknown>): Promise<Record<string, unknown>> {
+	const current = await readSettings(file);
+	const next = { ...current, ...patch };
+	await mkdir(dirname(file), { recursive: true });
+	await writeFile(file, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+	return next;
+}
+
+/** Human-readable summary of the model-related keys in a settings object. */
+export function describeDefaults(settings: Record<string, unknown>): string {
+	const provider = typeof settings.defaultProvider === "string" ? settings.defaultProvider : undefined;
+	const model = typeof settings.defaultModel === "string" ? settings.defaultModel : undefined;
+	if (!provider && !model) return "(not set)";
+	const parts: string[] = [];
+	if (provider) parts.push(`defaultProvider=${provider}`);
+	if (model) parts.push(`defaultModel=${model}`);
+	if (typeof settings.defaultThinkingLevel === "string") parts.push(`defaultThinkingLevel=${settings.defaultThinkingLevel}`);
+	return parts.join("  ");
+}
+
+export function defaultsFromSettings(settings: Record<string, unknown>): ModelDefaults {
+	const out: ModelDefaults = {};
+	if (typeof settings.defaultProvider === "string") out.defaultProvider = settings.defaultProvider;
+	if (typeof settings.defaultModel === "string") out.defaultModel = settings.defaultModel;
+	if (typeof settings.defaultThinkingLevel === "string") out.defaultThinkingLevel = settings.defaultThinkingLevel;
+	return out;
+}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@faiku/pi-default-model-switcher",
+  "version": "0.0.1",
+  "author": "Faiku",
+  "private": false,
+  "type": "module",
+  "description": "Pi extension for switching the default startup model globally or per project",
+  "scripts": {
+    "test": "node --experimental-strip-types --test test/*.test.mjs",
+    "typecheck": "tsc -p tsconfig.json"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "^0.87.1",
+    "@types/node": "^22",
+    "typescript": "^5"
+  }
+}

package/test/extension.test.mjs

@@ -0,0 +1,119 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+	agentDir,
+	describeDefaults,
+	globalSettingsPath,
+	projectSettingsPath,
+	readSettings,
+	writeSettings,
+} from "../lib/settings.ts";
+import {
+	modelOptionLabel,
+	modelRef,
+	parseModelRef,
+	sortModels,
+	supportedThinkingLevels,
+	OTHER_OPTION,
+} from "../lib/models.ts";
+
+async function tmp() {
+	return mkdtemp(join(tmpdir(), "dms-test-"));
+}
+
+test("agentDir honors PI_CODING_AGENT_DIR", () => {
+	assert.equal(agentDir({ PI_CODING_AGENT_DIR: "/tmp/agent" }), "/tmp/agent");
+});
+
+test("agentDir falls back to ~/.pi/agent", () => {
+	assert.equal(agentDir({}), join(process.env.HOME ?? "", ".pi", "agent"));
+});
+
+test("settings paths are derived from agent dir and cwd", () => {
+	assert.equal(projectSettingsPath("/work/repo"), "/work/repo/.pi/settings.json");
+	assert.equal(globalSettingsPath({ PI_CODING_AGENT_DIR: "/tmp/agent" }), "/tmp/agent/settings.json");
+});
+
+test("writeSettings creates the file, merges, and keeps unrelated keys", async () => {
+	const dir = await tmp();
+	const file = join(dir, "nested", "settings.json");
+	const merged = await writeSettings(file, { defaultModel: "m1", defaultProvider: "p1" });
+	assert.deepEqual(merged, { defaultModel: "m1", defaultProvider: "p1" });
+
+	await writeSettings(file, { defaultThinkingLevel: "high" });
+	assert.deepEqual(await readSettings(file), {
+		defaultModel: "m1",
+		defaultProvider: "p1",
+		defaultThinkingLevel: "high",
+	});
+	const text = await readFile(file, "utf8");
+	assert.ok(text.endsWith("\n"));
+	assert.ok(text.includes('  "defaultModel": "m1"'));
+});
+
+test("readSettings tolerates missing and malformed files", async () => {
+	const dir = await tmp();
+	assert.deepEqual(await readSettings(join(dir, "missing.json")), {});
+	const bad = join(dir, "bad.json");
+	await writeSettings(bad, {});
+	const { writeFile } = await import("node:fs/promises");
+	await writeFile(bad, "{not json", "utf8");
+	assert.deepEqual(await readSettings(bad), {});
+});
+
+test("describeDefaults reports set and unset defaults", () => {
+	assert.equal(describeDefaults({}), "(not set)");
+	assert.equal(
+		describeDefaults({ defaultProvider: "anthropic", defaultModel: "sonnet", defaultThinkingLevel: "low" }),
+		"defaultProvider=anthropic  defaultModel=sonnet  defaultThinkingLevel=low",
+	);
+});
+
+test("parseModelRef handles provider/id, bare id, and thinking suffix", () => {
+	assert.deepEqual(parseModelRef(" anthropic/claude-sonnet-4-5 "), { provider: "anthropic", id: "claude-sonnet-4-5", thinkingLevel: undefined });
+	assert.deepEqual(parseModelRef("gpt-5"), { id: "gpt-5", thinkingLevel: undefined });
+	assert.deepEqual(parseModelRef("openai/gpt-5:high"), { provider: "openai", id: "gpt-5", thinkingLevel: "high" });
+	assert.equal(parseModelRef("   "), undefined);
+});
+
+test("parseModelRef keeps colons that are part of the model id", () => {
+	assert.deepEqual(parseModelRef("openrouter/some-model:exacto"), { provider: "openrouter", id: "some-model:exacto", thinkingLevel: undefined });
+});
+
+test("modelRef joins provider and id", () => {
+	assert.equal(modelRef({ provider: "anthropic", id: "claude-sonnet-4-5" }), "anthropic/claude-sonnet-4-5");
+});
+
+test("sortModels orders by provider then name", () => {
+	const sorted = sortModels([
+		{ provider: "openai", id: "b", name: "B" },
+		{ provider: "anthropic", id: "a2", name: "Zeta" },
+		{ provider: "anthropic", id: "a1", name: "Alpha" },
+	]);
+	assert.deepEqual(sorted.map((m) => `${m.provider}/${m.id}`), ["anthropic/a1", "anthropic/a2", "openai/b"]);
+});
+
+test("supportedThinkingLevels respects reasoning and the level map", () => {
+	assert.deepEqual(supportedThinkingLevels({ id: "m", name: "m", provider: "p" }), ["off"]);
+	assert.deepEqual(
+		supportedThinkingLevels({ id: "m", name: "m", provider: "p", reasoning: true }),
+		["off", "minimal", "low", "medium", "high", "xhigh", "max"],
+	);
+	assert.deepEqual(
+		supportedThinkingLevels({ id: "m", name: "m", provider: "p", reasoning: true, thinkingLevelMap: { off: 0, minimal: null, low: 1, medium: null, high: null, xhigh: null, max: null } }),
+		["off", "low"],
+	);
+});
+
+test("modelOptionLabel marks the current model", () => {
+	const current = { provider: "anthropic", id: "sonnet", name: "Sonnet" };
+	const label = modelOptionLabel(current, current);
+	assert.match(label, /\(current\)$/);
+	assert.match(label, /\[sonnet\]/);
+	assert.doesNotMatch(modelOptionLabel({ provider: "openai", id: "gpt", name: "GPT" }, current), /current/);
+	assert.notEqual(OTHER_OPTION, "");
+});

package/test/picker.test.mjs

@@ -0,0 +1,90 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { fuzzyFilterItems, fuzzyScore } from "../lib/fuzzy.ts";
+import {
+	buildPickerItems,
+	clampIndex,
+	filterPickerItems,
+	PICKER_CHROME_ROWS,
+	PICKER_MAX_ROWS,
+	pickerMaxVisible,
+	visibleRange,
+} from "../lib/picker.ts";
+
+const models = [
+	{ provider: "openai", id: "gpt-5", name: "GPT-5", reasoning: true },
+	{ provider: "anthropic", id: "claude-sonnet-4-5", name: "Claude Sonnet 4.5", reasoning: true },
+	{ provider: "anthropic", id: "claude-haiku-4-5", name: "Claude Haiku 4.5", reasoning: false },
+	{ provider: "openrouter", id: "~anthropic/claude-opus-latest", name: "Claude Opus (latest)", reasoning: true },
+];
+
+test("fuzzyScore matches subsequences and rejects misses", () => {
+	assert.equal(fuzzyScore("", "anything"), 0);
+	assert.equal(fuzzyScore("   ", "anything"), 0);
+	assert.notEqual(fuzzyScore("sonnet", "claude sonnet 4.5"), undefined);
+	assert.notEqual(fuzzyScore("claude sonnet", "claude sonnet 4.5"), undefined);
+	assert.equal(fuzzyScore("zzz", "claude sonnet"), undefined);
+	// tokens must appear in order
+	assert.equal(fuzzyScore("sonnet claude", "claude sonnet"), undefined);
+});
+
+test("fuzzyScore prefers earlier and tighter matches", () => {
+	assert.ok(fuzzyScore("sonnet", "claude sonnet 4.5") < fuzzyScore("sonnet", "claude haiku sonnet preview"));
+});
+
+test("fuzzyFilterItems keeps input order for an empty query and ranks matches otherwise", () => {
+	const all = fuzzyFilterItems(models, "", (m) => m.id);
+	assert.deepEqual(all, models);
+	const ranked = fuzzyFilterItems(models, "opus", (m) => `${m.provider} ${m.id} ${m.name}`);
+	assert.ok(ranked.length >= 1);
+	assert.equal(ranked[0].id, "~anthropic/claude-opus-latest");
+});
+
+test("buildPickerItems sorts by provider and marks the current model", () => {
+	const items = buildPickerItems(models, { provider: "openai", id: "gpt-5", name: "GPT-5" });
+	assert.deepEqual(items.map((i) => i.value), [
+		"anthropic/claude-haiku-4-5",
+		"anthropic/claude-sonnet-4-5",
+		"openai/gpt-5",
+		"openrouter/~anthropic/claude-opus-latest",
+	]);
+	const current = items.find((i) => i.value === "openai/gpt-5");
+	assert.match(current.description, /current/);
+	assert.ok(!items[0].description.includes("current"));
+	// search text covers provider, id and name
+	assert.ok(items[0].searchText.includes("claude haiku"));
+});
+
+test("filterPickerItems matches on provider, id, and name", () => {
+	const items = buildPickerItems(models);
+	assert.equal(filterPickerItems(items, "gpt-5")[0].value, "openai/gpt-5");
+	assert.equal(filterPickerItems(items, "haiku")[0].value, "anthropic/claude-haiku-4-5");
+	assert.equal(filterPickerItems(items, "openrouter")[0].value, "openrouter/~anthropic/claude-opus-latest");
+	assert.equal(filterPickerItems(items, "nothing-here").length, 0);
+});
+
+test("visibleRange keeps the selection inside the window", () => {
+	assert.deepEqual(visibleRange(0, 0, 10), { start: 0, end: 0 });
+	assert.deepEqual(visibleRange(5, 0, 10), { start: 0, end: 5 });
+	assert.deepEqual(visibleRange(20, 0, 10), { start: 0, end: 10 });
+	assert.deepEqual(visibleRange(20, 19, 10), { start: 10, end: 20 });
+	assert.deepEqual(visibleRange(20, 10, 10), { start: 5, end: 15 });
+});
+
+test("pickerMaxVisible never exceeds the item count, the cap, or the terminal", () => {
+	assert.equal(pickerMaxVisible(0, 40), 0);
+	assert.equal(pickerMaxVisible(3, 40), 3);
+	assert.equal(pickerMaxVisible(100, 200), PICKER_MAX_ROWS);
+	// A short terminal clamps the window so the overlay still fits.
+	assert.equal(pickerMaxVisible(100, PICKER_CHROME_ROWS + 4), 4);
+	assert.equal(pickerMaxVisible(100, 4), 3, "minimum of three rows");
+	assert.equal(pickerMaxVisible(100, 200, 8), 8);
+});
+
+test("clampIndex keeps the selection in range", () => {
+	assert.equal(clampIndex(-5, 3), 0);
+	assert.equal(clampIndex(9, 3), 2);
+	assert.equal(clampIndex(1, 3), 1);
+	assert.equal(clampIndex(4, 0), 0);
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "types": ["node"],
+    "lib": ["es2023"]
+  },
+  "include": ["index.ts", "lib/**/*.ts"]
+}