@oh-my-pi/pi-coding-agent 14.5.12 → 14.5.14

package/CHANGELOG.md

@@ -2,6 +2,51 @@
 
 ## [Unreleased]
 
+## [14.5.14] - 2026-05-01
+### Changed
+
+- Changed markdown conversion and archive tooling to defer loading heavy dependencies (Turndown, fflate, and browser agent content) until first use, reducing startup overhead for CLI startup and command initialization
+
+### Fixed
+
+- Fixed changelog state tracking by flushing `lastChangelogVersion` to settings immediately when showing new entries, so the updated version is persisted across restarts
+
+## [14.5.13] - 2026-05-01
+
+### Breaking Changes
+
+- Removed the built-in `python` tool in favor of `eval`, so tool allowlists and tool-call handlers referencing `python` need to migrate
+- Removed the `python.toolMode` setting and replaced mode control with separate `eval.py` and `eval.js` toggles
+- Changed the tool runtime config surface by migrating `python` execution timeout/export behavior to `eval` and replacing `./ipy/*` internal exports with `./eval/*` paths
+- Changed the `eval` tool wire format to a single `input` string composed of markdown fenced code blocks (with per-fence language, timeout, title, and reset metadata in the info string) instead of top-level `cells`, `language`, `timeout`, and `reset` fields
+
+### Added
+
+- Added a JavaScript backend to the `eval` tool with an in-process VM runtime and JS helper bridge (`read`, `write`, `glob`, etc.)
+- Added `eval.py` and `eval.js` settings so Python and JavaScript `eval` backends can be enabled or disabled independently
+- Added `rename_file` action to the Lsp tool to rename files and directories with LSP `workspace/willRenameFiles` and `workspace/didRenameFiles` flow, applying returned workspace edits before moving files
+- Added `apply: false` preview mode for `rename_file` so users can see planned LSP edits without performing filesystem changes
+- Added `request` action to invoke arbitrary LSP methods, with automatic `textDocument`/`position` parameter construction from `file`/`line`/`symbol` and support for explicit JSON `payload`
+- Added `capabilities` action to display language server capabilities (for a file or all configured servers) through the LSP tool
+
+### Changed
+
+- Changed AGENTS.md discovery to respect `.gitignore` files during project context collection so ignored context files are no longer loaded
+- Changed eval tool initialization to skip Python kernel preflight when the JavaScript backend is enabled, avoiding unnecessary startup checks
+- Changed model registry refresh flow to defer rebuilding the canonical model index until refresh operations complete, reducing refresh churn
+- Changed execution/tool discovery flow so `exec` maps to `eval` when any `eval` backend is enabled, while `bash` stays independently available
+- Changed `eval` dispatch to automatically fall back to JavaScript when Python is unavailable and JavaScript backend is enabled
+- Parallelized plugin root preloading with other startup initialization in `runRootCommand` to reduce startup latency
+- Parallelized session bootstrap work in `createAgentSession`, including AGENTS.md scanning, context discovery, prompt template loading, slash command loading, and skill discovery, to reduce time to first available session
+
+### Fixed
+
+- Fixed eval startup messaging to report `eval` as unavailable when Python is unreachable and JavaScript backend is disabled
+
+### Fixed
+- Stabilized MCP tool ordering so reconnects and refreshes no longer reorder the tools array sent to the model. Anthropic prompt caching is keyed on byte-identical tool definitions; previously, the order depended on connection sequence and a single MCP server reconnect could shuffle tools across servers and invalidate the tools cache breakpoint.
+- Skipped redundant system-prompt rebuilds in `AgentSession.refreshMCPTools` when the active tool set is unchanged. MCP transport flapping (e.g. routine 5-minute SSE reconnects) used to call `rebuildSystemPrompt` on every reconnect even though the resulting prompt was byte-identical, eating CPU and risking cache misses if the rebuild ever became non-deterministic. The applied-tool signature also covers `customWireName` so a wire-name flip with the rest of the tool metadata constant still forces a rebuild.
+
 ## [14.5.12] - 2026-04-30
 
 ### Breaking Changes

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.5.12",
+	"version": "14.5.14",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.20.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.5.12",
-		"@oh-my-pi/pi-agent-core": "14.5.12",
-		"@oh-my-pi/pi-ai": "14.5.12",
-		"@oh-my-pi/pi-natives": "14.5.12",
-		"@oh-my-pi/pi-tui": "14.5.12",
-		"@oh-my-pi/pi-utils": "14.5.12",
+		"@oh-my-pi/omp-stats": "14.5.14",
+		"@oh-my-pi/pi-agent-core": "14.5.14",
+		"@oh-my-pi/pi-ai": "14.5.14",
+		"@oh-my-pi/pi-natives": "14.5.14",
+		"@oh-my-pi/pi-tui": "14.5.14",
+		"@oh-my-pi/pi-utils": "14.5.14",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@xterm/headless": "^6.0.0",
@@ -319,9 +319,17 @@
 			"types": "./src/internal-urls/*.ts",
 			"import": "./src/internal-urls/*.ts"
 		},
