@oh-my-pi/pi-coding-agent 16.2.9 → 16.2.12

package/src/config/model-resolver.ts

@@ -4,8 +4,8 @@
  * Layering:
  * - `matchModel` is the single matching engine. Order: exact `provider/id`
  *   reference (with variant-alias and OpenRouter routed/date fallbacks) →
- *   exact canonical id → exact bare id → retired variant alias →
- *   provider-scoped fuzzy → substring with alias-vs-dated pick.
+ *   exact bare id → retired variant alias → provider-scoped fuzzy → substring
+ *   with alias-vs-dated pick.
  * - `parseModelPatternWithContext`/`parseModelPattern` layer the selector
  *   grammar on top: trailing `:level` thinking suffixes (`splitThinkingSuffix`)
  *   and `@upstream` provider routing (`splitUpstreamRouting`).
@@ -107,13 +107,6 @@ function splitThinkingSuffix(
 	return level ? { base: pattern.slice(0, colonIdx), level } : { base: pattern };
 }
 
-function hasExactModelPattern(pattern: string, availableModels: readonly Model<Api>[]): boolean {
-	const normalized = pattern.toLowerCase();
-	return availableModels.some(
-		model => model.id.toLowerCase() === normalized || `${model.provider}/${model.id}`.toLowerCase() === normalized,
-	);
-}
-
 function matchingGlobModels(pattern: string, availableModels: readonly Model<Api>[]): Model<Api>[] {
 	const glob = new Bun.Glob(pattern.toLowerCase());
 	return availableModels.filter(model => {
@@ -444,11 +437,8 @@ export interface ModelMatchPreferences {
 	deprioritizeProviders?: string[];
 }
 
-export type CanonicalModelRegistry = Partial<
-	Pick<ModelRegistry, "resolveCanonicalModel" | "getCanonicalVariants" | "getCanonicalId">
->;
-export type ModelLookupRegistry = Pick<ModelRegistry, "getAvailable"> & Partial<CanonicalModelRegistry>;
-type CliModelRegistry = Pick<ModelRegistry, "getAll"> & Partial<CanonicalModelRegistry>;
+export type ModelLookupRegistry = Pick<ModelRegistry, "getAvailable">;
+type CliModelRegistry = Pick<ModelRegistry, "getAll">;
 type InitialModelRegistry = Pick<ModelRegistry, "getAvailable" | "find">;
 type RestorableModelRegistry = Pick<ModelRegistry, "getAvailable" | "find" | "getApiKey">;
 
@@ -579,7 +569,6 @@ function includeSyntheticAllowedModels(available: Model<Api>[], allowedModels: I
 
 /**
  * Find an exact explicit provider/model match.
- * Bare model ids are handled separately so canonical ids can coalesce variants.
  */
 function findExactModelReferenceMatch(modelReference: string, availableModels: Model<Api>[]): Model<Api> | undefined {
 	const trimmedReference = modelReference.trim();
@@ -597,52 +586,25 @@ function findExactModelReferenceMatch(modelReference: string, availableModels: M
 	}
 	return undefined;
 }
-
-function findExactCanonicalModelMatch(
-	modelReference: string,
-	availableModels: Model<Api>[],
-	modelRegistry: CanonicalModelRegistry | undefined,
-): Model<Api> | undefined {
-	if (!modelRegistry) {
-		return undefined;
-	}
-	const trimmedReference = modelReference.trim();
-	if (!trimmedReference || trimmedReference.includes("/")) {
-		return undefined;
-	}
-	return modelRegistry.resolveCanonicalModel?.(trimmedReference, {
-		availableOnly: false,
-		candidates: availableModels,
-	});
-}
-
 /**
  * The single model-matching engine. Tries, in order:
  * 1. exact `provider/id` reference (variant-alias and OpenRouter routed/date
  *    fallbacks included),
-
- * 2. exact canonical id (coalesces provider variants),
- * 3. exact bare id (preference-ranked),
- * 4. retired effort-tier variant alias (collapsed catalog entries),
- * 5. provider-scoped fuzzy match,
- * 6. substring match with the alias-vs-dated pick.
+ * 2. exact bare id (preference-ranked),
+ * 3. retired effort-tier variant alias (collapsed catalog entries),
+ * 4. provider-scoped fuzzy match,
+ * 5. substring match with the alias-vs-dated pick.
  * Returns the matched model or undefined if no match found.
  */
 function matchModel(
 	modelPattern: string,
 	availableModels: Model<Api>[],
 	context: ModelPreferenceContext,
-	options?: { modelRegistry?: CanonicalModelRegistry },
 ): Model<Api> | undefined {
 	const exactRefMatch = findExactModelReferenceMatch(modelPattern, availableModels);
 	if (exactRefMatch) {
 		return exactRefMatch;
 	}
-	// Exact canonical ids coalesce provider variants before bare-id matching.
-	const exactCanonicalMatch = findExactCanonicalModelMatch(modelPattern, availableModels, options?.modelRegistry);
-	if (exactCanonicalMatch) {
-		return exactCanonicalMatch;
-	}
 
 	// Exact ID match (case-insensitive) — this must happen before provider-scoped
 	// fuzzy matching so raw IDs that contain slashes (for example OpenRouter model
@@ -773,10 +735,10 @@ function parseModelPatternWithContext(
 	pattern: string,
 	availableModels: Model<Api>[],
 	context: ModelPreferenceContext,
-	options?: { allowInvalidThinkingSelectorFallback?: boolean; modelRegistry?: CanonicalModelRegistry },
+	options?: { allowInvalidThinkingSelectorFallback?: boolean },
 ): ParsedModelResult {
 	// Try exact match first
-	const exactMatch = matchModel(pattern, availableModels, context, options);
+	const exactMatch = matchModel(pattern, availableModels, context);
 	if (exactMatch) {
 		return { model: exactMatch, thinkingLevel: undefined, warning: undefined, explicitThinkingLevel: false };
 	}
@@ -830,7 +792,7 @@ export function parseModelPattern(
 	pattern: string,
 	availableModels: Model<Api>[],
 	preferences?: ModelMatchPreferences,
-	options?: { allowInvalidThinkingSelectorFallback?: boolean; modelRegistry?: CanonicalModelRegistry },
+	options?: { allowInvalidThinkingSelectorFallback?: boolean },
 ): ParsedModelResult {
 	const context = buildPreferenceContext(availableModels, preferences);
 	const direct = parseModelPatternWithContext(pattern, availableModels, context, options);
@@ -1035,7 +997,7 @@ export interface ResolvedModelRoleValue {
 export function resolveModelRoleValue(
 	roleValue: string | undefined,
 	availableModels: Model<Api>[],
-	options?: { settings?: Settings; matchPreferences?: ModelMatchPreferences; modelRegistry?: CanonicalModelRegistry },
+	options?: { settings?: Settings; matchPreferences?: ModelMatchPreferences },
 ): ResolvedModelRoleValue {
 	if (!roleValue) {
 		return { model: undefined, thinkingLevel: undefined, explicitThinkingLevel: false, warning: undefined };
@@ -1054,9 +1016,7 @@ export function resolveModelRoleValue(
 	let warning: string | undefined;
 	const matchPreferences = mergeModelMatchPreferences(options?.settings, options?.matchPreferences);
 	for (const effectivePattern of effectivePatterns) {
-		const resolved = parseModelPattern(effectivePattern, availableModels, matchPreferences, {
-			modelRegistry: options?.modelRegistry,
-		});
+		const resolved = parseModelPattern(effectivePattern, availableModels, matchPreferences);
 		if (resolved.model) {
 			return {
 				model: resolved.model,
@@ -1121,7 +1081,6 @@ export function resolveModelFromString(
 	value: string,
 	available: Model<Api>[],
 	matchPreferences?: ModelMatchPreferences,
-	modelRegistry?: CanonicalModelRegistry,
 ): Model<Api> | undefined {
 	const exact = available.find(model => `${model.provider}/${model.id}` === value);
 	if (exact) return exact;
@@ -1133,7 +1092,7 @@ export function resolveModelFromString(
 		const parsedExact = available.find(model => model.provider === parsed.provider && model.id === parsed.id);
 		if (parsedExact) return parsedExact;
 	}
-	return parseModelPattern(value, available, matchPreferences, { modelRegistry }).model;
+	return parseModelPattern(value, available, matchPreferences).model;
 }
 
 /**
@@ -1144,9 +1103,8 @@ export function resolveModelFromSettings(options: {
 	availableModels: Model<Api>[];
 	matchPreferences?: ModelMatchPreferences;
 	roleOrder?: readonly ModelRole[];
-	modelRegistry?: CanonicalModelRegistry;
 }): Model<Api> | undefined {
-	const { settings, availableModels, matchPreferences, roleOrder, modelRegistry } = options;
+	const { settings, availableModels, matchPreferences, roleOrder } = options;
 	const roles = roleOrder ?? MODEL_ROLE_IDS;
 	let sawConfiguredProviderQualifiedRole = false;
 	for (const role of roles) {
@@ -1156,7 +1114,7 @@ export function resolveModelFromSettings(options: {
 		if (expanded.includes("/")) {
 			sawConfiguredProviderQualifiedRole = true;
 		}
-		const resolved = resolveModelFromString(expanded, availableModels, matchPreferences, modelRegistry);
+		const resolved = resolveModelFromString(expanded, availableModels, matchPreferences);
 		if (resolved) return resolved;
 	}
 	return sawConfiguredProviderQualifiedRole ? undefined : availableModels[0];
@@ -1177,7 +1135,6 @@ export function resolveModelOverride(
 		const { model, thinkingLevel, explicitThinkingLevel } = resolveModelRoleValue(pattern, availableModels, {
 			settings,
 			matchPreferences,
-			modelRegistry,
 		});
 		if (model) {
 			return { model, thinkingLevel, explicitThinkingLevel };
@@ -1250,14 +1207,12 @@ export function resolveRoleSelection(
 	roles: readonly string[],
 	settings: Settings,
 	availableModels: Model<Api>[],
-	modelRegistry?: CanonicalModelRegistry,
 ): { model: Model<Api>; thinkingLevel?: ThinkingLevel } | undefined {
 	const matchPreferences = getModelMatchPreferences(settings);
 	for (const role of roles) {
 		const resolved = resolveModelRoleValue(settings.getModelRole(role), availableModels, {
 			settings,
 			matchPreferences,
-			modelRegistry,
 		});
 		if (resolved.model) {
 			return { model: resolved.model, thinkingLevel: resolved.thinkingLevel };
@@ -1277,37 +1232,14 @@ export function resolveRoleSelection(
 export function resolveAdvisorRoleSelection(
 	settings: Settings,
 	availableModels: Model<Api>[],
-	modelRegistry?: CanonicalModelRegistry,
 ): { model: Model<Api>; thinkingLevel?: ThinkingLevel } | undefined {
 	const resolved = resolveModelRoleValue(`${PREFIX_MODEL_ROLE}advisor`, availableModels, {
 		settings,
 		matchPreferences: getModelMatchPreferences(settings),
-		modelRegistry,
 	});
 	return resolved.model ? { model: resolved.model, thinkingLevel: resolved.thinkingLevel } : undefined;
 }
 
-function resolveExactCanonicalScopePattern(
-	pattern: string,
-	modelRegistry: Pick<ModelRegistry, "getCanonicalVariants">,
-	availableModels: Model<Api>[],
-): { models: Model<Api>[]; thinkingLevel?: ThinkingLevel; explicitThinkingLevel: boolean } | undefined {
-	if (pattern.endsWith(":max") && hasExactModelPattern(pattern, availableModels)) {
-		return undefined;
-	}
-	const { base: canonicalId, level: thinkingLevel } = splitThinkingSuffix(pattern, -1, MAX_THINKING_SUFFIX_OPTIONS);
-	const explicitThinkingLevel = thinkingLevel !== undefined;
-
-	const variants = modelRegistry
-		.getCanonicalVariants(canonicalId, { availableOnly: true, candidates: availableModels })
-		.map(variant => variant.model);
-	if (variants.length === 0) {
-		return undefined;
-	}
-
-	return { models: variants, thinkingLevel, explicitThinkingLevel };
-}
-
 /**
  * Resolve model patterns to actual Model objects with optional thinking levels
  * Format: "pattern:level" where :level is optional
@@ -1321,7 +1253,7 @@ function resolveExactCanonicalScopePattern(
  */
 export async function resolveModelScope(
 	patterns: string[],
-	modelRegistry: Pick<ModelRegistry, "getAvailable" | "getCanonicalVariants">,
+	modelRegistry: Pick<ModelRegistry, "getAvailable">,
 	preferences?: ModelMatchPreferences,
 ): Promise<ScopedModel[]> {
 	const availableModels = modelRegistry.getAvailable();
@@ -1360,19 +1292,10 @@ export async function resolveModelScope(
 			continue;
 		}
 
-		const exactCanonical = resolveExactCanonicalScopePattern(pattern, modelRegistry, availableModels);
-		if (exactCanonical) {
-			for (const model of exactCanonical.models) {
-				addScopedModel(model, exactCanonical.thinkingLevel, exactCanonical.explicitThinkingLevel);
-			}
-			continue;
-		}
-
 		const { model, thinkingLevel, warning, explicitThinkingLevel } = parseModelPatternWithContext(
 			pattern,
 			availableModels,
 			context,
-			{ modelRegistry },
 		);
 
 		if (warning) {
@@ -1403,7 +1326,7 @@ export async function resolveModelScope(
  * falling back to the global default (see issue #1022).
  */
 export async function resolveAllowedModels(
-	modelRegistry: Pick<ModelRegistry, "getAvailable" | "getCanonicalVariants">,
+	modelRegistry: Pick<ModelRegistry, "getAvailable">,
 	settings: Settings | undefined,
 	preferences?: ModelMatchPreferences,
 ): Promise<Model<Api>[]> {
@@ -1429,7 +1352,6 @@ export async function resolveAllowedModels(
  * `enabledModels` scope semantics as startup resolution:
  *
  * - Glob selectors match `provider/modelId` and bare model id
- * - Exact canonical ids expand to all available concrete variants
  * - Exact `provider/modelId`, bare ids, provider-scoped fuzzy, and substring selectors
  *   resolve through the shared model-pattern matcher
  * - Optional `:thinkingLevel` suffixes are stripped only when valid
@@ -1442,7 +1364,6 @@ export async function resolveAllowedModels(
 export function filterAvailableModelsByEnabledPatterns(
 	available: Model<Api>[],
 	patterns: readonly string[],
-	registry: Pick<ModelRegistry, "getCanonicalVariants">,
 ): Model<Api>[] {
 	if (patterns.length === 0) return available;
 
@@ -1460,15 +1381,7 @@ export function filterAvailableModelsByEnabledPatterns(
 			continue;
 		}
 
-		const exactCanonical = resolveExactCanonicalScopePattern(pattern, registry, available);
-		if (exactCanonical) {
-			for (const model of exactCanonical.models) {
-				addAllowed(model);
-			}
-			continue;
-		}
-
-		const { model } = parseModelPatternWithContext(pattern, available, context, { modelRegistry: registry });
+		const { model } = parseModelPatternWithContext(pattern, available, context);
 		if (model) {
 			addAllowed(model);
 		}
@@ -1533,21 +1446,6 @@ export function resolveCliModel(options: {
 		// "zai/glm-5" on provider "vercel-ai-gateway" wins over provider "zai"
 		// with id "glm-5", because Array.find returns the first catalog hit.
 		let exact = findExactModelReferenceMatch(trimmedModel, availableModels);
-		if (!exact && !trimmedModel.includes(":")) {
-			// CLI flags address the full catalog, so unlike the engine's canonical
-			// step this lookup is unrestricted; the `:`-guard defers suffixed
-			// selectors (thinking levels, ollama-style ids) to the grammar below.
-			const canonicalMatch = modelRegistry.resolveCanonicalModel?.(trimmedModel, { availableOnly: false });
-			if (canonicalMatch) {
-				return {
-					model: canonicalMatch,
-					selector: modelRegistry.getCanonicalId?.(canonicalMatch) ?? trimmedModel,
-					warning: undefined,
-					thinkingLevel: undefined,
-					error: undefined,
-				};
-			}
-		}
 		if (!exact) {
 			// Flat exact id (or full selector) by catalog order: CLI resolution
 			// stays deterministic across runs regardless of usage-based ranking.
@@ -1601,7 +1499,6 @@ export function resolveCliModel(options: {
 	const candidates = provider ? availableModels.filter(model => model.provider === provider) : availableModels;
 	const { model, thinkingLevel, warning, upstream } = parseModelPattern(pattern, candidates, preferences, {
 		allowInvalidThinkingSelectorFallback: false,
-		modelRegistry,
 	});
 
 	if (!model) {
@@ -1616,15 +1513,6 @@ export function resolveCliModel(options: {
 	}
 
 	let selector = provider ? formatModelString(model) : undefined;
-	if (!provider) {
-		const canonicalCandidate = splitThinkingSuffix(pattern).base;
-		if (!canonicalCandidate.includes("/")) {
-			const canonicalResolved = modelRegistry.resolveCanonicalModel?.(canonicalCandidate, { availableOnly: false });
-			if (canonicalResolved && canonicalResolved.provider === model.provider && canonicalResolved.id === model.id) {
-				selector = modelRegistry.getCanonicalId?.(canonicalResolved) ?? canonicalCandidate;
-			}
-		}
-	}
 	if (selector !== undefined && upstream) {
 		selector = `${selector}@${upstream}`;
 	}
@@ -1801,7 +1689,7 @@ export async function findSmolModel(
 
 	// 1. Try saved model from settings
 	if (savedModel) {
-		const match = resolveModelFromString(savedModel, availableModels, undefined, modelRegistry);
+		const match = resolveModelFromString(savedModel, availableModels, undefined);
 		if (match) return match;
 	}
 
@@ -1812,7 +1700,7 @@ export async function findSmolModel(
 		if (providerMatch) return providerMatch;
 
 		// Try exact match first
-		const exactMatch = parseModelPattern(pattern, availableModels, undefined, { modelRegistry }).model;
+		const exactMatch = parseModelPattern(pattern, availableModels, undefined).model;
 		if (exactMatch) return exactMatch;
 
 		// Try fuzzy match (substring)
@@ -1841,14 +1729,14 @@ export async function findSlowModel(
 
 	// 1. Try saved model from settings
 	if (savedModel) {
-		const match = resolveModelFromString(savedModel, availableModels, undefined, modelRegistry);
+		const match = resolveModelFromString(savedModel, availableModels, undefined);
 		if (match) return match;
 	}
 
 	// 2. Try priority chain
 	for (const pattern of MODEL_PRIO.slow) {
 		// Try exact match first
-		const exactMatch = parseModelPattern(pattern, availableModels, undefined, { modelRegistry }).model;
+		const exactMatch = parseModelPattern(pattern, availableModels, undefined).model;
 		if (exactMatch) return exactMatch;
 
 		// Try fuzzy match (substring)

package/src/config/models-config-schema.ts

@@ -273,30 +273,8 @@ const ProviderConfigSchema = type({
 	return true;
 });
 
-const EquivalenceConfigSchema = type({
-	"overrides?": { "[string]": "string" },
-	"exclude?": "string[]",
-}).narrow((value, ctx) => {
-	if (value.overrides !== undefined) {
-		for (const [, v] of Object.entries(value.overrides)) {
-			if (typeof v === "string" && v.length === 0) {
-				return ctx.mustBe("overrides values non-empty strings");
-			}
-		}
-	}
-	if (value.exclude !== undefined && Array.isArray(value.exclude)) {
-		for (const item of value.exclude) {
-			if (typeof item === "string" && item.length === 0) {
-				return ctx.mustBe("exclude items non-empty strings");
-			}
-		}
-	}
-	return true;
-});
-
 export const ModelsConfigSchema = type({
 	"providers?": { "[string]": ProviderConfigSchema },
-	"equivalence?": EquivalenceConfigSchema,
 });
 
 export type ModelsConfig = typeof ModelsConfigSchema.infer;

package/src/config/prompt-templates.ts

@@ -29,6 +29,26 @@ prompt.registerHelper("jtdToTypeScript", (schema: unknown): string => {
 	}
 });
 
+/**
+ * Render a subagent output schema wrapped in the `yield` tool's
+ * `result: { data: … }` envelope so the model sees the shape it must
+ * actually submit, not just the user-facing payload. Without this the LLM
+ * pattern-matches on the bare interface and puts strings/objects directly
+ * in `result.data`, tripping schema validation repeatedly.
+ */
+prompt.registerHelper("renderYieldSchema", (schema: unknown): string => {
+	let ts: string;
+	try {
+		ts = jtdToTypeScript(schema);
+	} catch {
+		ts = "unknown";
+	}
+	const lines = ts.split("\n");
+	const [first, ...rest] = lines;
+	const body = rest.length === 0 ? first : `${first}\n${rest.map(l => `  ${l}`).join("\n")}`;
+	return `result: {\n  data: ${body};\n}`;
+});
+
 const INLINE_ARG_SHELL_PATTERN = /\$(?:ARGUMENTS|@(?:\[\d+(?::\d*)?\])?|\d+)/;
 const INLINE_ARG_TEMPLATE_PATTERN = /\{\{[\s\S]*?(?:\b(?:arguments|ARGUMENTS|args)\b|\barg\s+[^}]+)[\s\S]*?\}\}/;
 

package/src/config/settings-schema.ts

@@ -285,6 +285,7 @@ const EMPTY_STRING_ARRAY: string[] = [];
 const EMPTY_STRING_RECORD: Record<string, string> = {};
 const EMPTY_NUMBER_RECORD: Record<string, number> = {};
 const DEFAULT_CYCLE_ORDER: string[] = ["smol", "default", "slow"];
+const DEFAULT_TOOL_CALL_LOOP_EXEMPT_TOOLS: string[] = ["job", "irc"];
 const EMPTY_MODEL_TAGS_RECORD: ModelTagsSettings = {};
 const HINDSIGHT_RECALL_TYPES_DEFAULT: string[] = ["world", "experience"];
 export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
@@ -989,7 +990,7 @@ export const SETTINGS_SCHEMA = {
 			tab: "model",
 			group: "Thinking",
 			label: "Loop Guard",
-			description: "Enable automatic stream loop detection for Gemini and DeepSeek models",
+			description: "Enable automatic stream loop detection for model reasoning and prose",
 		},
 	},
 
@@ -1016,6 +1017,39 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"model.toolCallLoopGuard.enabled": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "model",
+			group: "Thinking",
+			label: "Tool-Call Loop Guard",
+			description: "Detect consecutive identical tool calls across turns and inject a corrective steer",
+		},
+	},
+
+	"model.toolCallLoopGuard.threshold": {
+		type: "number",
+		default: 5,
+		ui: {
+			tab: "model",
+			group: "Thinking",
+			label: "Tool-Call Loop Threshold",
+			description: "Consecutive identical tool calls required before the corrective steer is injected",
+		},
+	},
+
+	"model.toolCallLoopGuard.exemptTools": {
+		type: "array",
+		default: DEFAULT_TOOL_CALL_LOOP_EXEMPT_TOOLS,
+		ui: {
+			tab: "model",
+			group: "Thinking",
+			label: "Tool-Call Loop Exempt Tools",
+			description: "Tool names that may repeat consecutively without triggering the cross-turn loop guard",
+		},
+	},
+
 	inlineToolDescriptors: {
 		type: "enum",
 		values: ["auto", "on", "off"] as const,

package/src/config/settings.ts

@@ -172,19 +172,10 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
 
-function shallowStringRecord(value: unknown): Record<string, string> {
-	if (!isRecord(value)) return {};
-
-	const result: Record<string, string> = {};
-	for (const key in value) {
-		if (!Object.hasOwn(value, key)) continue;
-		const item = value[key];
-		if (typeof item === "string") {
-			result[key] = item;
-		}
-	}
-	return result;
-}
+type EditVariantEntry = {
+	patternLower: string;
+	mode: EditMode;
+};
 
 function resolvePathScopedStringArray(settingPath: SettingPath, value: unknown, cwd: string): string[] | undefined {
 	if (!PATH_SCOPED_ARRAY_SETTINGS.has(settingPath) || !Array.isArray(value)) return undefined;
@@ -247,6 +238,7 @@ export class Settings {
 	#merged: RawSettings = {};
 	/** Cached resolved values from the merged view, including defaults/path scoping */
 	#resolvedCache = new Map<SettingPath, unknown>();
+	#editVariantCache: readonly EditVariantEntry[] | undefined;
 
 	/** Paths modified during this session (for partial save) */
 	#modified = new Set<string>();
@@ -536,19 +528,44 @@ export class Settings {
 	 */
 	getEditVariantForModel(model: string | undefined): EditMode | null {
 		if (!model) return null;
-		const variants = shallowStringRecord(getByPath(this.#merged, ["edit", "modelVariants"]));
+		const variants = this.#getEditVariantEntries();
+		if (variants.length === 0) return null;
+
 		const modelLower = model.toLowerCase();
-		for (const pattern in variants) {
-			if (modelLower.includes(pattern.toLowerCase())) {
-				const value = normalizeEditMode(variants[pattern]);
-				if (value) {
-					return value;
-				}
+
+		for (let i = 0; i < variants.length; i++) {
+			const variant = variants[i];
+			if (modelLower.includes(variant.patternLower)) {
+				return variant.mode;
 			}
 		}
 		return null;
 	}
 
+	#getEditVariantEntries(): readonly EditVariantEntry[] {
+		if (this.#editVariantCache !== undefined) return this.#editVariantCache;
+
+		const value = getByPath(this.#merged, ["edit", "modelVariants"]);
+		if (!isRecord(value)) {
+			this.#editVariantCache = [];
+			return this.#editVariantCache;
+		}
+
+		const variants: EditVariantEntry[] = [];
+		for (const pattern in value) {
+			if (!Object.hasOwn(value, pattern)) continue;
+			const rawMode = value[pattern];
+			if (typeof rawMode !== "string") continue;
+			const mode = normalizeEditMode(rawMode);
+			if (mode) {
+				variants.push({ patternLower: pattern.toLowerCase(), mode });
+			}
+		}
+
+		this.#editVariantCache = variants;
+		return variants;
+	}
+
 	/**
 	 * Get bash interceptor rules (typed accessor for complex array config).
 	 */
@@ -556,11 +573,26 @@ export class Settings {
 		return this.get("bashInterceptor.patterns");
 	}
 
+	#modelRolesFromLayer(layer: RawSettings): Record<string, string> {
+		const value = getByPath(layer, ["modelRoles"]);
+		if (!isRecord(value)) return {};
+
+		const roles: Record<string, string> = {};
+		for (const role in value) {
+			if (!Object.hasOwn(value, role)) continue;
+			const modelId = value[role];
+			if (typeof modelId === "string") {
+				roles[role] = modelId;
+			}
+		}
+		return roles;
+	}
+
 	/**
 	 * Set a model role (helper for modelRoles record).
 	 */
 	setModelRole(role: ModelRole | string, modelId: string): void {
-		const current = shallowStringRecord(getByPath(this.#global, ["modelRoles"]));
+		const current = this.#modelRolesFromLayer(this.#global);
 		const runtimeOverrides = getByPath(this.#overrides, ["modelRoles"]);
 		const updateRuntimeOverride =
 			!!runtimeOverrides &&
@@ -568,10 +600,13 @@ export class Settings {
 			!Array.isArray(runtimeOverrides) &&
 			Object.hasOwn(runtimeOverrides, role);
 
-		this.set("modelRoles", { ...current, [role]: modelId });
+		current[role] = modelId;
+		this.set("modelRoles", current);
 
 		if (updateRuntimeOverride) {
-			this.override("modelRoles", { ...shallowStringRecord(runtimeOverrides), [role]: modelId });
+			const nextRuntimeOverride = this.#modelRolesFromLayer(this.#overrides);
+			nextRuntimeOverride[role] = modelId;
+			this.override("modelRoles", nextRuntimeOverride);
 		}
 	}
 
@@ -594,7 +629,7 @@ export class Settings {
 	 * Override model roles (helper for modelRoles record).
 	 */
 	overrideModelRoles(roles: ReadOnlyDict<string>): void {
-		const next = shallowStringRecord(getByPath(this.#overrides, ["modelRoles"]));
+		const next = this.#modelRolesFromLayer(this.#overrides);
 		for (const [role, modelId] of Object.entries(roles)) {
 			if (modelId) {
 				next[role] = modelId;
@@ -1281,6 +1316,7 @@ export class Settings {
 		this.#merged = this.#deepMerge(this.#merged, this.#configOverlay);
 		this.#merged = this.#deepMerge(this.#merged, this.#overrides);
 		this.#resolvedCache.clear();
+		this.#editVariantCache = undefined;
 	}
 
 	#fireAllHooks(): void {

package/src/eval/__tests__/agent-bridge.test.ts

@@ -196,15 +196,29 @@ describe("runEvalAgent", () => {
 		await expect(runEvalAgent({ prompt: "hello" }, { session: makeSession({ spawns: "" }) })).rejects.toThrow(
 			"spawns disabled",
 		);
-		await expect(runEvalAgent({ prompt: "hello" }, { session: makeSession({ spawns: "reviewer" }) })).rejects.toThrow(
-			"Allowed: reviewer",
-		);
+		await expect(
+			runEvalAgent({ prompt: "hello", agent: "task" }, { session: makeSession({ spawns: "reviewer" }) }),
+		).rejects.toThrow("Allowed: reviewer");
 		await expect(
 			runEvalAgent({ prompt: "hello" }, { session: makeSession({ depth: EVAL_AGENT_MAX_DEPTH }) }),
 		).rejects.toThrow("maximum depth");
 		expect(runSpy).not.toHaveBeenCalled();
 	});
 
+	it("defaults to the first allowed spawn under restricted eval policies", async () => {
+		mockAgents();
+		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options =>
+			singleResult(options, {
+				output: options.agent.name,
+			}),
+		);
+
+		const result = await runEvalAgent({ prompt: "hello" }, { session: makeSession({ spawns: "reviewer,task" }) });
+
+		expect(result.text).toBe("reviewer");
+		expect(runSpy.mock.calls[0]?.[0].agent.name).toBe("reviewer");
+	});
+
 	it("throws instead of spawning from plan mode", async () => {
 		mockAgents();
 		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));