@bastani/atomic 0.9.23-alpha.1 → 0.9.24-alpha.1

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [0.9.24-alpha.1] - 2026-09-28
+
+### Added
+
+- Added inherited Claude Sonnet 5.5 support for Anthropic with adaptive thinking, mid-conversation effort, and a 1M context window.
+- llama.cpp models are now also listed as classifier models with the same ID, so a local model can make `model: "auto"` routing decisions the way TypeSafe Jev does. Because an explicit `routerModel` resolves a classifier before a chat model, `routerModel: "llama.cpp/<id>"` now routes with the classifier instead of the chat model ([#10119](https://github.com/earendil-works/pi/pull/10119)).
+- Packages can contribute MCP servers with `"atomic": { "mcpServers": "./mcp.json" }` or an inline `mcpServers` object, and extensions can add runtime-computed servers with `pi.registerMcpServer(name, config)` from the factory or `session_start`. Contributed servers are the lowest-precedence MCP layer, so a same-named server in any user or project MCP config replaces them. Package filters accept `mcpServers` name patterns, project packages contribute servers only in trusted projects, and workflow stages see the same servers ([#3355](https://github.com/bastani-inc/atomic/issues/3355)).
+
+### Changed
+
+- Recorded Claude Sonnet 5.5 results in the evals snapshot used by automatic model routing: Artificial Analysis Intelligence Index rows for max, xhigh, high, medium and low effort, Cognition FrontierCode 1.1, and Anthropic's published OSWorld, AutomationBench, BenchCAD, Humanity's Last Exam (with tools) and Terminal-Bench-Science scores.
+
+### Fixed
+
+- OpenCode Go now defaults to Kimi K3 (`kimi-k3`). models.dev deprecated Kimi K2.6 for OpenCode Go, which removed it from the built-in catalog, so the previous default no longer resolved.
+- Together now defaults to Kimi K3 (`moonshotai/Kimi-K3`). models.dev removed Kimi K2.6 from Together, which removed it from the built-in catalog, so the previous default no longer resolved.
+- Fixed extension tool schemas leaking TypeBox `~kind`/`~optional` metadata into provider requests, which made Fireworks reject every request with `JSON Schema not supported` ([#3330](https://github.com/bastani-inc/atomic/issues/3330)).
+- Resuming a session no longer appends a spurious system-prompt `tools` update when only the order of the active tools changed, so the resumed session keeps its prompt cache and the model is no longer told that unchanged tools were removed ([#3346](https://github.com/bastani-inc/atomic/issues/3346)).
+- Switching sessions with `/resume` or closing a session before sending a message no longer leaves a header-only session file behind ([#3347](https://github.com/bastani-inc/atomic/issues/3347)).
+- Fixed pasting files copied in Finder with `Ctrl+V` inserting the file icon as an image instead of the file paths. Copied files now paste as their paths, shell-quoted in bash mode, and clipboard read errors are reported instead of pasting the icon ([#10136](https://github.com/earendil-works/pi/pull/10136)).
+
+## [0.9.23] - 2026-09-27
+
+### Fixed
+
+- Long sessions no longer leak one open file per bash command. A finished command now releases its output file, an output file with no output is deleted, and output files left behind by Atomic processes that have exited are removed. On macOS, where a child process cannot receive a file descriptor numbered 10240 or higher, the leak eventually made every bash call and spawn fail with `Bad file descriptor`; if a spawn still fails that way, the error now names the cause ([#3313](https://github.com/bastani-inc/atomic/issues/3313)).
+- Resuming a run that failed in a `ctx.tool` call now works when the call ran in parallel with other tools. Siblings that were cancelled or also threw when the run failed are run again on resume, in any order, instead of failing with `replay topology mismatch` or `unfinished or missing completed tool checkpoint`. A resume rejected by changed code no longer runs the failed tool or makes the run unresumable, including after Atomic restarts ([#3314](https://github.com/bastani-inc/atomic/issues/3314)).
+- `model: "auto"` routing no longer ignores benchmark results when fewer than four models are available. Each model's results are now ranked against every model in the evals catalog rather than only the models you can route to, so with just two or three models (for example Opus and Haiku) the stronger model is no longer outranked on price alone, and a model scores the same however many models are enabled.
+
 ## [0.9.23-alpha.1] - 2026-09-27
 
 ### Fixed

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.23-alpha.1",
+  "version": "0.9.24-alpha.1",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions. Fork of: https://github.com/nicobailon/pi-intercom",
   "contributors": [

package/dist/builtin/mcp/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.24-alpha.1] - 2026-09-28
+
+### Added
+
+- MCP servers contributed by packages and by `pi.registerMcpServer()` load as the lowest-precedence config layer, including registrations made after MCP has started. A same-named server in any MCP config file replaces a contributed one, and `"disabled": true` on a server entry, alone or with other fields, removes it. `/mcp` and connection errors show which package or extension contributed each server ([#3355](https://github.com/bastani-inc/atomic/issues/3355)).
+
 ## [0.9.20] - 2026-09-24
 
 ### Fixed

package/dist/builtin/mcp/README.md

@@ -141,6 +141,7 @@ Pi-specific files are the write targets for imported or shared global servers wh
 | `directTools` | `true`, `string[]`, or `false` — register tools individually instead of through proxy |
 | `excludeTools` | `string[]` of tool names to hide (matches original names like `get_screenshot` and prefixed names like `figma_get_screenshot`) |
 | `debug` | Show server stderr (default: false) |
+| `disabled` | `true` removes the server from the effective config; `{ "disabled": true }` alone turns off a server contributed by a package or extension |
 
 `timeoutMs` is an **inactivity timeout**, not a total wall-clock limit. Each MCP progress notification resets the timer, so a tool that continues reporting progress can run indefinitely. The value must be a finite number greater than zero; invalid values produce a configuration error when the MCP config loads.
 

package/dist/builtin/mcp/index.bundle.mjs

@@ -6517,15 +6517,51 @@ function getMcpDiscoverySummary(overridePath, cwd = process.cwd()) {
     repoPrompt: detectRepoPrompt(summaryWithoutRepoPrompt, cwd)
   };
 }
-function loadMcpConfig(overridePath, cwd = process.cwd()) {
-  let config = { mcpServers: {} };
+function loadMcpConfig(overridePath, cwd = process.cwd(), contributions = []) {
+  let config = { mcpServers: validateContributedServers(contributions) };
   for (const source of getConfigSources(overridePath, cwd)) {
     const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
     if (!loaded)
       continue;
     config = mergeConfigs(config, expandImports(loaded, cwd));
   }
-  return config;
+  return withoutDisabledServers(config);
+}
+function describeMcpContributionSource(contribution) {
+  const { origin, sourceInfo } = contribution;
+  if (origin === "package")
+    return `package ${sourceInfo.source}`;
+  return sourceInfo.origin === "package" ? `extension from package ${sourceInfo.source}` : `extension ${sourceInfo.path}`;
+}
+function getContributedServerSources(overridePath, cwd, contributions) {
+  const sources = new Map;
+  if (contributions.length === 0)
+    return sources;
+  for (const [name, provenance] of getServerProvenance(overridePath, cwd, contributions)) {
+    if (provenance.kind === "contributed" && provenance.source)
+      sources.set(name, provenance.source);
+  }
+  return sources;
+}
+function validateContributedServers(contributions) {
+  const servers = {};
+  for (const contribution of contributions) {
+    try {
+      Object.assign(servers, validateMcpServerTimeouts({ [contribution.name]: contribution.config }));
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      const message = `Ignoring MCP server "${contribution.name}" from ${describeMcpContributionSource(contribution)}: ${reason}`;
+      if (!reportOwnedMcpLog("warn"))
+        console.warn(message);
+    }
+  }
+  return servers;
+}
+function withoutDisabledServers(config) {
+  const enabled = Object.entries(config.mcpServers).filter(([, entry]) => entry.disabled !== true);
+  if (enabled.length === Object.keys(config.mcpServers).length)
+    return config;
+  return { ...config, mcpServers: Object.fromEntries(enabled) };
 }
 function getConfigSources(overridePath, cwd = process.cwd()) {
   const userPath = getPiGlobalConfigPath(overridePath);
@@ -6806,9 +6842,16 @@ function writeSharedServerEntry(filePath, serverName, entry) {
   writeRawConfigObject(filePath, raw);
   return filePath;
 }
-function getServerProvenance(overridePath, cwd = process.cwd()) {
+function getServerProvenance(overridePath, cwd = process.cwd(), contributions = []) {
   const provenance = new Map;
   const userPath = getPiGlobalConfigPath(overridePath);
+  for (const contribution of contributions) {
+    provenance.set(contribution.name, {
+      path: userPath,
+      kind: "contributed",
+      source: describeMcpContributionSource(contribution)
+    });
+  }
   for (const source of getConfigSources(overridePath, cwd)) {
     const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
     if (!loaded)
@@ -6822,7 +6865,7 @@ function getServerProvenance(overridePath, cwd = process.cwd()) {
           const imported = JSON.parse(readFileSync2(importPath, "utf-8"));
           const servers = extractServers(imported, importKind);
           for (const name of Object.keys(servers)) {
-            if (!provenance.has(name)) {
+            if (!provenance.has(name) || provenance.get(name)?.kind === "contributed") {
               provenance.set(name, { path: userPath, kind: "import", importKind });
             }
           }
@@ -6854,7 +6897,7 @@ function writeDirectToolsConfig(changes, provenance, fullConfig) {
     const raw = readRawConfigObject(filePath);
     const servers = getServersObject(raw);
     for (const { name, value, prov } of entries) {
-      if (prov.kind === "import") {
+      if (prov.kind === "import" || prov.kind === "contributed") {
         const fullDef = fullConfig.mcpServers[name];
         if (fullDef) {
           servers[name] = { ...fullDef, directTools: value };
@@ -7193,6 +7236,11 @@ class McpLifecycleManager {
       this.serverSettings.set(name, settings);
     }
   }
+  unregisterServer(name) {
+    this.allServers.delete(name);
+    this.keepAliveServers.delete(name);
+    this.serverSettings.delete(name);
+  }
   setGlobalIdleTimeout(minutes) {
     this.globalIdleTimeout = minutes * 60 * 1000;
   }
@@ -7200,6 +7248,8 @@ class McpLifecycleManager {
     this.onIdleShutdown = callback;
   }
   startHealthChecks(intervalMs = 30000) {
+    if (this.healthCheckInterval)
+      return;
     this.healthCheckInterval = setInterval(() => {
       this.checkConnections();
     }, intervalMs);
@@ -7238,6 +7288,7 @@ class McpLifecycleManager {
   async gracefulShutdown() {
     if (this.healthCheckInterval) {
       clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = undefined;
     }
     await this.manager.closeAll();
   }
@@ -22249,7 +22300,9 @@ var init_ui_resource_handler = __esm(() => {
 // dist/builtin/mcp/init.ts
 var exports_init = {};
 __export(exports_init, {
+  applyMcpConfigChanges: () => applyMcpConfigChanges,
   flushMetadataCache: () => flushMetadataCache,
+  formatMcpServerName: () => formatMcpServerName,
   getFailureAgeSeconds: () => getFailureAgeSeconds,
   initializeMcp: () => initializeMcp,
   lazyConnect: () => lazyConnect,
@@ -22260,7 +22313,8 @@ __export(exports_init, {
 import { existsSync as existsSync6 } from "node:fs";
 async function initializeMcp(pi, ctx) {
   const configPath = pi.getFlag("mcp-config");
-  const config = loadMcpConfig(configPath, ctx.cwd);
+  const contributions = pi.getMcpServerContributions?.() ?? [];
+  const config = loadMcpConfig(configPath, ctx.cwd, contributions);
   const manager = new McpServerManager;
   const lifecycle = new McpLifecycleManager(manager);
   try {
@@ -22284,6 +22338,7 @@ async function initializeMcp(pi, ctx) {
       lifecycle,
       toolMetadata,
       config,
+      contributedSources: getContributedServerSources(configPath, ctx.cwd, contributions),
       failureTracker,
       uiResourceHandler,
       consentManager,
@@ -22310,16 +22365,7 @@ async function initializeMcp(pi, ctx) {
     }
     const prefix = config.settings?.toolPrefix ?? "server";
     for (const [name, definition] of serverEntries) {
-      const lifecycleMode = definition.lifecycle ?? "lazy";
-      const idleOverride = definition.idleTimeout ?? (lifecycleMode === "eager" ? 0 : undefined);
-      lifecycle.registerServer(name, definition, idleOverride !== undefined ? { idleTimeout: idleOverride } : undefined);
-      if (lifecycleMode === "keep-alive") {
-        lifecycle.markKeepAlive(name, definition);
-      }
-      if (cache?.servers?.[name] && isServerCacheValid(cache.servers[name], definition)) {
-        const metadata = reconstructToolMetadata(name, cache.servers[name], prefix, definition);
-        toolMetadata.set(name, metadata);
-      }
+      registerServer(state, name, definition, cache, prefix);
     }
     const startupServers = serverEntries.filter(([, definition]) => {
       const mode = definition.lifecycle ?? "lazy";
@@ -22343,7 +22389,7 @@ async function initializeMcp(pi, ctx) {
     for (const { name, definition, connection, error } of results) {
       if (error || !connection) {
         if (ctx.hasUI) {
-          ctx.ui.notify(`MCP: Failed to connect to ${name}: ${error}`, "error");
+          ctx.ui.notify(`MCP: Failed to connect to ${formatMcpServerName(state, name)}: ${error}`, "error");
         }
         reportMcpDiagnostic(pi, "MCP startup connection failed");
         continue;
@@ -22362,18 +22408,7 @@ async function initializeMcp(pi, ctx) {
       const msg = failedCount > 0 ? `MCP: ${connectedCount}/${startupServers.length} servers connected (${totalTools} tools)` : `MCP: ${connectedCount} servers connected (${totalTools} tools)`;
       ctx.ui.notify(msg, "info");
     }
-    lifecycle.setReconnectCallback((serverName) => {
-      updateServerMetadata(state, serverName);
-      updateMetadataCache(state, serverName);
-      state.failureTracker.delete(serverName);
-      updateStatusBar(state);
-    });
-    lifecycle.setIdleShutdownCallback((serverName) => {
-      const idleMinutes = getEffectiveIdleTimeoutMinutes(state, serverName);
-      logger.debug(`${serverName} shut down (idle ${idleMinutes}m)`);
-      updateStatusBar(state);
-    });
-    lifecycle.startHealthChecks();
+    startLifecycle(state);
     return state;
   } catch (error) {
     try {
@@ -22385,6 +22420,61 @@ async function initializeMcp(pi, ctx) {
     throw error;
   }
 }
+function formatMcpServerName(state, name) {
+  const source = state.contributedSources?.get(name);
+  return source ? `${name} (${source})` : name;
+}
+function registerServer(state, name, definition, cache, prefix) {
+  const lifecycleMode = definition.lifecycle ?? "lazy";
+  const idleOverride = definition.idleTimeout ?? (lifecycleMode === "eager" ? 0 : undefined);
+  state.lifecycle.registerServer(name, definition, idleOverride !== undefined ? { idleTimeout: idleOverride } : undefined);
+  if (lifecycleMode === "keep-alive") {
+    state.lifecycle.markKeepAlive(name, definition);
+  }
+  if (cache?.servers?.[name] && isServerCacheValid(cache.servers[name], definition)) {
+    const metadata = reconstructToolMetadata(name, cache.servers[name], prefix, definition);
+    state.toolMetadata.set(name, metadata);
+  }
+}
+function startLifecycle(state) {
+  state.lifecycle.setReconnectCallback((serverName) => {
+    updateServerMetadata(state, serverName);
+    updateMetadataCache(state, serverName);
+    state.failureTracker.delete(serverName);
+    updateStatusBar(state);
+  });
+  state.lifecycle.setIdleShutdownCallback((serverName) => {
+    const idleMinutes = getEffectiveIdleTimeoutMinutes(state, serverName);
+    logger.debug(`${serverName} shut down (idle ${idleMinutes}m)`);
+    updateStatusBar(state);
+  });
+  state.lifecycle.startHealthChecks();
+}
+async function applyMcpConfigChanges(state, configPath, cwd, contributions) {
+  const previous = state.config.mcpServers;
+  const next = loadMcpConfig(configPath, cwd, contributions).mcpServers;
+  const changed = [...new Set([...Object.keys(previous), ...Object.keys(next)])].filter((name) => JSON.stringify(previous[name]) !== JSON.stringify(next[name]));
+  state.config = { ...state.config, mcpServers: next };
+  state.contributedSources = getContributedServerSources(configPath, cwd, contributions);
+  if (changed.length === 0)
+    return changed;
+  const cache = loadMetadataCache();
+  const settings = state.config.settings;
+  const prefix = settings?.toolPrefix ?? "server";
+  state.lifecycle.setGlobalIdleTimeout(typeof settings?.idleTimeout === "number" ? settings.idleTimeout : 10);
+  for (const name of changed) {
+    await state.manager.close(name);
+    state.lifecycle.unregisterServer(name);
+    state.toolMetadata.delete(name);
+    state.failureTracker.delete(name);
+    const definition = next[name];
+    if (definition)
+      registerServer(state, name, definition, cache, prefix);
+  }
+  startLifecycle(state);
+  updateStatusBar(state);
+  return changed;
+}
 function updateServerMetadata(state, serverName) {
   const connection = state.manager.getConnection(serverName);
   if (!connection || connection.status !== "connected")
@@ -23148,6 +23238,7 @@ function buildServerStates(config, cache, provenance, callbacks, authOnly, prefi
       expanded: false,
       source: prov?.kind ?? "user",
       importKind: prov?.importKind,
+      contributedBy: prov?.source,
       excludeTools: definition.excludeTools,
       exposeResources: definition.exposeResources !== false,
       connectionStatus: callbacks.getConnectionStatus(serverName),
@@ -23323,7 +23414,8 @@ function renderServerRow(context, server, isCursor) {
   const expandIcon = server.expanded ? "▾" : "▸";
   const prefix = isCursor ? fg2(t.selected, expandIcon) : fg2(t.border, server.expanded ? expandIcon : "·");
   const nameStr = isCursor ? bold(fg2(t.selected, server.name)) : server.name;
-  const importLabel = server.source === "import" ? fg2(t.description, ` (${server.importKind ?? "import"})`) : "";
+  const originLabel = server.source === "import" ? ` (${server.importKind ?? "import"})` : server.source === "contributed" ? ` (${server.contributedBy ?? "contributed"})` : "";
+  const importLabel = originLabel ? fg2(t.description, originLabel) : "";
   const statusLabel = renderConnectionStatus(context, server);
   if (!server.hasCachedData && !context.authOnly) {
     return `${prefix}   ${nameStr}${importLabel}  ${fg2(t.description, "(not cached)")}${statusLabel}`;
@@ -23692,9 +23784,8 @@ class McpPanel {
     if (item.toolIndex !== undefined) {
       const tool = server.tools[item.toolIndex];
       tool.isDirect = !tool.isDirect;
-      if (tool.isDirect && server.source === "import") {
-        this.importNotice = `Imported from ${server.importKind ?? "external"} — will copy to user config on save`;
-      }
+      if (tool.isDirect)
+        this.noteCopyToUserConfig(server);
       this.updateDirty();
     }
   }
@@ -23748,23 +23839,28 @@ class McpPanel {
       this.tui.requestRender();
     });
   }
+  noteCopyToUserConfig(server) {
+    if (server.source === "import") {
+      this.importNotice = `Imported from ${server.importKind ?? "external"} — will copy to user config on save`;
+    } else if (server.source === "contributed") {
+      this.importNotice = `Contributed by ${server.contributedBy ?? "a package"} — will copy to user config on save`;
+    }
+  }
   toggleItem(item) {
     if (this.authOnly)
       return;
     const server = this.servers[item.serverIndex];
     if (item.type === "server") {
       const newState = !server.tools.every((tool) => tool.isDirect);
-      if (server.source === "import" && newState) {
-        this.importNotice = `Imported from ${server.importKind ?? "external"} — will copy to user config on save`;
-      }
+      if (newState)
+        this.noteCopyToUserConfig(server);
       for (const tool of server.tools)
         tool.isDirect = newState;
     } else if (item.toolIndex !== undefined) {
       const tool = server.tools[item.toolIndex];
       tool.isDirect = !tool.isDirect;
-      if (tool.isDirect && server.source === "import") {
-        this.importNotice = `Imported from ${server.importKind ?? "external"} — will copy to user config on save`;
-      }
+      if (tool.isDirect)
+        this.noteCopyToUserConfig(server);
     }
     this.updateDirty();
   }
@@ -23865,7 +23961,7 @@ async function showStatus(state, ctx) {
       status = "cached";
     }
     const toolSuffix = failed ? "" : ` (${toolCount} tools${status === "cached" ? ", cached" : ""})`;
-    lines.push(`${statusIcon} ${name}: ${status}${toolSuffix}`);
+    lines.push(`${statusIcon} ${formatMcpServerName(state, name)}: ${status}${toolSuffix}`);
   }
   if (Object.keys(state.config.mcpServers).length === 0) {
     lines.push("No MCP servers configured");
@@ -23925,7 +24021,7 @@ async function reconnectServers(state, ctx, targetServer) {
       const message = error instanceof Error ? error.message : String(error);
       state.failureTracker.set(name, Date.now());
       if (ctx.hasUI) {
-        ctx.ui.notify(`MCP: Failed to reconnect to ${name}: ${message}`, "error");
+        ctx.ui.notify(`MCP: Failed to reconnect to ${formatMcpServerName(state, name)}: ${message}`, "error");
       }
     }
   }
@@ -24091,7 +24187,7 @@ async function openMcpPanel(state, pi, ctx, configOverridePath) {
   const config = state.config;
   const cache = loadMetadataCache();
   const configPath = pi.getFlag("mcp-config") ?? configOverridePath;
-  const provenanceMap = getServerProvenance(configPath, ctx.cwd);
+  const provenanceMap = getServerProvenance(configPath, ctx.cwd, pi.getMcpServerContributions?.() ?? []);
   const { lines: noticeLines, fingerprint } = buildSharedConfigNoticeLines(configPath, ctx.cwd);
   const callbacks = buildMcpPanelCallbacks(state, config, ctx);
   await Promise.resolve().then(() => init_mcp_panel());
@@ -24125,7 +24221,7 @@ async function openMcpAuthPanel(state, pi, ctx, configOverridePath) {
   }
   const cache = loadMetadataCache();
   const configPath = pi.getFlag("mcp-config") ?? configOverridePath;
-  const provenanceMap = getServerProvenance(configPath, ctx.cwd);
+  const provenanceMap = getServerProvenance(configPath, ctx.cwd, pi.getMcpServerContributions?.() ?? []);
   const callbacks = buildMcpPanelCallbacks(state, config, ctx);
   await Promise.resolve().then(() => init_mcp_panel());
   await new Promise((resolve) => {
@@ -27076,13 +27172,29 @@ function mcpAdapter(pi) {
   let renderConfig;
   let initPromise = null;
   let lifecycleGeneration = 0;
-  let registeredDirectToolNames = new Set;
+  let registeredDirectTools = new Map;
+  const retiredDirectToolNames = new Set;
   let registeredProxyTool = false;
   let startupWarmupCancel = null;
   let activeSession = null;
   let stateOwner = null;
   const cleanupBarrier = new McpSessionCleanupBarrier;
   const unpublishedCleanupFailures = [];
+  let contributionRevision = 0;
+  let contributionRefresh = Promise.resolve();
+  const getContributions = () => pi.getMcpServerContributions?.() ?? [];
+  const getConfigPath = () => pi.getFlag("mcp-config") ?? earlyConfigPath;
+  function forgetDirectToolRegistrations() {
+    registeredDirectTools = new Map([...registeredDirectTools.keys()].map((name) => [name, ""]));
+  }
+  function startsWithSession(server) {
+    return server?.lifecycle === "eager" || server?.lifecycle === "keep-alive";
+  }
+  function registerProxyToolIfNeeded(config, directToolState) {
+    if (config.settings?.disableProxyTool !== true || directToolState.directToolCount === 0 || directToolState.missingConfiguredDirectToolServers.length > 0) {
+      registerProxyTool();
+    }
+  }
   async function registerDirectToolsFromConfig(config, cache, subagentPolicy) {
     const [{ resolveDirectTools, createDirectToolExecutor, getMissingConfiguredDirectToolServers }, { truncateAtWord }] = await Promise.all([
       Promise.resolve().then(() => (init_direct_tools(), exports_direct_tools)),
@@ -27091,10 +27203,22 @@ function mcpAdapter(pi) {
     const prefix = config.settings?.toolPrefix ?? "server";
     const directTools = subagentPolicy?.mcpDirectTools;
     const directSpecs = resolveDirectTools(config, cache, prefix, directTools === undefined ? undefined : [...directTools]);
+    const resolvedNames = new Set(directSpecs.map((spec) => spec.prefixedName));
+    const obsoleteNames = [...registeredDirectTools.keys()].filter((name) => !resolvedNames.has(name));
+    const revivedNames = directSpecs.map((spec) => spec.prefixedName).filter((name) => retiredDirectToolNames.has(name));
+    const activeNames = new Set(obsoleteNames.length > 0 ? pi.getActiveTools() : []);
+    for (const name of obsoleteNames) {
+      registeredDirectTools.delete(name);
+      if (activeNames.has(name))
+        retiredDirectToolNames.add(name);
+    }
+    for (const name of revivedNames)
+      retiredDirectToolNames.delete(name);
     for (const spec of directSpecs) {
-      if (registeredDirectToolNames.has(spec.prefixedName))
+      const signature = JSON.stringify([spec.serverName, spec.originalName, spec.description, spec.inputSchema]);
+      if (registeredDirectTools.get(spec.prefixedName) === signature)
         continue;
-      registeredDirectToolNames.add(spec.prefixedName);
+      registeredDirectTools.set(spec.prefixedName, signature);
       pi.registerTool({
         name: spec.prefixedName,
         label: `MCP: ${spec.originalName}`,
@@ -27108,6 +27232,10 @@ function mcpAdapter(pi) {
     }
     const refreshTools = pi.refreshTools;
     refreshTools?.();
+    if (obsoleteNames.length > 0 || revivedNames.length > 0) {
+      const obsolete = new Set(obsoleteNames);
+      pi.setActiveTools([...pi.getActiveTools().filter((name) => !obsolete.has(name)), ...revivedNames]);
+    }
     return {
       directToolCount: directSpecs.length,
       missingConfiguredDirectToolServers: getMissingConfiguredDirectToolServers(config, cache, directTools)
@@ -27188,6 +27316,7 @@ function mcpAdapter(pi) {
       throw new Error(`${STALE_INITIALIZATION_PREFIX} before startup`);
     }
     let candidate = null;
+    const revision = contributionRevision;
     try {
       candidate = await initializeMcp(pi, session.ctx);
       const initializedState = candidate;
@@ -27198,9 +27327,7 @@ function mcpAdapter(pi) {
       if (!isCurrentSession(session) || initPromise !== expectedPromise.current) {
         throw new Error(`${STALE_INITIALIZATION_PREFIX} after tool registration`);
       }
-      if (initializedState.config.settings?.disableProxyTool !== true || directToolState.directToolCount === 0 || directToolState.missingConfiguredDirectToolServers.length > 0) {
-        registerProxyTool();
-      }
+      registerProxyToolIfNeeded(initializedState.config, directToolState);
       updateStatusBar(initializedState);
       let cancelWarmup = null;
       const warmup = scheduleMcpStartupWarmup(initializedState, {
@@ -27222,6 +27349,8 @@ function mcpAdapter(pi) {
       startupWarmupCancel = cancelWarmup;
       stateOwner = session;
       state = initializedState;
+      if (revision !== contributionRevision)
+        scheduleContributionRefresh(session);
       return initializedState;
     } catch (error) {
       if (candidate && state !== candidate) {
@@ -27268,6 +27397,56 @@ function mcpAdapter(pi) {
     });
     return attempt;
   }
+  function scheduleContributionRefresh(session) {
+    contributionRefresh = contributionRefresh.then(() => refreshContributedServers(session)).catch((error) => {
+      if (!isCurrentSession(session) || isStaleExtensionContextError(error))
+        return;
+      if (!reportOwnedMcpLog("error"))
+        console.error("MCP: failed to apply contributed MCP server changes", error);
+    });
+  }
+  async function refreshContributedServers(session) {
+    if (!isCurrentSession(session))
+      return;
+    const configPath = getConfigPath();
+    const contributions = getContributions();
+    const current = state;
+    if (current && isOwnedState(current, session)) {
+      await Promise.resolve().then(() => init_init());
+      const changed = await applyMcpConfigChanges(current, configPath, session.ctx.cwd, contributions);
+      renderConfig = current.config;
+      if (!isOwnedState(current, session))
+        return;
+      registerProxyToolIfNeeded(current.config, await registerDirectTools(current, session.ctx.subagentPolicy));
+      for (const name of changed) {
+        if (!startsWithSession(current.config.mcpServers[name]))
+          continue;
+        lazyConnect(current, name).then(async (connected) => {
+          if (!isOwnedState(current, session)) {
+            await current.manager.close(name);
+          } else if (connected) {
+            registerProxyToolIfNeeded(current.config, await registerDirectTools(current, session.ctx.subagentPolicy));
+          } else if (current.failureTracker.has(name)) {
+            current.ui?.notify(`MCP: Failed to connect to ${formatMcpServerName(current, name)}`, "error");
+          }
+        }).catch(() => {
+          return;
+        });
+      }
+      return;
+    }
+    const config = loadMcpConfig(configPath, session.ctx.cwd, contributions);
+    renderConfig = config;
+    await Promise.resolve().then(() => init_metadata_cache());
+    if (!isCurrentSession(session))
+      return;
+    registerProxyToolIfNeeded(config, await registerDirectToolsFromConfig(config, loadMetadataCache()));
+    if (isCurrentSession(session) && !state && !initPromise && Object.values(config.mcpServers).some(startsWithSession)) {
+      ensureMcpInitialized().catch(() => {
+        return;
+      });
+    }
+  }
   pi.on("session_start", async (_event, ctx) => {
     const generation = ++lifecycleGeneration;
     const previousState = state;
@@ -27276,7 +27455,7 @@ function mcpAdapter(pi) {
     renderConfig = undefined;
     stateOwner = null;
     initPromise = null;
-    registeredDirectToolNames = new Set;
+    forgetDirectToolRegistrations();
     cancelStartupWarmup();
     const previousStateCleanup = cleanupSessionResources(previousState, "session_restart", "MCP: failed to shut down previous session state");
     const cleanup = cleanupBarrier.retain([retiredInitialization, previousStateCleanup]);
@@ -27284,8 +27463,9 @@ function mcpAdapter(pi) {
     await cleanup;
     if (!isStartCurrent())
       return;
+    const revision = contributionRevision;
     try {
-      const config = loadMcpConfig(earlyConfigPath, ctx.cwd);
+      const config = loadMcpConfig(earlyConfigPath, ctx.cwd, getContributions());
       await Promise.resolve().then(() => init_metadata_cache());
       if (!isStartCurrent())
         return;
@@ -27293,9 +27473,7 @@ function mcpAdapter(pi) {
       const directToolState = await registerDirectToolsFromConfig(config, loadMetadataCache());
       if (!isStartCurrent())
         return;
-      if (config.settings?.disableProxyTool !== true || directToolState.directToolCount === 0 || directToolState.missingConfiguredDirectToolServers.length > 0) {
-        registerProxyTool();
-      }
+      registerProxyToolIfNeeded(config, directToolState);
     } catch (error) {
       if (!isStartCurrent() || isStaleExtensionContextError(error))
         return;
@@ -27305,12 +27483,20 @@ function mcpAdapter(pi) {
     }
     if (!isStartCurrent())
       return;
-    activeSession = { generation, ctx, cleanup };
-    if (ctx.hasUI || Object.values(renderConfig?.mcpServers ?? {}).some((server) => server.lifecycle === "eager" || server.lifecycle === "keep-alive")) {
+    const session = { generation, ctx, cleanup };
+    activeSession = session;
+    if (ctx.hasUI || Object.values(renderConfig?.mcpServers ?? {}).some(startsWithSession)) {
       ensureMcpInitialized().catch(() => {
         return;
       });
     }
+    if (revision !== contributionRevision)
+      scheduleContributionRefresh(session);
+  });
+  pi.onMcpServerContributionsChanged?.(() => {
+    contributionRevision++;
+    if (activeSession)
+      scheduleContributionRefresh(activeSession);
   });
   pi.on("session_shutdown", async () => {
     ++lifecycleGeneration;
@@ -27321,7 +27507,7 @@ function mcpAdapter(pi) {
     renderConfig = undefined;
     stateOwner = null;
     initPromise = null;
-    registeredDirectToolNames = new Set;
+    forgetDirectToolRegistrations();
     cancelStartupWarmup();
     const stateCleanup = cleanupSessionResources(currentState, "session_shutdown", "MCP: session shutdown cleanup failed");
     const failures = [];

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.23-alpha.1",
+  "version": "0.9.24-alpha.1",
   "private": true,
   "description": "Atomic extension that adapts MCP (Model Context Protocol) servers into the coding agent. Fork of: https://github.com/nicobailon/pi-mcp-adapter",
   "contributors": [

package/dist/builtin/subagents/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.9.23] - 2026-09-27
+
+### Fixed
+
+- `model: "auto"` routing no longer ignores benchmark results when fewer than four models are available. Each model's results are now ranked against every model in the evals catalog rather than only the models you can route to, so with just two or three models (for example Opus and Haiku) the stronger model is no longer outranked on price alone, and a model scores the same however many models are enabled.
+
 ## [0.9.23-alpha.1] - 2026-09-27
 
 ### Fixed

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.23-alpha.1",
+  "version": "0.9.24-alpha.1",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with parallel execution. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [