@humain/terminal 0.0.3-beta.3 → 0.0.4-beta.2

package/dist/humain/mcp-adapter/vendor/mcp-bearer-store.ts

@@ -0,0 +1,387 @@
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+type KeyringEntry = {
+  getPassword(): string | null;
+  setPassword(password: string): void;
+  deleteCredential(): boolean;
+};
+
+type KeyringEntryConstructor = new (service: string, account: string) => KeyringEntry;
+type KeyringModule = { Entry: KeyringEntryConstructor };
+type KeyringRequire = ((id: string) => unknown) & { resolve(id: string): string };
+
+type BearerSecretStore = {
+  read(account: string): string | undefined;
+  write(account: string, payload: string): void;
+  remove(account: string): void;
+};
+
+interface StoredBearerTokenRecord {
+  token: string;
+  serverUrl: string;
+}
+
+interface BearerChunkManifest {
+  __piMcpAdapterBearerChunked: 1;
+  chunkCount: number;
+  chunkDigest: string;
+}
+
+const require = createRequire(import.meta.url);
+const BEARER_SECRET_SERVICE = "pi-mcp-adapter.bearer";
+const TEST_AUTH_STORE_ENV = "PI_MCP_ADAPTER_TEST_AUTH_STORE";
+const BEARER_SECRET_CHUNK_SIZE = 1000;
+const BEARER_SECRET_VALUE_LIMIT = 1280;
+
+let KeyringEntryClass: KeyringEntryConstructor | undefined;
+const memoryBearerEntries = new Map<string, string>();
+let testBearerSecretStoreReadCount = 0;
+
+export class BearerCredentialStoreError extends Error {
+  readonly code = "BEARER_CREDENTIAL_STORE_UNAVAILABLE";
+  readonly operation: "read" | "write" | "remove";
+
+  // No parameter properties: cli.js loads this module under plain Node
+  // type stripping, which rejects non-erasable TypeScript syntax.
+  constructor(message: string, operation: "read" | "write" | "remove", cause: unknown) {
+    super(message, { cause });
+    this.name = "BearerCredentialStoreError";
+    this.operation = operation;
+  }
+}
+
+export type BearerCredentialStatus =
+  | { status: "present" }
+  | { status: "missing" }
+  | { status: "url-mismatch" }
+  | { status: "unavailable"; message: string };
+
+const memoryBearerSecretStore: BearerSecretStore = {
+  read(account) {
+    testBearerSecretStoreReadCount++;
+    return memoryBearerEntries.get(account);
+  },
+  write(account, payload) {
+    memoryBearerEntries.set(account, payload);
+  },
+  remove(account) {
+    memoryBearerEntries.delete(account);
+  },
+};
+
+const sizeLimitedBearerSecretStore: BearerSecretStore = {
+  read(account) {
+    testBearerSecretStoreReadCount++;
+    return memoryBearerEntries.get(account);
+  },
+  write(account, payload) {
+    if (payload.length > BEARER_SECRET_VALUE_LIMIT) {
+      throw new Error(`Value of 'password encoded as UTF-16' is longer than the platform limit of ${BEARER_SECRET_VALUE_LIMIT * 2} chars`);
+    }
+    memoryBearerEntries.set(account, payload);
+  },
+  remove(account) {
+    memoryBearerEntries.delete(account);
+  },
+};
+
+const unavailableBearerSecretStore: BearerSecretStore = {
+  read() {
+    testBearerSecretStoreReadCount++;
+    throw new Error("simulated secure credential store unavailable");
+  },
+  write() {
+    throw new Error("simulated secure credential store unavailable");
+  },
+  remove() {
+    throw new Error("simulated secure credential store unavailable");
+  },
+};
+
+const keyringBearerSecretStore: BearerSecretStore = {
+  read(account) {
+    return getKeyringEntry(account).getPassword() ?? undefined;
+  },
+  write(account, payload) {
+    getKeyringEntry(account).setPassword(payload);
+  },
+  remove(account) {
+    getKeyringEntry(account).deleteCredential();
+  },
+};
+
+function getBearerSecretStore(): BearerSecretStore {
+  if (process.env[TEST_AUTH_STORE_ENV] === "memory") return memoryBearerSecretStore;
+  if (process.env[TEST_AUTH_STORE_ENV] === "sizelimited") return sizeLimitedBearerSecretStore;
+  if (process.env[TEST_AUTH_STORE_ENV] === "unavailable") return unavailableBearerSecretStore;
+  return keyringBearerSecretStore;
+}
+
+function getKeyringEntry(account: string): KeyringEntry {
+  try {
+    KeyringEntryClass ??= loadKeyringEntryClass();
+    return new KeyringEntryClass(BEARER_SECRET_SERVICE, account);
+  } catch (error) {
+    throw new Error("Bearer token secure credential storage is unavailable. Configure the OS credential store and retry.", { cause: error });
+  }
+}
+
+function loadKeyringEntryClass(keyringRequire: KeyringRequire = require, platform: NodeJS.Platform = process.platform, arch: NodeJS.Architecture = process.arch): KeyringEntryConstructor {
+  try {
+    return (keyringRequire("@napi-rs/keyring") as KeyringModule).Entry;
+  } catch (loaderError) {
+    try {
+      return loadKeyringNativeBindingFallback(keyringRequire, platform, arch).Entry;
+    } catch (fallbackError) {
+      const message = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+      throw new Error(`Failed to load @napi-rs/keyring; absolute-path native binding fallback also failed: ${message}`, { cause: loaderError });
+    }
+  }
+}
+
+function loadKeyringNativeBindingFallback(keyringRequire: KeyringRequire, platform: NodeJS.Platform, arch: NodeJS.Architecture): KeyringModule {
+  const targets = getKeyringNativeBindingSuffixes(platform, arch).map(suffix => ({
+    packageName: `@napi-rs/keyring-${suffix}`,
+    bindingFile: `keyring.${suffix}.node`,
+  }));
+  let lastError: unknown;
+  for (const target of targets) {
+    try {
+      const packageJsonPath = keyringRequire.resolve(`${target.packageName}/package.json`);
+      return keyringRequire(join(dirname(packageJsonPath), target.bindingFile)) as KeyringModule;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+
+function getKeyringNativeBindingSuffixes(platform: NodeJS.Platform, arch: NodeJS.Architecture): string[] {
+  if (platform === "darwin") {
+    if (arch === "arm64") return ["darwin-arm64"];
+    if (arch === "x64") return ["darwin-x64"];
+  }
+  if (platform === "win32") {
+    if (arch === "arm64") return ["win32-arm64-msvc"];
+    if (arch === "x64") return ["win32-x64-msvc"];
+    if (arch === "ia32") return ["win32-ia32-msvc"];
+  }
+  if (platform === "linux") {
+    if (arch === "arm64") return ["linux-arm64-gnu", "linux-arm64-musl"];
+    if (arch === "arm") return ["linux-arm-gnueabihf"];
+    if (arch === "riscv64") return ["linux-riscv64-gnu"];
+    if (arch === "x64") return ["linux-x64-gnu", "linux-x64-musl"];
+  }
+  if (platform === "freebsd" && arch === "x64") return ["freebsd-x64"];
+  return [];
+}
+
+function getBearerAccount(serverName: string): string {
+  if (typeof serverName !== "string") {
+    throw new Error(`Invalid MCP server name: ${JSON.stringify(serverName)}`);
+  }
+  return `sha256-${createHash("sha256").update(serverName, "utf8").digest("hex")}`;
+}
+
+function parseBearerPayload(serverName: string, payload: string): StoredBearerTokenRecord {
+  const parsed = parseStoredBearerJson(serverName, payload);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Stored bearer token record for ${serverName} has invalid shape`);
+  }
+  const record = parsed as Partial<StoredBearerTokenRecord>;
+  if (typeof record.token !== "string" || typeof record.serverUrl !== "string") {
+    throw new Error(`Stored bearer token record for ${serverName} has invalid shape`);
+  }
+  return { token: record.token, serverUrl: record.serverUrl };
+}
+
+function parseStoredBearerJson(serverName: string, payload: string): unknown {
+  try {
+    return JSON.parse(payload) as unknown;
+  } catch {
+    throw new Error(`Failed to parse stored bearer token record for ${serverName}`);
+  }
+}
+
+function isBearerChunkManifest(value: unknown): value is BearerChunkManifest {
+  if (typeof value !== "object" || value === null) return false;
+  const manifest = value as Partial<BearerChunkManifest>;
+  return manifest.__piMcpAdapterBearerChunked === 1
+    && typeof manifest.chunkCount === "number"
+    && Number.isInteger(manifest.chunkCount)
+    && manifest.chunkCount > 0
+    && typeof manifest.chunkDigest === "string"
+    && /^[a-f0-9]{16}$/.test(manifest.chunkDigest);
+}
+
+function readManifest(serverName: string, payload: string): BearerChunkManifest | undefined {
+  const parsed = parseStoredBearerJson(serverName, payload);
+  return isBearerChunkManifest(parsed) ? parsed : undefined;
+}
+
+function chunkAccount(account: string, manifest: BearerChunkManifest, index: number): string {
+  return `${account}.chunk.${manifest.chunkDigest}.${index}`;
+}
+
+function chunkAccounts(account: string, manifest: BearerChunkManifest): string[] {
+  return Array.from({ length: manifest.chunkCount }, (_, index) => chunkAccount(account, manifest, index));
+}
+
+function createManifest(payload: string): BearerChunkManifest {
+  return {
+    __piMcpAdapterBearerChunked: 1,
+    chunkCount: Math.ceil(payload.length / BEARER_SECRET_CHUNK_SIZE),
+    chunkDigest: createHash("sha256").update(payload, "utf8").digest("hex").slice(0, 16),
+  };
+}
+
+function readExistingManifest(store: BearerSecretStore, serverName: string, account: string): BearerChunkManifest | undefined {
+  try {
+    const payload = store.read(account);
+    return payload === undefined ? undefined : readManifest(serverName, payload);
+  } catch {
+    return undefined;
+  }
+}
+
+function removeChunks(store: BearerSecretStore, account: string, manifest: BearerChunkManifest | undefined): void {
+  if (!manifest) return;
+  for (const accountName of chunkAccounts(account, manifest)) store.remove(accountName);
+}
+
+function tryRemoveChunks(store: BearerSecretStore, account: string, manifest: BearerChunkManifest | undefined): void {
+  try {
+    removeChunks(store, account, manifest);
+  } catch {
+    // Stale chunk cleanup must not hide a successful credential write.
+  }
+}
+
+function readBearerRecordFromStore(store: BearerSecretStore, serverName: string): StoredBearerTokenRecord | undefined {
+  const account = getBearerAccount(serverName);
+  let payload: string | undefined;
+  try {
+    payload = store.read(account);
+  } catch (error) {
+    throw new BearerCredentialStoreError(
+      `Failed to read bearer token for ${serverName} from the OS secure credential store`,
+      "read",
+      error,
+    );
+  }
+  if (payload === undefined) return undefined;
+  try {
+    const manifest = readManifest(serverName, payload);
+    const recordPayload = manifest
+      ? chunkAccounts(account, manifest).map((chunkName) => {
+        const chunk = store.read(chunkName);
+        if (chunk === undefined) throw new Error(`Missing bearer token chunk for ${serverName}`);
+        return chunk;
+      }).join("")
+      : payload;
+    return parseBearerPayload(serverName, recordPayload);
+  } catch (error) {
+    throw new BearerCredentialStoreError(
+      `Failed to read bearer token for ${serverName} from the OS secure credential store`,
+      "read",
+      error,
+    );
+  }
+}
+
+function writeBearerRecordToStore(store: BearerSecretStore, serverName: string, record: StoredBearerTokenRecord): void {
+  const account = getBearerAccount(serverName);
+  const payload = JSON.stringify(record);
+  const previousManifest = readExistingManifest(store, serverName, account);
+  const manifest = payload.length > BEARER_SECRET_CHUNK_SIZE ? createManifest(payload) : undefined;
+  try {
+    if (manifest) {
+      for (let index = 0; index < manifest.chunkCount; index++) {
+        store.write(chunkAccount(account, manifest, index), payload.slice(index * BEARER_SECRET_CHUNK_SIZE, (index + 1) * BEARER_SECRET_CHUNK_SIZE));
+      }
+      store.write(account, JSON.stringify(manifest));
+    } else {
+      store.write(account, payload);
+    }
+    if (previousManifest?.chunkDigest !== manifest?.chunkDigest) {
+      tryRemoveChunks(store, account, previousManifest);
+    }
+  } catch (error) {
+    // An identical payload reuses the previous manifest's digest-keyed chunk
+    // accounts. Removing them on a failed rewrite would destroy the still
+    // installed previous credential, so clean up only digest-distinct chunks.
+    if (previousManifest?.chunkDigest !== manifest?.chunkDigest) {
+      tryRemoveChunks(store, account, manifest);
+    }
+    throw new BearerCredentialStoreError(
+      `Failed to write bearer token for ${serverName} to the OS secure credential store`,
+      "write",
+      error,
+    );
+  }
+}
+
+function removeBearerRecordFromStore(store: BearerSecretStore, serverName: string): void {
+  const account = getBearerAccount(serverName);
+  try {
+    const payload = store.read(account);
+    const manifest = payload === undefined ? undefined : readManifest(serverName, payload);
+    removeChunks(store, account, manifest);
+    store.remove(account);
+  } catch (error) {
+    throw new BearerCredentialStoreError(
+      `Failed to remove bearer token for ${serverName} from the OS secure credential store`,
+      "remove",
+      error,
+    );
+  }
+}
+
+export function getBearerTokenForUrl(serverName: string, serverUrl: string): string | undefined {
+  const record = readBearerRecordFromStore(getBearerSecretStore(), serverName);
+  if (!record) return undefined;
+  return record.serverUrl === serverUrl ? record.token : undefined;
+}
+
+export function saveBearerTokenForUrl(serverName: string, token: string, serverUrl: string): void {
+  writeBearerRecordToStore(getBearerSecretStore(), serverName, { token, serverUrl });
+}
+
+export function removeBearerToken(serverName: string): void {
+  removeBearerRecordFromStore(getBearerSecretStore(), serverName);
+}
+
+export function inspectBearerTokenForUrl(serverName: string, serverUrl: string): BearerCredentialStatus {
+  try {
+    const record = readBearerRecordFromStore(getBearerSecretStore(), serverName);
+    if (!record) return { status: "missing" };
+    if (record.serverUrl !== serverUrl) return { status: "url-mismatch" };
+    return { status: "present" };
+  } catch (error) {
+    if (!(error instanceof BearerCredentialStoreError)) throw error;
+    return { status: "unavailable", message: "Bearer token secure credential store unavailable. Configure or unlock the OS credential store and retry." };
+  }
+}
+
+export function resetTestBearerTokenStore(): void {
+  memoryBearerEntries.clear();
+  testBearerSecretStoreReadCount = 0;
+}
+
+export function getTestBearerTokenStoreEntries(): [string, string][] {
+  return [...memoryBearerEntries.entries()];
+}
+
+export function removeTestBearerTokenStoreEntry(account: string): void {
+  memoryBearerEntries.delete(account);
+}
+
+export function setTestBearerTokenStoreEntry(account: string, payload: string): void {
+  memoryBearerEntries.set(account, payload);
+}
+
+export function getTestBearerTokenStoreReadCount(): number {
+  return testBearerSecretStoreReadCount;
+}

package/dist/humain/mcp-adapter/vendor/mcp-callback-server.ts

@@ -180,6 +180,7 @@ interface PendingAuth {
 let server: Server | undefined
 let bindingPromise: Promise<void> | undefined
 let stoppingPromise: Promise<void> | undefined
+let restartableStoppingPromise: Promise<void> | undefined
 let callbackGeneration = 0
 const pendingAuths = new Map<string, PendingAuth>()
 const reservedAuthStates = new Set<string>()
@@ -288,10 +289,16 @@ function handleRequest(req: IncomingMessage, res: ServerResponse): void {
  * If strictPort is false, asks the OS for an available local port.
  */
 export async function ensureCallbackServer(options: EnsureCallbackServerOptions = {}): Promise<void> {
+  const generation = callbackGeneration
   if (stoppingPromise) {
-    throw new Error("OAuth callback server stopped")
+    if (!restartableStoppingPromise) {
+      throw new Error("OAuth callback server stopped")
+    }
+    await restartableStoppingPromise
+    if (generation !== callbackGeneration) {
+      throw new Error("OAuth callback server stopped")
+    }
   }
-  const generation = callbackGeneration
   while (bindingPromise) {
     await bindingPromise
     if (generation !== callbackGeneration) {
@@ -455,7 +462,11 @@ export function cancelPendingCallback(oauthState: string): void {
  * Stop the callback server and reject all pending authorizations.
  */
 export function stopCallbackServer(): Promise<void> {
-  if (stoppingPromise) return stoppingPromise
+  if (stoppingPromise) {
+    restartableStoppingPromise = undefined
+    callbackGeneration += 1
+    return stoppingPromise
+  }
 
   callbackGeneration += 1
   const cleanup = (async () => {
@@ -495,6 +506,19 @@ export function stopCallbackServer(): Promise<void> {
   return operation
 }
 
+/** Stop the callback server only when no bind or authorization owns it. */
+export function stopCallbackServerIfIdle(): Promise<void> {
+  if (stoppingPromise) return stoppingPromise
+  if (bindingPromise || !server || pendingAuths.size > 0 || reservedAuthStates.size > 0) {
+    return Promise.resolve()
+  }
+  const operation = stopCallbackServer().finally(() => {
+    if (restartableStoppingPromise === operation) restartableStoppingPromise = undefined
+  })
+  restartableStoppingPromise = operation
+  return operation
+}
+
 /**
  * Check if the callback server is running.
  */

package/dist/humain/mcp-adapter/vendor/mcp-code.ts

@@ -249,6 +249,10 @@ export async function runMcpScript(
     worker = new Worker(new URL("./mcp-script-worker.mjs", import.meta.url), {
       workerData: { code },
       env: {},
+      // The sandbox cannot open files, and the host always terminates this worker.
+      // Disable Node's unmanaged FD bookkeeping, which emits false warnings when
+      // short-lived workers are terminated on Node 24.
+      trackUnmanagedFds: false,
     });
     const activeWorker = worker;
     const execution = new Promise<void>((resolve, reject) => {

package/dist/humain/mcp-adapter/vendor/mcp-panel.ts

@@ -137,6 +137,8 @@ interface ServerState {
   connectionStatus: ConnectionStatus;
   failureMessage?: string | null;
   tools: ToolState[];
+  directCount: number;
+  directTokens: number;
   hasCachedData: boolean;
 }
 
@@ -241,7 +243,13 @@ class McpPanel {
 
       const status = callbacks.getConnectionStatus(serverName);
       const failureMessage = callbacks.getFailureMessage?.(serverName) ?? null;
-
+      let directCount = 0;
+      let directTokens = 0;
+      for (const tool of tools) {
+        if (!tool.isDirect) continue;
+        directCount++;
+        directTokens += tool.estimatedTokens;
+      }
       this.servers.push({
         name: serverName,
         expanded: false,
@@ -253,6 +261,8 @@ class McpPanel {
         connectionStatus: status,
         failureMessage,
         tools,
+        directCount,
+        directTokens,
         hasCachedData: !!serverCache,
       });
     }
@@ -444,7 +454,7 @@ class McpPanel {
       } else if (item.toolIndex !== undefined) {
         const tool = server.tools[item.toolIndex];
         if (!tool) return;
-        tool.isDirect = !tool.isDirect;
+        this.toggleToolDirect(server, tool);
         if (tool.isDirect && server.source === "import") {
           this.importNotice = `Imported from ${sanitizeDisplayText(server.importKind ?? "external")} — will copy to user config on save`;
         }
@@ -595,11 +605,17 @@ class McpPanel {
       if (server.source === "import" && newState) {
         this.importNotice = `Imported from ${sanitizeDisplayText(server.importKind ?? "external")} — will copy to user config on save`;
       }
-      for (const t of server.tools) t.isDirect = newState;
+      let directTokens = 0;
+      for (const tool of server.tools) {
+        tool.isDirect = newState;
+        if (newState) directTokens += tool.estimatedTokens;
+      }
+      server.directCount = newState ? server.tools.length : 0;
+      server.directTokens = directTokens;
     } else if (item.toolIndex !== undefined) {
       const tool = server.tools[item.toolIndex];
       if (!tool) return;
-      tool.isDirect = !tool.isDirect;
+      this.toggleToolDirect(server, tool);
       if (tool.isDirect && server.source === "import") {
         this.importNotice = `Imported from ${sanitizeDisplayText(server.importKind ?? "external")} — will copy to user config on save`;
       }
@@ -607,6 +623,12 @@ class McpPanel {
     this.updateDirty();
   }
 
+  private toggleToolDirect(server: ServerState, tool: ToolState): void {
+    tool.isDirect = !tool.isDirect;
+    server.directCount += tool.isDirect ? 1 : -1;
+    server.directTokens += tool.isDirect ? tool.estimatedTokens : -tool.estimatedTokens;
+  }
+
   private handleDiscardInput(data: string): void {
     if (matchesKey(data, "ctrl+c")) {
       this.cleanup();
@@ -717,6 +739,13 @@ class McpPanel {
     }
 
     server.tools = newTools;
+    server.directCount = 0;
+    server.directTokens = 0;
+    for (const tool of newTools) {
+      if (!tool.isDirect) continue;
+      server.directCount++;
+      server.directTokens += tool.estimatedTokens;
+    }
     this.rebuildVisibleItems();
     this.updateDirty();
   }
@@ -826,13 +855,14 @@ class McpPanel {
       if (this.authOnly) {
         lines.push(row(fg(t.description, "select a server to authenticate")));
       } else {
-        const directCount = this.servers.reduce((sum, s) => sum + s.tools.filter((t) => t.isDirect).length, 0);
-        const totalTokens = this.servers.reduce(
-          (sum, s) => sum + s.tools.filter((t) => t.isDirect).reduce((ts, t) => ts + t.estimatedTokens, 0),
-          0,
-        );
+        let directCount = 0;
+        let directTokens = 0;
+        for (const server of this.servers) {
+          directCount += server.directCount;
+          directTokens += server.directTokens;
+        }
         const stats =
-          directCount > 0 ? `${directCount} direct  ~${totalTokens.toLocaleString()} tokens` : "no direct tools";
+          directCount > 0 ? `${directCount} direct  ~${directTokens.toLocaleString()} tokens` : "no direct tools";
         lines.push(row(fg(t.description, stats + (this.dirty ? fg(t.needsAuth, "  (unsaved)") : ""))));
       }
     }
@@ -900,7 +930,7 @@ class McpPanel {
       return `${prefix}   ${nameStr}${importLabel}  ${fg(t.description, "(not cached)")}${statusLabel}`;
     }
 
-    const directCount = server.tools.filter((t) => t.isDirect).length;
+    const directCount = server.directCount;
     const totalCount = server.tools.length;
     let toggleIcon = fg(t.description, "○");
     if (directCount === totalCount && totalCount > 0) {
@@ -913,8 +943,7 @@ class McpPanel {
     if (totalCount > 0) {
       toolInfo = `${directCount}/${totalCount}`;
       if (directCount > 0) {
-        const tokens = server.tools.filter((t) => t.isDirect).reduce((s, t) => s + t.estimatedTokens, 0);
-        toolInfo += `  ~${tokens.toLocaleString()}`;
+        toolInfo += `  ~${server.directTokens.toLocaleString()}`;
       }
       toolInfo = fg(t.description, toolInfo);
     }

package/dist/humain/mcp-adapter/vendor/metadata-cache.ts

@@ -19,7 +19,7 @@ import type {
   ToolMetadata,
   PromptMetadata,
 } from "./types.ts";
-import { createToolSelectorCandidateIndex, formatPromptCommandName, formatToolName, getToolNameCandidates, isServerDisabled, isToolAllowed, resolveToolPrefix, type ToolPrefix } from "./types.ts";
+import { createToolSelectorCandidateIndex, formatPromptCommandName, formatToolName, getToolNameCandidates, isServerDisabled, isToolAllowed, resolveToolPrefix, type ToolPrefix, type ToolSelectorCandidateIndex } from "./types.ts";
 import { resourceNameToToolName } from "./resource-tools.ts";
 import {
   extractToolUiStreamMode,
@@ -75,7 +75,7 @@ export function saveMetadataCache(cache: MetadataCache): void {
   merged.servers = { ...merged.servers, ...cache.servers };
 
   const tmpPath = `${cachePath}.${process.pid}.tmp`;
-  writeFileSync(tmpPath, JSON.stringify(merged, null, 2), "utf-8");
+  writeFileSync(tmpPath, JSON.stringify(merged), "utf-8");
   renameSync(tmpPath, cachePath);
 }
 
@@ -189,6 +189,7 @@ export function reconstructToolMetadata(
   definition: Pick<ServerEntry, "exposeResources" | "includeTools" | "excludeTools" | "toolPrefix">,
   configuredServers?: Record<string, ServerEntry>,
   cache?: MetadataCache,
+  sharedSelectorCandidateIndex?: ToolSelectorCandidateIndex,
 ): ToolMetadata[] {
   const metadata: ToolMetadata[] = [];
   const seenNames = new Set<string>();
@@ -196,25 +197,11 @@ export function reconstructToolMetadata(
   const hasToolFilters =
     (Array.isArray(definition.includeTools) && definition.includeTools.length > 0) ||
     (Array.isArray(definition.excludeTools) && definition.excludeTools.length > 0);
-  const selectorCandidateIndex = hasToolFilters && configuredServers && cache ? (() => {
-    const candidates = new Set<string>();
-    for (const [otherServerName, otherDefinition] of Object.entries(configuredServers)) {
-      const otherEntry = cache.servers[otherServerName];
-      if (!otherEntry || !isServerCacheValid(otherEntry, otherDefinition) || isServerDisabled(otherDefinition)) continue;
-      const otherPrefix = resolveToolPrefix(otherDefinition, prefix);
-      for (const otherTool of otherEntry.tools ?? []) {
-        if (!isUiToolVisibleToModel(otherTool.uiVisibility)) continue;
-        for (const candidate of getToolNameCandidates(otherTool.name, otherServerName, otherPrefix, false)) candidates.add(candidate);
-      }
-      if (otherDefinition.exposeResources !== false) {
-        for (const resource of otherEntry.resources ?? []) {
-          const baseName = `read_${resourceNameToToolName(resource.name)}`;
-          for (const candidate of getToolNameCandidates(baseName, otherServerName, otherPrefix, false)) candidates.add(candidate);
-        }
-      }
-    }
-    return createToolSelectorCandidateIndex(candidates);
-  })() : undefined;
+  const selectorCandidateIndex = hasToolFilters
+    ? sharedSelectorCandidateIndex ?? (configuredServers && cache
+      ? createCachedToolSelectorCandidateIndex(configuredServers, cache, prefix)
+      : undefined)
+    : undefined;
 
   for (const tool of entry.tools ?? []) {
     if (!tool?.name) continue;
@@ -268,6 +255,30 @@ export function reconstructToolMetadata(
   return metadata;
 }
 
+export function createCachedToolSelectorCandidateIndex(
+  configuredServers: Record<string, ServerEntry>,
+  cache: MetadataCache,
+  prefix: ToolPrefix,
+): ToolSelectorCandidateIndex {
+  const candidates = new Set<string>();
+  for (const [serverName, definition] of Object.entries(configuredServers)) {
+    const entry = cache.servers[serverName];
+    if (!entry || !isServerCacheValid(entry, definition) || isServerDisabled(definition)) continue;
+    const effectivePrefix = resolveToolPrefix(definition, prefix);
+    for (const tool of entry.tools ?? []) {
+      if (!isUiToolVisibleToModel(tool.uiVisibility)) continue;
+      for (const candidate of getToolNameCandidates(tool.name, serverName, effectivePrefix, false)) candidates.add(candidate);
+    }
+    if (definition.exposeResources !== false) {
+      for (const resource of entry.resources ?? []) {
+        const baseName = `read_${resourceNameToToolName(resource.name)}`;
+        for (const candidate of getToolNameCandidates(baseName, serverName, effectivePrefix, false)) candidates.add(candidate);
+      }
+    }
+  }
+  return createToolSelectorCandidateIndex(candidates);
+}
+
 export function serializeTools(tools: McpTool[]): CachedTool[] {
   return tools
     .filter(t => t?.name)