-		"./ipy/*": {
-			"types": "./src/ipy/*.ts",
-			"import": "./src/ipy/*.ts"
+		"./eval": {
+			"types": "./src/eval/index.ts",
+			"import": "./src/eval/index.ts"
+		},
+		"./eval/js/*": {
+			"types": "./src/eval/js/*.ts",
+			"import": "./src/eval/js/*.ts"
+		},
+		"./eval/py/*": {
+			"types": "./src/eval/py/*.ts",
+			"import": "./src/eval/py/*.ts"
 		},
 		"./lsp": {
 			"types": "./src/lsp/index.ts",

package/src/cli/jupyter-cli.ts

@@ -6,7 +6,7 @@
 
 import { APP_NAME } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
-import { getGatewayStatus, shutdownSharedGateway } from "../ipy/gateway-coordinator";
+import { getGatewayStatus, shutdownSharedGateway } from "../eval/py/gateway-coordinator";
 
 export type JupyterAction = "kill" | "status";
 

package/src/commit/pipeline.ts

@@ -25,7 +25,8 @@ import type { CommitCommandArgs, ConventionalAnalysis } from "./types";
 
 const SUMMARY_MAX_CHARS = 72;
 const RECENT_COMMITS_COUNT = 8;
-const TYPES_DESCRIPTION = prompt.render(typesDescriptionPrompt);
+let _typesDescription: string | undefined;
+const TYPES_DESCRIPTION = (): string => (_typesDescription ??= prompt.render(typesDescriptionPrompt));
 
 /**
  * Execute the omp commit pipeline for staged changes.
@@ -176,7 +177,7 @@ async function generateAnalysis(input: {
 			diff: input.diff,
 			stat: input.stat,
 			scopeCandidates: input.scopeCandidates,
-			typesDescription: TYPES_DESCRIPTION,
+			typesDescription: TYPES_DESCRIPTION(),
 			settings: {
 				enabled: input.commitSettings.mapReduceEnabled,
 				minFiles: input.commitSettings.mapReduceMinFiles,
@@ -193,7 +194,7 @@ async function generateAnalysis(input: {
 		thinkingLevel: input.primaryThinkingLevel,
 		contextFiles: input.contextFiles,
 		userContext: input.userContext,
-		typesDescription: TYPES_DESCRIPTION,
+		typesDescription: TYPES_DESCRIPTION(),
 		recentCommits: input.recentCommits,
 		scopeCandidates: input.scopeCandidates,
 		stat: input.stat,

package/src/config/model-equivalence.ts

@@ -61,7 +61,25 @@ const TRAILING_CANONICAL_MARKERS = [
 	"int8",
 	"int4",
 ] as const;
+const TRAILING_MARKER_SUFFIXES: readonly string[] = (() => {
+	const suffixes: string[] = [];
+	for (const marker of TRAILING_CANONICAL_MARKERS) {
+		const lower = marker.toLowerCase();
+		suffixes.push(`-${lower}`, `:${lower}`);
+	}
+	return suffixes;
+})();
 const WRAPPER_PREFIXES = ["duo-chat-"] as const;
+
+let __referenceDataCache: CanonicalReferenceData | undefined;
+const EMPTY_COMPILED_EQUIVALENCE: CompiledEquivalenceConfig = {
+	overrides: new Map<string, string>(),
+	exclude: new Set<string>(),
+};
+const __resolutionCache: WeakMap<
+	CompiledEquivalenceConfig,
+	WeakMap<Model<Api>, ResolvedCanonicalModel>
+> = new WeakMap();
 const FAMILY_EXTRACTION_PATTERNS = [
 	/(?:^|[/:._-])((?:claude|gemini|gpt|grok|glm|qwen|minimax|kimi|deepseek|llama|gemma|nova|mistral|ministral|pixtral|codestral|devstral|magistral|ernie|doubao|seed|aion|olmo|molmo|nemotron|palmyra|command|codex|coder|o[1345])[-a-z0-9.]+)(?::|$)/i,
 	/(?:^|[/:._-])((?:claude|gemini|gpt|grok|glm|qwen|minimax|kimi|deepseek|llama|gemma|nova|mistral|ministral|pixtral|codestral|devstral|magistral|ernie|doubao|seed|aion|olmo|molmo|nemotron|palmyra|command|codex|coder|o[1345])[-a-z0-9.]+(?:[-_/][a-z0-9.]+)*)(?::|$)/i,
@@ -79,6 +97,9 @@ function shouldReplaceReference(existing: Model<Api> | undefined, candidate: Mod
 }
 
 function createCanonicalReferenceData(): CanonicalReferenceData {
+	if (__referenceDataCache) {
+		return __referenceDataCache;
+	}
 	const references = new Map<string, Model<Api>>();
 	for (const provider of getBundledProviders()) {
 		for (const model of getBundledModels(provider as Parameters<typeof getBundledModels>[0])) {
@@ -89,10 +110,12 @@ function createCanonicalReferenceData(): CanonicalReferenceData {
 			}
 		}
 	}
-	return {
-		references,
-		officialIds: new Set(references.keys()),
+	const officialIds = new Set(references.keys());
+	__referenceDataCache = {
+		references: Object.freeze(references) as Map<string, Model<Api>>,
+		officialIds: Object.freeze(officialIds) as Set<string>,
 	};
+	return __referenceDataCache;
 }
 
 function normalizeSelectorKey(selector: string): string {
@@ -135,10 +158,12 @@ function buildExclusionSet(exclusions: readonly string[] | undefined): Set<strin
 }
 
 function compileEquivalenceConfig(config: ModelEquivalenceConfig | undefined): CompiledEquivalenceConfig {
-	return {
-		overrides: buildOverrideMap(config?.overrides),
-		exclude: buildExclusionSet(config?.exclude),
-	};
+	const overrides = buildOverrideMap(config?.overrides);
+	const exclude = buildExclusionSet(config?.exclude);
+	if (overrides.size === 0 && exclude.size === 0) {
+		return EMPTY_COMPILED_EQUIVALENCE;
+	}
+	return { overrides, exclude };
 }
 
 function addCanonicalCandidate(candidates: Set<string>, candidate: string): void {
@@ -149,12 +174,10 @@ function addCanonicalCandidate(candidates: Set<string>, candidate: string): void
 }
 
 function stripTrailingMarker(candidate: string): string | undefined {
-	for (const marker of TRAILING_CANONICAL_MARKERS) {
-		for (const separator of ["-", ":"] as const) {
-			const suffix = `${separator}${marker}`;
-			if (candidate.toLowerCase().endsWith(suffix)) {
-				return candidate.slice(0, -suffix.length);
-			}
+	const lower = candidate.toLowerCase();
+	for (const suffix of TRAILING_MARKER_SUFFIXES) {
+		if (lower.endsWith(suffix)) {
+			return candidate.slice(0, -suffix.length);
 		}
 	}
 	return undefined;
@@ -450,8 +473,8 @@ function getHeuristicCanonicalCandidates(modelId: string): string[] {
 	const queue = [modelId];
 	const visited = new Set<string>();
 
-	while (queue.length > 0) {
-		const candidate = queue.shift();
+	for (let qi = 0; qi < queue.length; qi += 1) {
+		const candidate = queue[qi];
 		if (!candidate) {
 			continue;
 		}
@@ -644,8 +667,18 @@ export function buildCanonicalModelIndex(
 	const byId = new Map<string, CanonicalModelRecord>();
 	const bySelector = new Map<string, string>();
 
+	let modelCache = __resolutionCache.get(compiledEquivalence);
+	if (!modelCache) {
+		modelCache = new WeakMap<Model<Api>, ResolvedCanonicalModel>();
+		__resolutionCache.set(compiledEquivalence, modelCache);
+	}
+
 	for (const model of models) {
-		const canonical = resolveCanonicalIdForModel(model, compiledEquivalence, referenceData);
+		let canonical = modelCache.get(model);
+		if (!canonical) {
+			canonical = resolveCanonicalIdForModel(model, compiledEquivalence, referenceData);
+			modelCache.set(model, canonical);
+		}
 		const selector = formatCanonicalVariantSelector(model);
 		const variant: CanonicalModelVariant = {
 			canonicalId: canonical.id,

package/src/config/model-registry.ts

@@ -4,7 +4,6 @@ import {
 	type AssistantMessageEventStream,
 	type Context,
 	createModelManager,
-	DEFAULT_LOCAL_TOKEN,
 	enrichModelThinking,
 	getBundledModels,
 	getBundledProviders,
@@ -13,18 +12,21 @@ import {
 	type Model,
 	type ModelManagerOptions,
 	type ModelRefreshStrategy,
-	type OAuthCredentials,
-	type OAuthLoginCallbacks,
 	openaiCodexModelManagerOptions,
 	PROVIDER_DESCRIPTORS,
 	readModelCache,
 	registerCustomApi,
-	registerOAuthProvider,
 	type SimpleStreamOptions,
 	type ThinkingConfig,
 	unregisterCustomApis,
-	unregisterOAuthProviders,
 } from "@oh-my-pi/pi-ai";
+
+// Sentinel for local-only OAuth token (LM Studio, vLLM) — declared inline to avoid loading
+// any provider module at startup. Must match `DEFAULT_LOCAL_TOKEN` in oauth/lm-studio.ts.
+const DEFAULT_LOCAL_TOKEN = "lm-studio-local";
+
+import { registerOAuthProvider, unregisterOAuthProviders } from "@oh-my-pi/pi-ai/utils/oauth";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
 import { isRecord, logger } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { type ConfigError, ConfigFile } from "../config";
@@ -281,6 +283,8 @@ const ProviderConfigSchema = Type.Object({
 	discovery: Type.Optional(ProviderDiscoverySchema),
 	models: Type.Optional(Type.Array(ModelDefinitionSchema)),
 	modelOverrides: Type.Optional(Type.Record(Type.String(), ModelOverrideSchema)),
+	/** When true, disables strict tool schemas for this provider (for third-party Anthropic-compatible endpoints that reject the strict field). */
+	disableStrictTools: Type.Optional(Type.Boolean()),
 });
 
 const EquivalenceConfigSchema = Type.Object({
@@ -316,6 +320,7 @@ interface ProviderValidationConfig {
 	oauthConfigured?: boolean;
 	discovery?: ProviderDiscovery;
 	compat?: Model<Api>["compat"];
+	disableStrictTools?: boolean;
 	modelOverrides?: Record<string, unknown>;
 	models: ProviderValidationModel[];
 }
@@ -331,9 +336,16 @@ function validateProviderConfiguration(
 	if (models.length === 0) {
 		if (mode === "models-config") {
 			const hasModelOverrides = config.modelOverrides && Object.keys(config.modelOverrides).length > 0;
-			if (!config.baseUrl && !config.headers && !config.compat && !hasModelOverrides && !config.discovery) {
+			if (
+				!config.baseUrl &&
+				!config.headers &&
+				!config.compat &&
+				!config.disableStrictTools &&
+				!hasModelOverrides &&
+				!config.discovery
+			) {
 				throw new Error(
-					`Provider ${providerName}: must specify "baseUrl", "headers", "compat", "modelOverrides", "discovery", or "models"`,
+					`Provider ${providerName}: must specify "baseUrl", "headers", "compat", "disableStrictTools", "modelOverrides", "discovery", or "models"`,
 				);
 			}
 		}
@@ -394,6 +406,7 @@ export const ModelsConfigFile = new ConfigFile<ModelsConfig>("models", ModelsCon
 					auth: (providerConfig.auth ?? "apiKey") as ProviderAuthMode,
 					discovery: providerConfig.discovery as ProviderDiscovery | undefined,
 					compat: providerConfig.compat,
+					disableStrictTools: providerConfig.disableStrictTools,
 					modelOverrides: providerConfig.modelOverrides,
 					models: (providerConfig.models ?? []) as ProviderValidationModel[],
 				},
@@ -784,6 +797,7 @@ export class ModelRegistry {
 	#equivalenceConfig: ModelEquivalenceConfig | undefined;
 	#configError: ConfigError | undefined = undefined;
 	#modelsConfigFile: ConfigFile<ModelsConfig>;
+	#lastStaticLoadMtime: number | null = null;
 	#registeredProviderSources: Set<string> = new Set();
 	#providerDiscoveryStates: Map<string, ProviderDiscoveryState> = new Map();
 	#cacheDbPath?: string;
@@ -797,6 +811,8 @@ export class ModelRegistry {
 	#runtimeProviderOverrides: Map<string, ProviderOverride> = new Map();
 	#runtimeProvidersBySource: Map<string, Set<string>> = new Map();
 	#runtimeProviderSourceByName: Map<string, string> = new Map();
+	#rebuildPending: boolean = false;
+	#rebuildSuspended: number = 0;
 
 	/**
 	 * @param authStorage - Auth storage for API key resolution
@@ -823,9 +839,14 @@ export class ModelRegistry {
 	 * Reload models from disk (built-in + custom from models.json).
 	 */
 	async refresh(strategy: ModelRefreshStrategy = "online-if-uncached"): Promise<void> {
-		this.#reloadStaticModels();
-		this.#suppressedSelectors.clear();
-		await this.#refreshRuntimeDiscoveries(strategy);
+		this.#suspendRebuild();
+		try {
+			this.#reloadStaticModels();
+			this.#suppressedSelectors.clear();
+			await this.#refreshRuntimeDiscoveries(strategy);
+		} finally {
+			this.#resumeRebuild();
+		}
 	}
 
 	refreshInBackground(strategy: ModelRefreshStrategy = "online-if-uncached"): void {
@@ -847,16 +868,26 @@ export class ModelRegistry {
 	}
 
 	async refreshProvider(providerId: string, strategy: ModelRefreshStrategy = "online"): Promise<void> {
-		this.#reloadStaticModels();
-		for (const selector of this.#suppressedSelectors.keys()) {
-			if (selector.startsWith(`${providerId}/`)) {
-				this.#suppressedSelectors.delete(selector);
+		this.#suspendRebuild();
+		try {
+			this.#reloadStaticModels();
+			for (const selector of this.#suppressedSelectors.keys()) {
+				if (selector.startsWith(`${providerId}/`)) {
+					this.#suppressedSelectors.delete(selector);
+				}
 			}
+			await this.#refreshRuntimeDiscoveries(strategy, new Set([providerId]));
+		} finally {
+			this.#resumeRebuild();
 		}
-		await this.#refreshRuntimeDiscoveries(strategy, new Set([providerId]));
 	}
 
 	#reloadStaticModels(): void {
+		const currentMtime = this.#modelsConfigFile.getMtimeMs();
+		if (currentMtime !== null && currentMtime === this.#lastStaticLoadMtime) {
+			// models.json unchanged since last load; reload + canonical rebuild would be redundant.
+			return;
+		}
 		this.#modelsConfigFile.invalidate();
 		this.#customProviderApiKeys.clear();
 		this.#keylessProviders.clear();
@@ -911,6 +942,7 @@ export class ModelRegistry {
 		const withModelOverrides = this.#applyModelOverrides(combined, this.#modelOverrides);
 		this.#models = this.#applyRuntimeProviderOverrides(withModelOverrides);
 		this.#rebuildCanonicalIndex();
+		this.#lastStaticLoadMtime = this.#modelsConfigFile.getMtimeMs();
 	}
 
 	/** Load built-in models, applying provider-level overrides only.
@@ -934,14 +966,19 @@ export class ModelRegistry {
 
 	#mergeResolvedModels(baseModels: Model<Api>[], replacementModels: Model<Api>[]): Model<Api>[] {
 		const merged = [...baseModels];
+		const indexByKey = new Map<string, number>();
+		for (let i = 0; i < merged.length; i += 1) {
+			const m = merged[i];
+			indexByKey.set(`${m.provider}\u0000${m.id}`, i);
+		}
 		for (const replacementModel of replacementModels) {
-			const existingIndex = merged.findIndex(
-				m => m.provider === replacementModel.provider && m.id === replacementModel.id,
-			);
-			if (existingIndex >= 0) {
+			const key = `${replacementModel.provider}\u0000${replacementModel.id}`;
+			const existingIndex = indexByKey.get(key);
+			if (existingIndex !== undefined) {
 				merged[existingIndex] = replacementModel;
 			} else {
 				merged.push(replacementModel);
+				indexByKey.set(key, merged.length - 1);
 			}
 		}
 		return merged;
@@ -950,9 +987,15 @@ export class ModelRegistry {
 	/** Merge custom models with built-in, replacing by provider+id match */
 	#mergeCustomModels(builtInModels: Model<Api>[], customModels: CustomModelOverlay[]): Model<Api>[] {
 		const merged = [...builtInModels];
+		const indexByKey = new Map<string, number>();
+		for (let i = 0; i < merged.length; i += 1) {
+			const m = merged[i];
+			indexByKey.set(`${m.provider}\u0000${m.id}`, i);
+		}
 		for (const customModel of customModels) {
-			const existingIndex = merged.findIndex(m => m.provider === customModel.provider && m.id === customModel.id);
-			if (existingIndex >= 0) {
+			const key = `${customModel.provider}\u0000${customModel.id}`;
+			const existingIndex = indexByKey.get(key);
+			if (existingIndex !== undefined) {
 				const existingModel = merged[existingIndex];
 				merged[existingIndex] = enrichModelThinking({
 					...existingModel,
@@ -977,6 +1020,7 @@ export class ModelRegistry {
 				} as Model<Api>);
 			} else {
 				merged.push(finalizeCustomModel(customModel, { useDefaults: true }));
+				indexByKey.set(key, merged.length - 1);
 			}
 		}
 		return merged;
@@ -1099,13 +1143,20 @@ export class ModelRegistry {
 		const configuredProviders = new Set(Object.keys(value.providers ?? {}));
 
 		for (const [providerName, providerConfig] of providerEntries) {
-			// Always set overrides when baseUrl/headers/apiKey/compat are present
-			if (providerConfig.baseUrl || providerConfig.headers || providerConfig.apiKey || providerConfig.compat) {
+			// Always set overrides when baseUrl/headers/apiKey/compat/disableStrictTools are present
+			if (
+				providerConfig.baseUrl ||
+				providerConfig.headers ||
+				providerConfig.apiKey ||
+				providerConfig.compat ||
+				providerConfig.disableStrictTools
+			) {
+				const disableStrictCompat = providerConfig.disableStrictTools ? { disableStrictTools: true } : undefined;
 				overrides.set(providerName, {
 					baseUrl: providerConfig.baseUrl,
 					headers: providerConfig.headers,
 					apiKey: providerConfig.apiKey,
-					compat: providerConfig.compat,
+					compat: mergeCompat(providerConfig.compat, disableStrictCompat),
 				});
 			}
 
@@ -1736,7 +1787,26 @@ export class ModelRegistry {
 	}
 
 	#rebuildCanonicalIndex(): void {
+		if (this.#rebuildSuspended > 0) {
+			this.#rebuildPending = true;
+			return;
+		}
 		this.#canonicalIndex = buildCanonicalModelIndex(this.#models, this.#equivalenceConfig);
+		this.#rebuildPending = false;
+	}
+
+	#suspendRebuild(): void {
+		this.#rebuildSuspended += 1;
+	}
+
+	#resumeRebuild(): void {
+		if (this.#rebuildSuspended > 0) {
+			this.#rebuildSuspended -= 1;
+		}
+		if (this.#rebuildSuspended === 0 && this.#rebuildPending) {
+			this.#rebuildPending = false;
+			this.#canonicalIndex = buildCanonicalModelIndex(this.#models, this.#equivalenceConfig);
+		}
 	}
 
 	#parseModels(config: ModelsConfig): CustomModelOverlay[] {
@@ -1749,6 +1819,9 @@ export class ModelRegistry {
 				this.#customProviderApiKeys.set(providerName, providerConfig.apiKey);
 			}
 			for (const modelDef of modelDefs) {
+				const providerCompat = providerConfig.disableStrictTools
+					? mergeCompat(providerConfig.compat, { disableStrictTools: true })
+					: providerConfig.compat;
 				const model = buildCustomModelOverlay(
 					providerName,
 					providerConfig.baseUrl!,
@@ -1756,7 +1829,7 @@ export class ModelRegistry {
 					providerConfig.headers,
 					providerConfig.apiKey,
 					providerConfig.authHeader,
-					providerConfig.compat,
+					providerCompat,
 					(providerConfig.auth as ProviderAuthMode | undefined) ?? undefined,
 					modelDef as CustomModelDefinitionLike,
 				);
@@ -1993,6 +2066,7 @@ export class ModelRegistry {
 			this.#runtimeProviderSourceByName.delete(providerName);
 			this.#clearRuntimeProviderState(providerName);
 		}
+		this.#lastStaticLoadMtime = null;
 		this.#reloadStaticModels();
 		this.#rebuildCanonicalIndex();
 	}
@@ -2071,6 +2145,7 @@ export class ModelRegistry {
 			this.#runtimeProviderSourceByName.set(providerName, sourceId);
 		}
 		if (sourceHandoff) {
+			this.#lastStaticLoadMtime = null;
 			this.#reloadStaticModels();
 		}
 

package/src/config/model-resolver.ts

@@ -116,6 +116,24 @@ function cloneModelWithRequestedId(model: Model<Api>, requestedId: string): Mode
 	};
 }
 
+const providerModelIndexCache = new WeakMap<readonly Model<Api>[], Map<string, Model<Api> | null>>();
+
+function getProviderModelIndex(availableModels: readonly Model<Api>[]): Map<string, Model<Api> | null> {
+	let index = providerModelIndexCache.get(availableModels);
+	if (index) return index;
+	index = new Map<string, Model<Api> | null>();
+	for (const m of availableModels) {
+		const key = `${m.provider.toLowerCase()}\u0000${m.id.toLowerCase()}`;
+		if (index.has(key)) {
+			index.set(key, null); // ambiguous sentinel; do not overwrite back
+		} else {
+			index.set(key, m);
+		}
+	}
+	providerModelIndexCache.set(availableModels, index);
+	return index;
+}
+
 export function resolveProviderModelReference(
 	provider: string,
 	modelId: string,
@@ -127,14 +145,13 @@ export function resolveProviderModelReference(
 		return undefined;
 	}
 
-	const exactMatches = availableModels.filter(
-		model => model.provider.toLowerCase() === normalizedProvider && model.id.toLowerCase() === normalizedModelId,
-	);
-	if (exactMatches.length === 1) {
-		return exactMatches[0];
+	const index = getProviderModelIndex(availableModels);
+	const exact = index.get(`${normalizedProvider}\u0000${normalizedModelId}`);
+	if (exact === null) {
+		return undefined; // ambiguous
 	}
-	if (exactMatches.length > 1) {
-		return undefined;
+	if (exact !== undefined) {
+		return exact;
 	}
 
 	if (normalizedProvider !== "openrouter") {
@@ -142,16 +159,13 @@ export function resolveProviderModelReference(
 	}
 
 	for (const fallbackId of getOpenRouterFallbackModelIds(modelId).slice(1)) {
-		const baseMatches = availableModels.filter(
-			model =>
-				model.provider.toLowerCase() === normalizedProvider && model.id.toLowerCase() === fallbackId.toLowerCase(),
-		);
-		if (baseMatches.length === 1) {
-			return cloneModelWithRequestedId(baseMatches[0], modelId);
-		}
-		if (baseMatches.length > 1) {
+		const fallback = index.get(`${normalizedProvider}\u0000${fallbackId.toLowerCase()}`);
+		if (fallback === null) {
 			return undefined;
 		}
+		if (fallback !== undefined) {
+			return cloneModelWithRequestedId(fallback, modelId);
+		}
 	}
 
 	return undefined;

package/src/config/settings-schema.ts

@@ -1137,14 +1137,28 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
-	// Python
-	"python.toolMode": {
-		type: "enum",
-		values: ["ipy-only", "bash-only", "both"] as const,
-		default: "both",
-		ui: { tab: "editing", label: "Python Tool Mode", description: "How Python code is executed" },
+	// Eval (per-backend toggles; add more as new backends ship, e.g. eval.ts)
+	"eval.py": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "editing",
+			label: "Eval: Python backend",
+			description: "Allow the eval tool to dispatch to the IPython kernel",
+		},
+	},
+
+	"eval.js": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "editing",
+			label: "Eval: JavaScript backend",
+			description: "Allow the eval tool to dispatch to the in-process JavaScript runtime",
+		},
 	},
 
+	// Python kernel knobs (consumed by the eval py backend and the /python slash command)
 	"python.kernelMode": {
 		type: "enum",
 		values: ["session", "per-call"] as const,

package/src/config/settings.ts

@@ -398,21 +398,22 @@ export class Settings {
 	// ─────────────────────────────────────────────────────────────────────────
 
 	async #load(): Promise<Settings> {
+		// Project settings load (loadCapability scans cwd) is independent of the
+		// persist chain (storage open → legacy migration → global config.yml read),
+		// so kick it off first and await after the persist chain completes. The
+		// persist steps remain sequential: migration may write config.yml, which
+		// #loadYaml then reads; migration's db fallback needs #storage opened.
+		const projectPromise = this.#loadProjectSettings();
+
 		if (this.#persist) {
-			// Open storage
 			this.#storage = await AgentStorage.open(getAgentDbPath(this.#agentDir));
-
-			// Migrate from legacy formats if needed
 			await this.#migrateFromLegacy();
-
-			// Load global settings from config.yml
 			this.#global = await this.#loadYaml(this.#configPath!);
 		}
 
-		// Load project settings
-		this.#project = await this.#loadProjectSettings();
+		this.#project = await projectPromise;
 
-		// Build merged view
+		// Build merged view (global → project → overrides; project wins over global)
 		this.#rebuildMerged();
 		this.#fireAllHooks();
 		return this;