@oh-my-pi/pi-coding-agent 10.6.0 → 10.6.2

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [10.6.1] - 2026-02-04
+
+### Added
+
+- Added `commit` model role for dedicated commit message generation
+- Exported `resolveModelOverride` function from model resolver for external use
+
+### Changed
+
+- Updated model role resolution to accept optional `roleOrder` parameter for custom role priority
+- Made `tag` and `color` properties optional in `ModelRoleInfo` interface
+- Updated model selector to safely handle roles without tag or color definitions
+- Refactored role label display to use centralized `MODEL_ROLES` registry instead of hardcoded strings
+- Refactored model role system to use centralized `MODEL_ROLES` registry with consistent tag, name, and color definitions
+- Simplified model role resolution to use `MODEL_ROLE_IDS` array instead of hardcoded role checks
+- Updated model selector to dynamically generate menu actions from `MODEL_ROLES` registry
+
+### Removed
+
+- Removed support for `omp/` model role prefix; use `pi/` prefix instead
+
 ## [10.6.0] - 2026-02-04
 ### Breaking Changes
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "10.6.0",
+	"version": "10.6.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -80,12 +80,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "0.6.0",
-		"@oh-my-pi/omp-stats": "10.6.0",
-		"@oh-my-pi/pi-agent-core": "10.6.0",
-		"@oh-my-pi/pi-ai": "10.6.0",
-		"@oh-my-pi/pi-natives": "10.6.0",
-		"@oh-my-pi/pi-tui": "10.6.0",
-		"@oh-my-pi/pi-utils": "10.6.0",
+		"@oh-my-pi/omp-stats": "10.6.2",
+		"@oh-my-pi/pi-agent-core": "10.6.2",
+		"@oh-my-pi/pi-ai": "10.6.2",
+		"@oh-my-pi/pi-natives": "10.6.2",
+		"@oh-my-pi/pi-tui": "10.6.2",
+		"@oh-my-pi/pi-utils": "10.6.2",
 		"@openai/agents": "^0.4.5",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",

package/src/commit/model-selection.ts

@@ -1,5 +1,12 @@
 import type { Api, Model } from "@oh-my-pi/pi-ai";
-import { parseModelPattern, parseModelString, SMOL_MODEL_PRIORITY } from "../config/model-resolver";
+import { MODEL_ROLE_IDS } from "../config/model-registry";
+import {
+	expandRoleAlias,
+	parseModelPattern,
+	resolveModelFromSettings,
+	resolveModelFromString,
+	SMOL_MODEL_PRIORITY,
+} from "../config/model-resolver";
 import type { Settings } from "../config/settings";
 
 export async function resolvePrimaryModel(
@@ -12,9 +19,15 @@ export async function resolvePrimaryModel(
 ): Promise<{ model: Model<Api>; apiKey: string }> {
 	const available = modelRegistry.getAvailable();
 	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
+	const roleOrder = ["commit", "smol", ...MODEL_ROLE_IDS] as const;
 	const model = override
 		? resolveModelFromString(expandRoleAlias(override, settings), available, matchPreferences)
-		: resolveModelFromSettings(settings, available, matchPreferences);
+		: resolveModelFromSettings({
+				settings,
+				availableModels: available,
+				matchPreferences,
+				roleOrder,
+			});
 	if (!model) {
 		throw new Error("No model available for commit generation");
 	}
@@ -37,7 +50,9 @@ export async function resolveSmolModel(
 	const available = modelRegistry.getAvailable();
 	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
 	const role = settings.getModelRole("smol");
-	const roleModel = role ? resolveModelFromString(role, available, matchPreferences) : undefined;
+	const roleModel = role
+		? resolveModelFromString(expandRoleAlias(role, settings), available, matchPreferences)
+		: undefined;
 	if (roleModel) {
 		const apiKey = await modelRegistry.getApiKey(roleModel);
 		if (apiKey) return { model: roleModel, apiKey };
@@ -52,39 +67,3 @@ export async function resolveSmolModel(
 
 	return { model: fallbackModel, apiKey: fallbackApiKey };
 }
-
-function resolveModelFromSettings(
-	settings: Settings,
-	available: Model<Api>[],
-	matchPreferences: { usageOrder?: string[] },
-): Model<Api> | undefined {
-	const roles = ["commit", "smol", "default"];
-	for (const role of roles) {
-		const configured = settings.getModelRole(role);
-		if (!configured) continue;
-		const resolved = resolveModelFromString(expandRoleAlias(configured, settings), available, matchPreferences);
-		if (resolved) return resolved;
-	}
-	return available[0];
-}
-
-function resolveModelFromString(
-	value: string,
-	available: Model<Api>[],
-	matchPreferences: { usageOrder?: string[] },
-): Model<Api> | undefined {
-	const parsed = parseModelString(value);
-	if (parsed) {
-		return available.find(model => model.provider === parsed.provider && model.id === parsed.id);
-	}
-	return parseModelPattern(value, available, matchPreferences).model;
-}
-
-function expandRoleAlias(value: string, settings: Settings): string {
-	const lower = value.toLowerCase();
-	if (lower.startsWith("pi/") || lower.startsWith("omp/")) {
-		const role = lower.startsWith("pi/") ? value.slice(3) : value.slice(4);
-		return settings.getModelRole(role) ?? value;
-	}
-	return value;
-}

package/src/config/model-registry.ts

@@ -15,8 +15,27 @@ import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import AjvModule from "ajv";
 import { YAML } from "bun";
+import type { ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage } from "../session/auth-storage";
 
+export type ModelRole = "default" | "smol" | "slow" | "plan" | "commit";
+
+export interface ModelRoleInfo {
+	tag?: string;
+	name: string;
+	color?: ThemeColor;
+}
+
+export const MODEL_ROLES: Record<ModelRole, ModelRoleInfo> = {
+	default: { tag: "DEFAULT", name: "Default", color: "success" },
+	smol: { tag: "SMOL", name: "Fast", color: "warning" },
+	slow: { tag: "SLOW", name: "Thinking", color: "accent" },
+	plan: { tag: "PLAN", name: "Architect", color: "muted" },
+	commit: { name: "Commit" },
+};
+
+export const MODEL_ROLE_IDS: ModelRole[] = ["default", "smol", "slow", "plan", "commit"];
+
 const Ajv = (AjvModule as any).default || AjvModule;
 
 const OpenRouterRoutingSchema = Type.Object({

package/src/config/model-resolver.ts

@@ -6,7 +6,8 @@ import { type Api, type KnownProvider, type Model, modelsAreEqual } from "@oh-my
 import chalk from "chalk";
 import { isValidThinkingLevel } from "../cli/args";
 import { fuzzyMatch } from "../utils/fuzzy";
-import type { ModelRegistry } from "./model-registry";
+import { MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "./model-registry";
+import type { Settings } from "./settings";
 
 /** Default model IDs for each known provider */
 export const defaultModelPerProvider: Record<KnownProvider, string> = {
@@ -310,6 +311,96 @@ export function parseModelPattern(
 	return parseModelPatternWithContext(pattern, availableModels, context);
 }
 
+const PREFIX_MODEL_ROLE = "pi/";
+const DEFAULT_MODEL_ROLE = "default";
+
+/**
+ * Check if a model override value is effectively the default role.
+ */
+export function isDefaultModelAlias(value: string | string[] | undefined): boolean {
+	if (!value) return true;
+	if (Array.isArray(value)) return value.every(entry => isDefaultModelAlias(entry));
+	if (value.startsWith(PREFIX_MODEL_ROLE)) {
+		value = value.slice(PREFIX_MODEL_ROLE.length);
+	}
+	return value === DEFAULT_MODEL_ROLE;
+}
+
+/**
+ * Expand a role alias like "pi/smol" to the configured model string.
+ */
+export function expandRoleAlias(value: string, settings?: Settings): string {
+	const normalized = value.trim();
+	if (normalized === "default") return settings?.getModelRole("default") ?? value;
+	if (!normalized.startsWith(PREFIX_MODEL_ROLE)) return value;
+	const role = normalized.slice(PREFIX_MODEL_ROLE.length) as ModelRole;
+	if (!MODEL_ROLE_IDS.includes(role)) return value;
+	return settings?.getModelRole(role) ?? value;
+}
+
+/**
+ * Resolve a model identifier or pattern to a Model instance.
+ */
+export function resolveModelFromString(
+	value: string,
+	available: Model<Api>[],
+	matchPreferences?: ModelMatchPreferences,
+): Model<Api> | undefined {
+	const parsed = parseModelString(value);
+	if (parsed) {
+		return available.find(model => model.provider === parsed.provider && model.id === parsed.id);
+	}
+	return parseModelPattern(value, available, matchPreferences).model;
+}
+
+/**
+ * Resolve a model from configured roles, honoring order and overrides.
+ */
+export function resolveModelFromSettings(options: {
+	settings: Settings;
+	availableModels: Model<Api>[];
+	matchPreferences?: ModelMatchPreferences;
+	roleOrder?: readonly ModelRole[];
+}): Model<Api> | undefined {
+	const { settings, availableModels, matchPreferences, roleOrder } = options;
+	const roles = roleOrder ?? MODEL_ROLE_IDS;
+	for (const role of roles) {
+		const configured = settings.getModelRole(role);
+		if (!configured) continue;
+		const resolved = resolveModelFromString(expandRoleAlias(configured, settings), availableModels, matchPreferences);
+		if (resolved) return resolved;
+	}
+	return availableModels[0];
+}
+
+/**
+ * Resolve a list of override patterns to the first matching model.
+ */
+export function resolveModelOverride(
+	modelPatterns: string[],
+	modelRegistry: ModelRegistry,
+	settings?: Settings,
+): { model?: Model<Api>; thinkingLevel?: ThinkingLevel } {
+	if (modelPatterns.length === 0) return {};
+	const matchPreferences = { usageOrder: settings?.getStorage()?.getModelUsageOrder() };
+	for (const pattern of modelPatterns) {
+		const normalized = pattern.trim();
+		if (!normalized || isDefaultModelAlias(normalized)) {
+			continue;
+		}
+		const effectivePattern = expandRoleAlias(pattern, settings);
+		const { model, thinkingLevel } = parseModelPattern(
+			effectivePattern,
+			modelRegistry.getAvailable(),
+			matchPreferences,
+		);
+		if (model) {
+			return { model, thinkingLevel: thinkingLevel !== "off" ? thinkingLevel : undefined };
+		}
+	}
+	return {};
+}
+
 /**
  * Resolve model patterns to actual Model objects with optional thinking levels
  * Format: "pattern:level" where :level is optional

package/src/config/settings.ts

@@ -13,6 +13,7 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
+import type { ModelRole } from "@oh-my-pi/pi-coding-agent/config/model-registry";
 import { isEnoent, logger, procmgr } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
 import { type Settings as SettingsCapabilityItem, settingsCapability } from "../capability/settings";
@@ -387,7 +388,7 @@ export class Settings {
 	/**
 	 * Set a model role (helper for modelRoles record).
 	 */
-	setModelRole(role: string, modelId: string): void {
+	setModelRole(role: ModelRole | string, modelId: string): void {
 		const current = this.get("modelRoles");
 		this.set("modelRoles", { ...current, [role]: modelId });
 	}
@@ -395,11 +396,31 @@ export class Settings {
 	/**
 	 * Get a model role (helper for modelRoles record).
 	 */
-	getModelRole(role: string): string | undefined {
+	getModelRole(role: ModelRole | string): string | undefined {
 		const roles = this.get("modelRoles");
 		return roles[role];
 	}
 
+	/**
+	 * Get all model roles (helper for modelRoles record).
+	 */
+	getModelRoles(): ReadOnlyDict<string> {
+		return this.get("modelRoles");
+	}
+
+	/*
+	 * Override model roles (helper for modelRoles record).
+	 */
+	overrideModelRoles(roles: ReadOnlyDict<string>): void {
+		const prev = this.get("modelRoles");
+		for (const [role, modelId] of Object.entries(roles)) {
+			if (modelId) {
+				prev[role] = modelId;
+			}
+		}
+		this.set("modelRoles", prev);
+	}
+
 	/**
 	 * Set disabled providers (for compatibility with discovery system).
 	 */

package/src/extensibility/custom-tools/types.ts

@@ -51,7 +51,7 @@ export interface CustomToolContext {
 	/** Model registry - use for API key resolution and model retrieval */
 	modelRegistry: ModelRegistry;
 	/** Current model (may be undefined if no model is selected yet) */
-	model: Model<any> | undefined;
+	model: Model | undefined;
 	/** Whether the agent is idle (not streaming) */
 	isIdle(): boolean;
 	/** Whether there are queued messages waiting to be processed */

package/src/extensibility/extensions/loader.ts

@@ -206,7 +206,7 @@ class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 		return this.runtime.setActiveTools(toolNames);
 	}
 
-	setModel(model: Model<any>): Promise<boolean> {
+	setModel(model: Model): Promise<boolean> {
 		return this.runtime.setModel(model);
 	}
 

package/src/extensibility/extensions/runner.ts

@@ -112,7 +112,7 @@ export class ExtensionRunner {
 	private sessionManager: SessionManager;
 	private modelRegistry: ModelRegistry;
 	private errorListeners: Set<ExtensionErrorListener> = new Set();
-	private getModel: () => Model<any> | undefined = () => undefined;
+	private getModel: () => Model | undefined = () => undefined;
 	private isIdleFn: () => boolean = () => true;
 	private waitForIdleFn: () => Promise<void> = async () => {};
 	private abortFn: () => void = () => {};

package/src/extensibility/extensions/types.ts

@@ -162,7 +162,7 @@ export interface ExtensionContext {
 	/** Model registry for API key resolution */
 	modelRegistry: ModelRegistry;
 	/** Current model (may be undefined) */
-	model: Model<any> | undefined;
+	model: Model | undefined;
 	/** Whether the agent is idle (not streaming) */
 	isIdle(): boolean;
 	/** Abort the current agent operation */
@@ -776,7 +776,7 @@ export interface ExtensionAPI {
 	setActiveTools(toolNames: string[]): Promise<void>;
 
 	/** Set the current model. Returns false if no API key available. */
-	setModel(model: Model<any>): Promise<boolean>;
+	setModel(model: Model): Promise<boolean>;
 
 	/** Get current thinking level. */
 	getThinkingLevel(): ThinkingLevel;
@@ -835,7 +835,7 @@ export type GetAllToolsHandler = () => string[];
 
 export type SetActiveToolsHandler = (toolNames: string[]) => Promise<void>;
 
-export type SetModelHandler = (model: Model<any>) => Promise<boolean>;
+export type SetModelHandler = (model: Model) => Promise<boolean>;
 
 export type GetThinkingLevelHandler = () => ThinkingLevel;
 
@@ -862,7 +862,7 @@ export interface ExtensionActions {
 
 /** Actions for ExtensionContext (ctx.* in event handlers). */
 export interface ExtensionContextActions {
-	getModel: () => Model<any> | undefined;
+	getModel: () => Model | undefined;
 	isIdle: () => boolean;
 	abort: () => void;
 	hasPendingMessages: () => boolean;

package/src/extensibility/hooks/runner.ts

@@ -69,7 +69,7 @@ export class HookRunner {
 	private sessionManager: SessionManager;
 	private modelRegistry: ModelRegistry;
 	private errorListeners: Set<HookErrorListener> = new Set();
-	private getModel: () => Model<any> | undefined = () => undefined;
+	private getModel: () => Model | undefined = () => undefined;
 	private isIdleFn: () => boolean = () => true;
 	private waitForIdleFn: () => Promise<void> = async () => {};
 	private abortFn: () => void = () => {};
@@ -93,7 +93,7 @@ export class HookRunner {
 	 */
 	initialize(options: {
 		/** Function to get the current model */
-		getModel: () => Model<any> | undefined;
+		getModel: () => Model | undefined;
 		/** Handler for hooks to send messages */
 		sendMessageHandler: SendMessageHandler;
 		/** Handler for hooks to append entries */

package/src/extensibility/hooks/types.ts

@@ -147,7 +147,7 @@ export interface HookContext {
 	/** Model registry - use for API key resolution and model retrieval */
 	modelRegistry: ModelRegistry;
 	/** Current model (may be undefined if no model is selected yet) */
-	model: Model<any> | undefined;
+	model: Model | undefined;
 	/** Whether the agent is idle (not streaming) */
 	isIdle(): boolean;
 	/** Abort the current agent operation (fire-and-forget, does not wait) */

package/src/main.ts

@@ -391,8 +391,7 @@ async function buildSessionOptions(
 			process.exit(1);
 		}
 		options.model = model;
-		const currentRoles = settings.get("modelRoles") as Record<string, string>;
-		settings.override("modelRoles", { ...currentRoles, default: `${model.provider}/${model.id}` });
+		settings.overrideModelRoles({ default: `${model.provider}/${model.id}` });
 	} else if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
 		const remembered = settings.getModelRole("default");
 		if (remembered) {

package/src/modes/components/model-selector.ts

@@ -11,7 +11,7 @@ import {
 	type TUI,
 	visibleWidth,
 } from "@oh-my-pi/pi-tui";
-import type { ModelRegistry } from "../../config/model-registry";
+import { MODEL_ROLE_IDS, MODEL_ROLES, type ModelRegistry, type ModelRole } from "../../config/model-registry";
 import { parseModelString } from "../../config/model-resolver";
 import type { Settings } from "../../config/settings";
 import { type ThemeColor, theme } from "../../modes/theme/theme";
@@ -27,27 +27,20 @@ function makeInvertedBadge(label: string, color: ThemeColor): string {
 interface ModelItem {
 	provider: string;
 	id: string;
-	model: Model<any>;
+	model: Model;
 }
 
 interface ScopedModelItem {
-	model: Model<any>;
+	model: Model;
 	thinkingLevel: string;
 }
 
-type ModelRole = "default" | "smol" | "slow" | "plan" | "temporary";
-
 interface MenuAction {
 	label: string;
 	role: ModelRole;
 }
 
-const MENU_ACTIONS: MenuAction[] = [
-	{ label: "Set as Default", role: "default" },
-	{ label: "Set as Smol (Fast)", role: "smol" },
-	{ label: "Set as Slow (Thinking)", role: "slow" },
-	{ label: "Set as Plan (Architect)", role: "plan" },
-];
+const MENU_ACTIONS: MenuAction[] = MODEL_ROLE_IDS.map(role => ({ label: `Set as ${MODEL_ROLES[role].name}`, role }));
 
 const ALL_TAB = "ALL";
 
@@ -76,13 +69,10 @@ export class ModelSelectorComponent extends Container {
 	private allModels: ModelItem[] = [];
 	private filteredModels: ModelItem[] = [];
 	private selectedIndex: number = 0;
-	private defaultModel?: Model<any>;
-	private smolModel?: Model<any>;
-	private slowModel?: Model<any>;
-	private planModel?: Model<any>;
+	private roles: { [key in ModelRole]?: Model } = {};
 	private settings: Settings;
 	private modelRegistry: ModelRegistry;
-	private onSelectCallback: (model: Model<any>, role: string) => void;
+	private onSelectCallback: (model: Model, role: ModelRole | null) => void;
 	private onCancelCallback: () => void;
 	private errorMessage?: string;
 	private tui: TUI;
@@ -99,11 +89,11 @@ export class ModelSelectorComponent extends Container {
 
 	constructor(
 		tui: TUI,
-		_currentModel: Model<any> | undefined,
+		_currentModel: Model | undefined,
 		settings: Settings,
 		modelRegistry: ModelRegistry,
 		scopedModels: ReadonlyArray<ScopedModelItem>,
-		onSelect: (model: Model<any>, role: string) => void,
+		onSelect: (model: Model, role: ModelRole | null) => void,
 		onCancel: () => void,
 		options?: { temporaryOnly?: boolean; initialSearchInput?: string },
 	) {
@@ -182,42 +172,16 @@ export class ModelSelectorComponent extends Container {
 	}
 
 	private _loadRoleModels(): void {
-		const roles = this.settings.get("modelRoles") as Record<string, string>;
 		const allModels = this.modelRegistry.getAll();
-
-		// Load default model
-		const defaultStr = roles.default;
-		if (defaultStr) {
-			const parsed = parseModelString(defaultStr);
-			if (parsed) {
-				this.defaultModel = allModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
-			}
-		}
-
-		// Load smol model
-		const smolStr = roles.smol;
-		if (smolStr) {
-			const parsed = parseModelString(smolStr);
-			if (parsed) {
-				this.smolModel = allModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
-			}
-		}
-
-		// Load slow model
-		const slowStr = roles.slow;
-		if (slowStr) {
-			const parsed = parseModelString(slowStr);
-			if (parsed) {
-				this.slowModel = allModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
-			}
-		}
-
-		// Load plan model
-		const planStr = roles.plan;
-		if (planStr) {
-			const parsed = parseModelString(planStr);
+		for (const role of MODEL_ROLE_IDS) {
+			const modelId = this.settings.getModelRole(role);
+			if (!modelId) continue;
+			const parsed = parseModelString(modelId);
 			if (parsed) {
-				this.planModel = allModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
+				const model = allModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
+				if (model) {
+					this.roles[role] = model;
+				}
 			}
 		}
 	}
@@ -227,30 +191,25 @@ export class ModelSelectorComponent extends Container {
 		const mruOrder = this.settings.getStorage()?.getModelUsageOrder() ?? [];
 		const mruIndex = new Map(mruOrder.map((key, i) => [key, i]));
 
+		const modelRank = (model: ModelItem) => {
+			let i = 0;
+			while (i < MODEL_ROLE_IDS.length) {
+				const role = MODEL_ROLE_IDS[i];
+				if (this.roles[role] && modelsAreEqual(this.roles[role], model.model)) {
+					break;
+				}
+				i++;
+			}
+			return i;
+		};
+
 		models.sort((a, b) => {
 			const aKey = `${a.provider}/${a.id}`;
 			const bKey = `${b.provider}/${b.id}`;
 
-			// Tagged models first: default (0), smol (1), slow (2), plan (3), untagged (4)
-			const aTag = modelsAreEqual(this.defaultModel, a.model)
-				? 0
-				: modelsAreEqual(this.smolModel, a.model)
-					? 1
-					: modelsAreEqual(this.slowModel, a.model)
-						? 2
-						: modelsAreEqual(this.planModel, a.model)
-							? 3
-							: 4;
-			const bTag = modelsAreEqual(this.defaultModel, b.model)
-				? 0
-				: modelsAreEqual(this.smolModel, b.model)
-					? 1
-					: modelsAreEqual(this.slowModel, b.model)
-						? 2
-						: modelsAreEqual(this.planModel, b.model)
-							? 3
-							: 4;
-			if (aTag !== bTag) return aTag - bTag;
+			const aRank = modelRank(a);
+			const bRank = modelRank(b);
+			if (aRank !== bRank) return aRank - bRank;
 
 			// Then MRU order (models in mruIndex come before those not in it)
 			const aMru = mruIndex.get(aKey) ?? Number.MAX_SAFE_INTEGER;
@@ -287,7 +246,7 @@ export class ModelSelectorComponent extends Container {
 			// Load available models (built-in models still work even if models.json failed)
 			try {
 				const availableModels = this.modelRegistry.getAvailable();
-				models = availableModels.map((model: Model<any>) => ({
+				models = availableModels.map((model: Model) => ({
 					provider: model.provider,
 					id: model.id,
 					model,
@@ -392,17 +351,15 @@ export class ModelSelectorComponent extends Container {
 			if (!item) continue;
 
 			const isSelected = i === this.selectedIndex;
-			const isDefault = modelsAreEqual(this.defaultModel, item.model);
-			const isSmol = modelsAreEqual(this.smolModel, item.model);
-			const isSlow = modelsAreEqual(this.slowModel, item.model);
-			const isPlan = modelsAreEqual(this.planModel, item.model);
 
 			// Build role badges (inverted: color as background, black text)
 			const badges: string[] = [];
-			if (isDefault) badges.push(makeInvertedBadge("DEFAULT", "success"));
-			if (isSmol) badges.push(makeInvertedBadge("SMOL", "warning"));
-			if (isSlow) badges.push(makeInvertedBadge("SLOW", "accent"));
-			if (isPlan) badges.push(makeInvertedBadge("PLAN", "muted"));
+			for (const role of MODEL_ROLE_IDS) {
+				const { tag, color } = MODEL_ROLES[role];
+				if (tag && modelsAreEqual(this.roles[role], item.model)) {
+					badges.push(makeInvertedBadge(tag, color ?? "success"));
+				}
+			}
 			const badgeText = badges.length > 0 ? ` ${badges.join(" ")}` : "";
 
 			let line = "";
@@ -533,7 +490,7 @@ export class ModelSelectorComponent extends Container {
 			if (selectedModel) {
 				if (this.temporaryOnly) {
 					// In temporary mode, skip menu and select directly
-					this.handleSelect(selectedModel.model, "temporary");
+					this.handleSelect(selectedModel.model, null);
 				} else {
 					this.openMenu();
 				}
@@ -585,10 +542,10 @@ export class ModelSelectorComponent extends Container {
 		}
 	}
 
-	private handleSelect(model: Model<any>, role: ModelRole): void {
+	private handleSelect(model: Model, role: ModelRole | null): void {
 		// For temporary role, don't save to settings - just notify caller
-		if (role === "temporary") {
-			this.onSelectCallback(model, role);
+		if (role === null) {
+			this.onSelectCallback(model, null);
 			return;
 		}
 
@@ -596,15 +553,7 @@ export class ModelSelectorComponent extends Container {
 		this.settings.setModelRole(role, `${model.provider}/${model.id}`);
 
 		// Update local state for UI
-		if (role === "default") {
-			this.defaultModel = model;
-		} else if (role === "smol") {
-			this.smolModel = model;
-		} else if (role === "slow") {
-			this.slowModel = model;
-		} else if (role === "plan") {
-			this.planModel = model;
-		}
+		this.roles[role] = model;
 
 		// Notify caller (for updating agent state if needed)
 		this.onSelectCallback(model, role);

package/src/modes/controllers/input-controller.ts

@@ -649,7 +649,7 @@ export class InputController {
 
 	async cycleRoleModel(options?: { temporary?: boolean }): Promise<void> {
 		try {
-			const roleOrder = ["slow", "default", "smol"];
+			const roleOrder = ["slow", "default", "smol"] as const;
 			const result = await this.ctx.session.cycleRoleModels(roleOrder, options);
 			if (!result) {
 				this.ctx.showStatus("Only one role model available");

package/src/modes/controllers/selector-controller.ts

@@ -3,6 +3,7 @@ import type { OAuthProvider } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Input, Loader, Spacer, Text } from "@oh-my-pi/pi-tui";
 import { getAgentDbPath } from "../../config";
+import { MODEL_ROLES } from "../../config/model-registry";
 import { settings } from "../../config/settings";
 import { DebugSelectorComponent } from "../../debug";
 import { disableProvider, enableProvider } from "../../discovery";
@@ -277,7 +278,7 @@ export class SelectorController {
 				this.ctx.session.scopedModels,
 				async (model, role) => {
 					try {
-						if (role === "temporary") {
+						if (role === null) {
 							// Temporary: update agent state but don't persist to settings
 							await this.ctx.session.setModelTemporary(model);
 							this.ctx.statusLine.invalidate();
@@ -294,7 +295,8 @@ export class SelectorController {
 							// Don't call done() - selector stays open for role assignment
 						} else {
 							// Other roles (smol, slow): just update settings, not current model
-							const roleLabel = role === "smol" ? "Smol" : role;
+							const roleInfo = MODEL_ROLES[role];
+							const roleLabel = roleInfo?.name ?? role;
 							this.ctx.showStatus(`${roleLabel} model: ${model.id}`);
 							// Don't call done() - selector stays open
 						}

package/src/modes/interactive-mode.ts

@@ -137,7 +137,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	private readonly version: string;
 	private readonly changelogMarkdown: string | undefined;
 	private planModePreviousTools: string[] | undefined;
-	private planModePreviousModel: Model<any> | undefined;
+	private planModePreviousModel: Model | undefined;
 	private planModeHasEntered = false;
 	public readonly lspServers:
 		| Array<{ name: string; status: "ready" | "error"; fileTypes: string[]; error?: string }>

package/src/modes/rpc/rpc-types.ts

@@ -68,7 +68,7 @@ export type RpcCommand =
 // ============================================================================
 
 export interface RpcSessionState {
-	model?: Model<any>;
+	model?: Model;
 	thinkingLevel: ThinkingLevel;
 	isStreaming: boolean;
 	isCompacting: boolean;
@@ -105,21 +105,21 @@ export type RpcResponse =
 			type: "response";
 			command: "set_model";
 			success: true;
-			data: Model<any>;
+			data: Model;
 	  }
 	| {
 			id?: string;
 			type: "response";
 			command: "cycle_model";
 			success: true;
-			data: { model: Model<any>; thinkingLevel: ThinkingLevel; isScoped: boolean } | null;
+			data: { model: Model; thinkingLevel: ThinkingLevel; isScoped: boolean } | null;
 	  }
 	| {
 			id?: string;
 			type: "response";
 			command: "get_available_models";
 			success: true;
-			data: { models: Model<any>[] };
+			data: { models: Model[] };
 	  }
 
 	// Thinking

package/src/prompts/agents/explore.md

@@ -2,7 +2,7 @@
 name: explore
 description: Fast read-only codebase scout returning compressed context for handoff
 tools: read, grep, find, ls, bash
-model: pi/smol, haiku, flash, mini
+model: pi/smol, haiku-4.5, haiku-4-5, gemini-flash-latest, gemini-3-flash, zai-glm-4.7, glm-4.7-flash, glm-4.5-flash, gpt-5.1-codex-mini, haiku, flash, mini
 output:
   properties:
     query:
@@ -108,4 +108,4 @@ Infer from task; default medium:
 
 <critical>
 Call `submit_result` with findings when done.
-</critical>
+</critical>

package/src/sdk.ts

@@ -131,11 +131,11 @@ export interface CreateAgentSessionOptions {
 	modelRegistry?: ModelRegistry;
 
 	/** Model to use. Default: from settings, else first available */
-	model?: Model<any>;
+	model?: Model;
 	/** Thinking level. Default: from settings, else 'off' (clamped to model capabilities) */
 	thinkingLevel?: ThinkingLevel;
 	/** Models available for cycling (Ctrl+P in interactive mode) */
-	scopedModels?: Array<{ model: Model<any>; thinkingLevel: ThinkingLevel }>;
+	scopedModels?: Array<{ model: Model; thinkingLevel: ThinkingLevel }>;
 
 	/** System prompt. String replaces default, function receives default and returns final. */
 	systemPrompt?: string | ((defaultPrompt: string) => string);

package/src/session/agent-session.ts

@@ -32,7 +32,7 @@ import { abortableSleep, isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
 import type { Rule } from "../capability/rule";
 import { getAgentDbPath } from "../config";
-import type { ModelRegistry } from "../config/model-registry";
+import { MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "../config/model-registry";
 import { parseModelString } from "../config/model-resolver";
 import {
 	expandPromptTemplate,
@@ -127,7 +127,7 @@ export interface AgentSessionConfig {
 	sessionManager: SessionManager;
 	settings: Settings;
 	/** Models to cycle through with Ctrl+P (from --models flag) */
-	scopedModels?: Array<{ model: Model<any>; thinkingLevel: ThinkingLevel }>;
+	scopedModels?: Array<{ model: Model; thinkingLevel: ThinkingLevel }>;
 	/** Prompt templates for expansion */
 	promptTemplates?: PromptTemplate[];
 	/** File-based slash commands for expansion */
@@ -167,7 +167,7 @@ export interface PromptOptions {
 
 /** Result from cycleModel() */
 export interface ModelCycleResult {
-	model: Model<any>;
+	model: Model;
 	thinkingLevel: ThinkingLevel;
 	/** Whether cycling through scoped models (--models flag) or all available */
 	isScoped: boolean;
@@ -175,9 +175,9 @@ export interface ModelCycleResult {
 
 /** Result from cycleRoleModels() */
 export interface RoleModelCycleResult {
-	model: Model<any>;
+	model: Model;
 	thinkingLevel: ThinkingLevel;
-	role: string;
+	role: ModelRole;
 }
 
 /** Session statistics for /session command */
@@ -257,7 +257,7 @@ export class AgentSession {
 	readonly sessionManager: SessionManager;
 	readonly settings: Settings;
 
-	private _scopedModels: Array<{ model: Model<any>; thinkingLevel: ThinkingLevel }>;
+	private _scopedModels: Array<{ model: Model; thinkingLevel: ThinkingLevel }>;
 	private _promptTemplates: PromptTemplate[];
 	private _slashCommands: FileSlashCommand[];
 
@@ -887,7 +887,7 @@ export class AgentSession {
 	}
 
 	/** Current model (may be undefined if not yet selected) */
-	get model(): Model<any> | undefined {
+	get model(): Model | undefined {
 		return this.agent.state.model;
 	}
 
@@ -994,7 +994,7 @@ export class AgentSession {
 	}
 
 	/** Scoped models for cycling (from --models flag) */
-	get scopedModels(): ReadonlyArray<{ model: Model<any>; thinkingLevel: ThinkingLevel }> {
+	get scopedModels(): ReadonlyArray<{ model: Model; thinkingLevel: ThinkingLevel }> {
 		return this._scopedModels;
 	}
 
@@ -1014,7 +1014,7 @@ export class AgentSession {
 		this._planReferenceSent = true;
 	}
 
-	resolveRoleModel(role: string): Model<any> | undefined {
+	resolveRoleModel(role: ModelRole): Model | undefined {
 		return this._resolveRoleModel(role, this._modelRegistry.getAvailable(), this.model);
 	}
 
@@ -1800,7 +1800,7 @@ export class AgentSession {
 	 * Validates API key, saves to session and settings.
 	 * @throws Error if no API key available for the model
 	 */
-	async setModel(model: Model<any>, role: string = "default"): Promise<void> {
+	async setModel(model: Model, role: ModelRole = "default"): Promise<void> {
 		const apiKey = await this._modelRegistry.getApiKey(model, this.sessionId);
 		if (!apiKey) {
 			throw new Error(`No API key for ${model.provider}/${model.id}`);
@@ -1820,7 +1820,7 @@ export class AgentSession {
 	 * Validates API key, saves to session log but NOT to settings.
 	 * @throws Error if no API key available for the model
 	 */
-	async setModelTemporary(model: Model<any>): Promise<void> {
+	async setModelTemporary(model: Model): Promise<void> {
 		const apiKey = await this._modelRegistry.getApiKey(model, this.sessionId);
 		if (!apiKey) {
 			throw new Error(`No API key for ${model.provider}/${model.id}`);
@@ -1854,7 +1854,7 @@ export class AgentSession {
 	 * @param options - Optional settings: `temporary` to not persist to settings
 	 */
 	async cycleRoleModels(
-		roleOrder: string[],
+		roleOrder: readonly ModelRole[],
 		options?: { temporary?: boolean },
 	): Promise<RoleModelCycleResult | undefined> {
 		const availableModels = this._modelRegistry.getAvailable();
@@ -1862,7 +1862,7 @@ export class AgentSession {
 
 		const currentModel = this.model;
 		if (!currentModel) return undefined;
-		const roleModels: Array<{ role: string; model: Model<any> }> = [];
+		const roleModels: Array<{ role: ModelRole; model: Model }> = [];
 
 		for (const role of roleOrder) {
 			const roleModelStr =
@@ -1872,7 +1872,7 @@ export class AgentSession {
 			if (!roleModelStr) continue;
 
 			const parsed = parseModelString(roleModelStr);
-			let match: Model<any> | undefined;
+			let match: Model | undefined;
 			if (parsed) {
 				match = availableModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
 			}
@@ -1964,7 +1964,7 @@ export class AgentSession {
 	/**
 	 * Get all available models with valid API keys.
 	 */
-	getAvailableModels(): Model<any>[] {
+	getAvailableModels(): Model[] {
 		return this._modelRegistry.getAvailable();
 	}
 
@@ -2530,15 +2530,15 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		this.agent.continue().catch(() => {});
 	}
 
-	private _getModelKey(model: Model<any>): string {
+	private _getModelKey(model: Model): string {
 		return `${model.provider}/${model.id}`;
 	}
 
 	private _resolveRoleModel(
-		role: string,
-		availableModels: Model<any>[],
-		currentModel: Model<any> | undefined,
-	): Model<any> | undefined {
+		role: ModelRole,
+		availableModels: Model[],
+		currentModel: Model | undefined,
+	): Model | undefined {
 		const roleModelStr =
 			role === "default"
 				? (this.settings.getModelRole("default") ??
@@ -2555,11 +2555,11 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		return availableModels.find(m => m.id.toLowerCase() === roleLower);
 	}
 
-	private _getCompactionModelCandidates(availableModels: Model<any>[]): Model<any>[] {
-		const candidates: Model<any>[] = [];
+	private _getCompactionModelCandidates(availableModels: Model[]): Model[] {
+		const candidates: Model[] = [];
 		const seen = new Set<string>();
 
-		const addCandidate = (model: Model<any> | undefined): void => {
+		const addCandidate = (model: Model | undefined): void => {
 			if (!model) return;
 			const key = this._getModelKey(model);
 			if (seen.has(key)) return;
@@ -2568,10 +2568,9 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		};
 
 		const currentModel = this.model;
-		addCandidate(this._resolveRoleModel("default", availableModels, currentModel));
-		addCandidate(this._resolveRoleModel("slow", availableModels, currentModel));
-		addCandidate(this._resolveRoleModel("small", availableModels, currentModel));
-		addCandidate(this._resolveRoleModel("smol", availableModels, currentModel));
+		for (const role of MODEL_ROLE_IDS) {
+			addCandidate(this._resolveRoleModel(role, availableModels, currentModel));
+		}
 
 		const sortedByContext = [...availableModels].sort((a, b) => b.contextWindow - a.contextWindow);
 		for (const model of sortedByContext) {

package/src/session/compaction/branch-summarization.ts

@@ -66,7 +66,7 @@ export interface CollectEntriesResult {
 
 export interface GenerateBranchSummaryOptions {
 	/** Model to use for summarization */
-	model: Model<any>;
+	model: Model;
 	/** API key for the model */
 	apiKey: string;
 	/** Abort signal for cancellation */

package/src/session/compaction/compaction.ts

@@ -478,7 +478,7 @@ export interface SummaryOptions {
 
 export async function generateSummary(
 	currentMessages: AgentMessage[],
-	model: Model<any>,
+	model: Model,
 	reserveTokens: number,
 	apiKey: string,
 	signal?: AbortSignal,
@@ -547,7 +547,7 @@ export async function generateSummary(
 async function generateShortSummary(
 	recentMessages: AgentMessage[],
 	historySummary: string | undefined,
-	model: Model<any>,
+	model: Model,
 	reserveTokens: number,
 	apiKey: string,
 	signal?: AbortSignal,
@@ -724,7 +724,7 @@ const TURN_PREFIX_SUMMARIZATION_PROMPT = renderPromptTemplate(compactionTurnPref
  */
 export async function compact(
 	preparation: CompactionPreparation,
-	model: Model<any>,
+	model: Model,
 	apiKey: string,
 	customInstructions?: string,
 	signal?: AbortSignal,
@@ -822,7 +822,7 @@ export async function compact(
  */
 async function generateTurnPrefixSummary(
 	messages: AgentMessage[],
-	model: Model<any>,
+	model: Model,
 	reserveTokens: number,
 	apiKey: string,
 	signal?: AbortSignal,

package/src/task/executor.ts

@@ -10,7 +10,7 @@ import { logger, untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import Ajv, { type ValidateFunction } from "ajv";
 import type { ModelRegistry } from "../config/model-registry";
-import { parseModelPattern } from "../config/model-resolver";
+import { resolveModelOverride } from "../config/model-resolver";
 import { type PromptTemplate, renderPromptTemplate } from "../config/prompt-templates";
 import { Settings } from "../config/settings";
 import type { CustomTool } from "../extensibility/custom-tools/types";
@@ -39,7 +39,6 @@ import {
 	TASK_SUBAGENT_PROGRESS_CHANNEL,
 } from "./types";
 
-const DEFAULT_MODEL_ALIASES = new Set(["default", "pi/default", "omp/default"]);
 const MCP_CALL_TIMEOUT_MS = 60_000;
 const ajv = new Ajv({ allErrors: true, strict: false });
 
@@ -129,39 +128,6 @@ function getReportFindingKey(value: unknown): string | null {
 	return `${filePath}:${lineStart}:${lineEnd}:${priority ?? ""}:${title}`;
 }
 
-function resolveModelOverride(
-	modelPatterns: string[],
-	modelRegistry: ModelRegistry,
-	settings?: Settings,
-): { model?: Model<Api>; thinkingLevel?: ThinkingLevel } {
-	if (modelPatterns.length === 0) return {};
-	const matchPreferences = { usageOrder: settings?.getStorage()?.getModelUsageOrder() };
-	const roles = settings?.getGroup("modelRoles");
-	for (const pattern of modelPatterns) {
-		const normalized = pattern.trim().toLowerCase();
-		if (!normalized || DEFAULT_MODEL_ALIASES.has(normalized)) {
-			continue;
-		}
-		let effectivePattern = pattern;
-		if (normalized.startsWith("omp/") || normalized.startsWith("pi/")) {
-			const role = normalized.startsWith("omp/") ? pattern.slice(4) : pattern.slice(3);
-			const configured = roles?.[role] ?? roles?.[role.toLowerCase()];
-			if (configured) {
-				effectivePattern = configured;
-			}
-		}
-		const { model, thinkingLevel } = parseModelPattern(
-			effectivePattern,
-			modelRegistry.getAvailable(),
-			matchPreferences,
-		);
-		if (model) {
-			return { model, thinkingLevel: thinkingLevel !== "off" ? thinkingLevel : undefined };
-		}
-	}
-	return {};
-}
-
 function buildSubmitResultToolChoice(model?: Model<Api>): ToolChoice | undefined {
 	if (!model) return undefined;
 	if (

package/src/task/index.ts

@@ -20,6 +20,7 @@ import type { Usage } from "@oh-my-pi/pi-ai";
 import { $ } from "bun";
 import { nanoid } from "nanoid";
 import type { ToolSession } from "..";
+import { isDefaultModelAlias } from "../config/model-resolver";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { Theme } from "../modes/theme/theme";
 import planModeSubagentPrompt from "../prompts/system/plan-mode-subagent.md" with { type: "text" };
@@ -165,16 +166,6 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 		const { agent: agentName, context, schema: outputSchema, isolated } = params;
 		const isIsolated = isolated === true;
 
-		const isDefaultModelAlias = (value: string | string[] | undefined): boolean => {
-			if (!value) return true;
-			const values = Array.isArray(value) ? value : [value];
-			if (values.length === 0) return true;
-			return values.every(entry => {
-				const normalized = entry.trim().toLowerCase();
-				return normalized === "default" || normalized === "pi/default" || normalized === "omp/default";
-			});
-		};
-
 		// Validate agent exists
 		const agent = getAgent(agents, agentName);
 		if (!agent) {