@oh-my-pi/pi-coding-agent 10.5.0 → 10.6.1

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/tools/grep.md

@@ -6,17 +6,13 @@ Powerful search tool built on ripgrep.
 - Supports full regex syntax (e.g., `log.*Error`, `function\\s+\\w+`)
 - Filter files with `glob` (e.g., `*.js`, `**/*.tsx`) or `type` (e.g., `js`, `py`, `rust`)
 - Pattern syntax uses ripgrep—literal braces need escaping (`interface\\{\\}` to find `interface{}` in Go)
-- For cross-line patterns like `struct \\{[\\s\\S]*?field`, use `multiline: true`
+- For cross-line patterns like `struct \\{[\\s\\S]*?field`, set `multiline: true` if needed
+- If the pattern contains a literal `\n`, multiline defaults to true
 </instruction>
 
 <output>
-Results depend on `output_mode`:
-- `content`: Matching lines with file paths and line numbers
-- `files_with_matches`: File paths only (one per line)
-- `count`: Match counts per file
-
-In `content` mode, truncated at 100 matches default (configurable via `limit`).
-For `files_with_matches` and `count` modes, use `limit` truncate results.
+Results are always content mode: matching lines with file paths and line numbers.
+Truncated at 100 matches by default (configurable via `limit`).
 </output>
 
 <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) {