@oh-my-pi/pi-coding-agent 14.7.0 → 14.7.2

package/CHANGELOG.md

@@ -1,9 +1,33 @@
 # Changelog
 
 ## [Unreleased]
+
+## [14.7.2] - 2026-05-06
+### Breaking Changes
+
+- Removed the exported `BUILTIN_TOOL_METADATA` API, including `BuiltinEntry`-style metadata exports and discoverable-built-in helper exports, which will break consumers relying on those symbols
+
+### Changed
+
+- Updated discoverable tool search (`search_tool_bm25` and related discovery metadata) to read each tool’s own `summary` field when present, improving discoverability descriptions for built-in tools
+
+### Fixed
+
+- Fixed SearXNG web search Basic Auth validation to reject RFC 7617 control characters and clarified the equivalent `config.yml` and environment variable settings.
+- Fixed extension commands that return without starting a model turn leaving the interactive `Working…` spinner active indefinitely. (#927)
+- Fixed `authHeader: true` provider overrides without custom `models` so built-in model transport headers receive `Authorization: Bearer <resolved-key>` (#929).
+
+## [14.7.1] - 2026-05-06
+
 ### Added
 
 - Added `pr_create` operation to the GitHub tool to create pull requests with title/body (or `fill`), base/head branch, draft, reviewer, assignee, and label options and return a summarized result including the new PR URL
+- Added `read.summarize.prose` setting to keep Markdown and plain-text reads out of the structural summarizer by default.
+
+### Changed
+
+- Changed the `PI_GREP_WORKERS` environment variable help text to state that it sets filesystem walker workers, defaults to 4, and uses `0` for automatic worker selection
+- Changed hashline replacement and pure-insert auto-absorb to also drop a single duplicated structural-closing line (`}`, `);`, `]`, etc.) on either boundary when keeping it would unbalance brackets. The pure-insert variant fires regardless of `edit.hashlineAutoDropPureInsertDuplicates`, while the existing 2+ line generic absorb stays gated on that setting.
 
 ## [14.7.0] - 2026-05-04
 ### Breaking Changes

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.7.0",
+	"version": "14.7.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -44,16 +44,17 @@
 		"generate-template": "bun scripts/generate-template.ts"
 	},
 	"dependencies": {
-		"@agentclientprotocol/sdk": "0.20.0",
+		"@agentclientprotocol/sdk": "0.21.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.7.0",
-		"@oh-my-pi/pi-agent-core": "14.7.0",
-		"@oh-my-pi/pi-ai": "14.7.0",
-		"@oh-my-pi/pi-natives": "14.7.0",
-		"@oh-my-pi/pi-tui": "14.7.0",
-		"@oh-my-pi/pi-utils": "14.7.0",
+		"@oh-my-pi/omp-stats": "14.7.2",
+		"@oh-my-pi/pi-agent-core": "14.7.2",
+		"@oh-my-pi/pi-ai": "14.7.2",
+		"@oh-my-pi/pi-natives": "14.7.2",
+		"@oh-my-pi/pi-tui": "14.7.2",
+		"@oh-my-pi/pi-utils": "14.7.2",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
+		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
 		"ajv": "^8.20.0",
 		"chalk": "^5.6.2",
@@ -61,16 +62,15 @@
 		"fflate": "0.8.2",
 		"handlebars": "^4.7.9",
 		"linkedom": "^0.18.12",
-		"lru-cache": "11.3.5",
+		"lru-cache": "11.3.6",
 		"markit-ai": "0.5.3",
 		"puppeteer-core": "^24.42.0",
 		"turndown": "7.2.4",
 		"turndown-plugin-gfm": "1.0.2",
-		"zod": "4.3.6"
+		"zod": "4.4.3"
 	},
 	"devDependencies": {
-		"@types/bun": "^1.3",
-		"@types/turndown": "5.0.6"
+		"@types/bun": "^1.3.13"
 	},
 	"engines": {
 		"bun": ">=1.3.7"

package/src/cli/grep-cli.ts

@@ -150,7 +150,7 @@ ${chalk.bold("Options:")}
   --no-gitignore        Include files excluded by .gitignore
 
 ${chalk.bold("Environment:")}
-  PI_GREP_WORKERS=0    Disable worker pool (use single-threaded mode)
+  PI_GREP_WORKERS=N    Set filesystem walker workers (default 4, 0 = auto)
 
 ${chalk.bold("Examples:")}
   ${APP_NAME} grep "import" src/

package/src/config/model-equivalence.ts

@@ -50,6 +50,7 @@ const TRAILING_CANONICAL_MARKERS = [
 	"minimal",
 	"xhigh",
 	"free",
+	"cloud",
 	"exacto",
 	"nitro",
 	"original",

package/src/config/model-registry.ts

@@ -421,6 +421,7 @@ interface ProviderOverride {
 	baseUrl?: string;
 	headers?: Record<string, string>;
 	apiKey?: string;
+	authHeader?: boolean;
 	compat?: Model<Api>["compat"];
 }
 
@@ -667,14 +668,20 @@ function mergeCustomModelHeaders(
 	authHeader: boolean | undefined,
 	apiKeyConfig: string | undefined,
 ): Record<string, string> | undefined {
-	let headers = providerHeaders || modelHeaders ? { ...providerHeaders, ...modelHeaders } : undefined;
-	if (authHeader && apiKeyConfig) {
-		const resolvedKey = resolveApiKeyConfig(apiKeyConfig);
-		if (resolvedKey) {
-			headers = { ...headers, Authorization: `Bearer ${resolvedKey}` };
-		}
+	return mergeAuthHeader({ ...providerHeaders, ...modelHeaders }, authHeader, apiKeyConfig);
+}
+
+function mergeAuthHeader(
+	headers: Record<string, string> | undefined,
+	authHeader: boolean | undefined,
+	apiKeyConfig: string | undefined,
+): Record<string, string> | undefined {
+	const nextHeaders = headers && Object.keys(headers).length > 0 ? { ...headers } : undefined;
+	if (!authHeader || !apiKeyConfig) {
+		return nextHeaders;
 	}
-	return headers;
+	const resolvedKey = resolveApiKeyConfig(apiKeyConfig);
+	return resolvedKey ? { ...nextHeaders, Authorization: `Bearer ${resolvedKey}` } : nextHeaders;
 }
 
 /**
@@ -726,6 +733,69 @@ function buildCustomModelOverlay(
 	};
 }
 
+// Custom provider entries often front a known upstream model through a local proxy.
+// Use bundled metadata for missing pricing/capability fields, but keep the custom transport.
+function shouldReplaceCustomReference(existing: Model<Api> | undefined, candidate: Model<Api>): boolean {
+	if (!existing) return true;
+	if (candidate.contextWindow !== existing.contextWindow) {
+		return candidate.contextWindow > existing.contextWindow;
+	}
+	if (candidate.maxTokens !== existing.maxTokens) {
+		return candidate.maxTokens > existing.maxTokens;
+	}
+	const existingHasCachePricing = existing.cost.cacheRead > 0 || existing.cost.cacheWrite > 0;
+	const candidateHasCachePricing = candidate.cost.cacheRead > 0 || candidate.cost.cacheWrite > 0;
+	if (candidateHasCachePricing !== existingHasCachePricing) {
+		return candidateHasCachePricing;
+	}
+	return existing.provider !== "openai" && candidate.provider === "openai";
+}
+
+function buildCustomReferenceMap(): Map<string, Model<Api>> {
+	const references = new Map<string, Model<Api>>();
+	for (const provider of getBundledProviders()) {
+		for (const model of getBundledModels(provider as Parameters<typeof getBundledModels>[0])) {
+			const candidate = model as Model<Api>;
+			if (shouldReplaceCustomReference(references.get(candidate.id), candidate)) {
+				references.set(candidate.id, candidate);
+			}
+		}
+	}
+	return references;
+}
+
+const customReferenceMap = buildCustomReferenceMap();
+
+function getCustomReferenceCandidateIds(modelId: string): string[] {
+	const candidates = new Set<string>();
+	const queue = [modelId];
+	for (let index = 0; index < queue.length; index += 1) {
+		const candidate = queue[index]?.trim();
+		if (!candidate || candidates.has(candidate)) continue;
+		candidates.add(candidate);
+
+		for (const suffix of [":cloud", "-cloud"] as const) {
+			if (candidate.toLowerCase().endsWith(suffix)) {
+				queue.push(candidate.slice(0, -suffix.length));
+			}
+		}
+
+		const colonToDash = candidate.replace(/:/g, "-");
+		if (colonToDash !== candidate) {
+			queue.push(colonToDash);
+		}
+	}
+	return [...candidates];
+}
+
+function resolveCustomModelReference(modelId: string): Model<Api> | undefined {
+	for (const candidate of getCustomReferenceCandidateIds(modelId)) {
+		const reference = customReferenceMap.get(candidate);
+		if (reference) return reference;
+	}
+	return undefined;
+}
+
 function applyStandaloneCustomModelPolicies(model: CustomModelOverlay): CustomModelOverlay {
 	if (model.id !== "gpt-5.4" || model.provider === "github-copilot" || model.contextWindow !== undefined) {
 		return model;
@@ -735,23 +805,27 @@ function applyStandaloneCustomModelPolicies(model: CustomModelOverlay): CustomMo
 
 function finalizeCustomModel(model: CustomModelOverlay, options: CustomModelBuildOptions): Model<Api> {
 	const resolvedModel = options.useDefaults ? applyStandaloneCustomModelPolicies(model) : model;
+	const reference = options.useDefaults ? resolveCustomModelReference(resolvedModel.id) : undefined;
 	const cost =
-		resolvedModel.cost ?? (options.useDefaults ? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } : undefined);
-	const input = resolvedModel.input ?? (options.useDefaults ? ["text"] : undefined);
+		resolvedModel.cost ??
+		reference?.cost ??
+		(options.useDefaults ? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } : undefined);
+	const input = resolvedModel.input ?? reference?.input ?? (options.useDefaults ? ["text"] : undefined);
 	return enrichModelThinking({
 		id: resolvedModel.id,
 		name: resolvedModel.name ?? (options.useDefaults ? resolvedModel.id : undefined),
 		api: resolvedModel.api,
 		provider: resolvedModel.provider,
 		baseUrl: resolvedModel.baseUrl,
-		reasoning: resolvedModel.reasoning ?? (options.useDefaults ? false : undefined),
-		thinking: resolvedModel.thinking,
+		reasoning: resolvedModel.reasoning ?? reference?.reasoning ?? (options.useDefaults ? false : undefined),
+		thinking: resolvedModel.thinking ?? reference?.thinking,
 		input: input as ("text" | "image")[],
 		cost,
-		contextWindow: resolvedModel.contextWindow ?? (options.useDefaults ? 128000 : undefined),
-		maxTokens: resolvedModel.maxTokens ?? (options.useDefaults ? 16384 : undefined),
+		contextWindow:
+			resolvedModel.contextWindow ?? reference?.contextWindow ?? (options.useDefaults ? 128000 : undefined),
+		maxTokens: resolvedModel.maxTokens ?? reference?.maxTokens ?? (options.useDefaults ? 16384 : undefined),
 		headers: resolvedModel.headers,
-		compat: resolvedModel.compat,
+		compat: mergeCompat(reference?.compat, resolvedModel.compat),
 		contextPromotionTarget: resolvedModel.contextPromotionTarget,
 		premiumMultiplier: resolvedModel.premiumMultiplier,
 		isOAuth: resolvedModel.isOAuth,
@@ -954,10 +1028,9 @@ export class ModelRegistry {
 
 			return models.map(m => {
 				if (!providerOverride) return m;
+				const withTransportOverride = this.#applyProviderTransportOverride(m, providerOverride);
 				return {
-					...m,
-					baseUrl: providerOverride.baseUrl ?? m.baseUrl,
-					headers: providerOverride.headers ? { ...m.headers, ...providerOverride.headers } : m.headers,
+					...withTransportOverride,
 					compat: mergeCompat(m.compat, providerOverride.compat),
 				};
 			});
@@ -1143,11 +1216,12 @@ 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/disableStrictTools are present
+			// Always set overrides when baseUrl/headers/apiKey/authHeader/compat/disableStrictTools are present
 			if (
 				providerConfig.baseUrl ||
 				providerConfig.headers ||
 				providerConfig.apiKey ||
+				providerConfig.authHeader !== undefined ||
 				providerConfig.compat ||
 				providerConfig.disableStrictTools
 			) {
@@ -1156,6 +1230,7 @@ export class ModelRegistry {
 					baseUrl: providerConfig.baseUrl,
 					headers: providerConfig.headers,
 					apiKey: providerConfig.apiKey,
+					authHeader: providerConfig.authHeader,
 					compat: mergeCompat(providerConfig.compat, disableStrictCompat),
 				});
 			}
@@ -1738,18 +1813,24 @@ export class ModelRegistry {
 		return {
 			baseUrl: override.baseUrl ?? baseOverride?.baseUrl,
 			apiKey: override.apiKey ?? baseOverride?.apiKey,
+			authHeader: override.authHeader ?? baseOverride?.authHeader,
 			headers: override.headers ? { ...(baseOverride?.headers ?? {}), ...override.headers } : baseOverride?.headers,
 			compat: override.compat ? mergeCompat(baseOverride?.compat, override.compat) : baseOverride?.compat,
 		};
 	}
 	#applyProviderTransportOverride<T extends { baseUrl?: string; headers?: Record<string, string> }>(
 		entry: T,
-		override: Pick<ProviderOverride, "baseUrl" | "headers">,
+		override: Pick<ProviderOverride, "baseUrl" | "headers" | "authHeader" | "apiKey">,
 	): T {
+		const headers = mergeAuthHeader(
+			override.headers ? { ...entry.headers, ...override.headers } : entry.headers,
+			override.authHeader,
+			override.apiKey,
+		);
 		return {
 			...entry,
 			baseUrl: override.baseUrl ?? entry.baseUrl,
-			headers: override.headers ? { ...entry.headers, ...override.headers } : entry.headers,
+			headers,
 		};
 	}
 	#applyRuntimeProviderOverrides(models: Model<Api>[]): Model<Api>[] {
@@ -2206,8 +2287,13 @@ export class ModelRegistry {
 			return;
 		}
 
-		if (config.baseUrl || config.headers) {
-			const transportOverride = { baseUrl: config.baseUrl, headers: config.headers };
+		if (config.baseUrl || config.headers || config.apiKey || config.authHeader !== undefined) {
+			const transportOverride = {
+				baseUrl: config.baseUrl,
+				headers: config.headers,
+				apiKey: config.apiKey,
+				authHeader: config.authHeader,
+			};
 			const nextRuntimeOverride = this.#mergeProviderOverride(
 				this.#runtimeProviderOverrides.get(providerName),
 				transportOverride,

package/src/config/settings-schema.ts

@@ -1485,6 +1485,16 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"read.summarize.prose": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "editing",
+			label: "Prose Summaries",
+			description: "Return structural summaries for Markdown and plain text reads",
+		},
+	},
+
 	"read.summarize.minBodyLines": {
 		type: "number",
 		default: 4,
@@ -1945,6 +1955,30 @@ export const SETTINGS_SCHEMA = {
 		default: 60_000,
 	},
 
+	// Tool Discovery
+	"tools.discoveryMode": {
+		type: "enum",
+		values: ["off", "mcp-only", "all"] as const,
+		default: "off",
+		ui: {
+			tab: "tools",
+			label: "Tool Discovery",
+			description:
+				"Hide tools behind a search tool to save tokens. 'mcp-only' hides MCP tools; 'all' hides all non-essential built-ins too.",
+		},
+	},
+
+	"tools.essentialOverride": {
+		type: "array",
+		default: [] as string[],
+		ui: {
+			tab: "tools",
+			label: "Essential Tools Override",
+			description:
+				"Override the always-loaded built-in tools (default: read, bash, edit). Leave empty to use defaults.",
+		},
+	},
+
 	// MCP
 	"mcp.enableProjectConfig": {
 		type: "boolean",
@@ -1996,6 +2030,17 @@ export const SETTINGS_SCHEMA = {
 	// Tasks
 	// ────────────────────────────────────────────────────────────────────────
 
+	// Plan mode
+	"plan.enabled": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "tasks",
+			label: "Plan Mode",
+			description: "Enable plan mode for read-only exploration and planning before execution",
+		},
+	},
+
 	// Delegation
 	"task.isolation.mode": {
 		type: "enum",
@@ -2268,7 +2313,7 @@ export const SETTINGS_SCHEMA = {
 				{ value: "kagi", label: "Kagi", description: "Requires KAGI_API_KEY and Kagi Search API beta access" },
 				{ value: "synthetic", label: "Synthetic", description: "Requires SYNTHETIC_API_KEY" },
 				{ value: "parallel", label: "Parallel", description: "Requires PARALLEL_API_KEY" },
-				{ value: "searxng", label: "SearXNG", description: "Requires searxng.endpoint" },
+				{ value: "searxng", label: "SearXNG", description: "Requires SEARXNG_ENDPOINT or searxng.endpoint" },
 			],
 		},
 	},

package/src/config/settings.ts

@@ -12,6 +12,7 @@
  */
 
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import {
 	getAgentDbPath,
@@ -98,6 +99,74 @@ function setByPath(obj: RawSettings, segments: string[], value: unknown): void {
 	current[segments[segments.length - 1]] = value;
 }
 
+const PATH_SCOPED_ARRAY_SETTINGS = new Set<SettingPath>(["enabledModels", "disabledProviders"]);
+
+type PathScopedStringArrayEntry = {
+	path?: unknown;
+	paths?: unknown;
+	pathPrefix?: unknown;
+	pathPrefixes?: unknown;
+	values?: unknown;
+	items?: unknown;
+	models?: unknown;
+	providers?: unknown;
+};
+
+function normalizePathPrefix(prefix: string): string {
+	const expanded =
+		prefix === "~" ? os.homedir() : prefix.startsWith("~/") ? path.join(os.homedir(), prefix.slice(2)) : prefix;
+	return path.resolve(expanded);
+}
+
+function pathMatchesPrefix(cwd: string, prefix: string): boolean {
+	const relative = path.relative(normalizePathPrefix(prefix), path.resolve(cwd));
+	return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function stringArrayFromUnknown(value: unknown): string[] {
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value)) return value.filter((item): item is string => typeof item === "string");
+	return [];
+}
+
+function resolvePathScopedStringArray(settingPath: SettingPath, value: unknown, cwd: string): string[] | undefined {
+	if (!PATH_SCOPED_ARRAY_SETTINGS.has(settingPath) || !Array.isArray(value)) return undefined;
+
+	const resolved: string[] = [];
+	for (const entry of value) {
+		if (typeof entry === "string") {
+			resolved.push(entry);
+			continue;
+		}
+		if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+
+		const scoped = entry as PathScopedStringArrayEntry;
+		const prefixes = [
+			...stringArrayFromUnknown(scoped.path),
+			...stringArrayFromUnknown(scoped.paths),
+			...stringArrayFromUnknown(scoped.pathPrefix),
+			...stringArrayFromUnknown(scoped.pathPrefixes),
+		];
+		if (prefixes.length === 0 || !prefixes.some(prefix => pathMatchesPrefix(cwd, prefix))) continue;
+
+		const values =
+			settingPath === "enabledModels"
+				? [
+						...stringArrayFromUnknown(scoped.values),
+						...stringArrayFromUnknown(scoped.items),
+						...stringArrayFromUnknown(scoped.models),
+					]
+				: [
+						...stringArrayFromUnknown(scoped.values),
+						...stringArrayFromUnknown(scoped.items),
+						...stringArrayFromUnknown(scoped.providers),
+					];
+		resolved.push(...values);
+	}
+
+	return resolved;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Settings Class
 // ═══════════════════════════════════════════════════════════════════════════
@@ -201,7 +270,8 @@ export class Settings {
 		const segments = path.split(".");
 		const value = getByPath(this.#merged, segments);
 		if (value !== undefined) {
-			return value as SettingValue<P>;
+			const pathScopedValue = resolvePathScopedStringArray(path, value, this.#cwd);
+			return (pathScopedValue ?? value) as SettingValue<P>;
 		}
 		return getDefault(path);
 	}

package/src/dap/client.ts

@@ -584,6 +584,7 @@ function socketToSink(socket: Bun.Socket<undefined>): DapWriteSink {
 		},
 		flush() {
 			socket.flush();
+			return undefined;
 		},
 	};
 }

package/src/discovery/builtin.ts

@@ -5,6 +5,7 @@
  */
 import * as path from "node:path";
 import { logger, parseFrontmatter, tryParseJson } from "@oh-my-pi/pi-utils";
+import { YAML } from "bun";
 import { registerProvider } from "../capability";
 import { type ContextFile, contextFileCapability } from "../capability/context-file";
 import { type Extension, type ExtensionManifest, extensionCapability } from "../capability/extension";
@@ -778,22 +779,46 @@ async function loadSettings(ctx: LoadContext): Promise<LoadResult<Settings>> {
 	const items: Settings[] = [];
 	const warnings: string[] = [];
 
+	const parseYamlSettings = (content: string, filePath: string): Record<string, unknown> | null => {
+		try {
+			const data = YAML.parse(content);
+			if (!data || typeof data !== "object" || Array.isArray(data)) return {};
+			return data as Record<string, unknown>;
+		} catch {
+			warnings.push(`Failed to parse ${filePath}`);
+			return null;
+		}
+	};
+
 	for (const { dir, level } of await getConfigDirs(ctx)) {
 		const settingsPath = path.join(dir, "settings.json");
-		const content = await readFile(settingsPath);
-		if (!content) continue;
-
-		const data = tryParseJson<Record<string, unknown>>(content);
-		if (!data) {
-			warnings.push(`Failed to parse ${settingsPath}`);
-			continue;
+		const settingsContent = await readFile(settingsPath);
+		if (settingsContent) {
+			const data = tryParseJson<Record<string, unknown>>(settingsContent);
+			if (data) {
+				items.push({
+					path: settingsPath,
+					data,
+					level,
+					_source: createSourceMeta(PROVIDER_ID, settingsPath, level),
+				});
+			} else {
+				warnings.push(`Failed to parse ${settingsPath}`);
+			}
 		}
 
+		const configPath = path.join(dir, "config.yml");
+		const configContent = await readFile(configPath);
+		if (!configContent) continue;
+
+		const data = parseYamlSettings(configContent, configPath);
+		if (!data) continue;
+
 		items.push({
-			path: settingsPath,
+			path: configPath,
 			data,
 			level,
-			_source: createSourceMeta(PROVIDER_ID, settingsPath, level),
+			_source: createSourceMeta(PROVIDER_ID, configPath, level),
 		});
 	}
 

package/src/discovery/helpers.ts

@@ -811,9 +811,10 @@ export async function listClaudePluginRoots(
 
 	// ── OMP installed plugins registry ───────────────────────────────────────
 	// OMP registry is authoritative: its entries replace Claude's entries for the same plugin ID.
-	// getPluginsDir() resolves to the same path the marketplace writer uses
-	// (XDG-aware via the dir resolver), so reads and writes always agree.
-	const ompRegistryPath = path.join(getPluginsDir(), "installed_plugins.json");
+	// In production `home` is `os.homedir()`, so `getPluginsDir(home)` resolves to the
+	// same XDG-aware path the marketplace writer uses (reads and writes always agree).
+	// Tests pass a temp dir, which short-circuits the resolver for deterministic isolation.
+	const ompRegistryPath = path.join(getPluginsDir(home), "installed_plugins.json");
 	const ompContent = await readFile(ompRegistryPath);
 	if (ompContent) {
 		const ompRegistry = parseClaudePluginsRegistry(ompContent);

package/src/edit/index.ts

@@ -246,6 +246,7 @@ async function executeSinglePathEntries(
 export class EditTool implements AgentTool<TInput> {
 	readonly name = "edit";
 	readonly label = "Edit";
+	readonly loadMode = "essential";
 	readonly nonAbortable = true;
 	readonly concurrency = "exclusive";
 	readonly strict = true;