pi-codemcp 1.2.0 → 1.2.2

package/README.md

@@ -148,7 +148,7 @@ The Python sidecar enforces catalog cache TTL, execution timeout, per-tool timeo
 
 ## Search and execute flow
 
-The agent searches for a capability, inspects the selected exact stub when needed, and executes a compact plan:
+The agent searches for a capability, inspects the selected exact stub when needed, and executes a compact plan. Unscoped searches discover stale or missing server catalogs independently: available servers still return results, while `discovery_failures` explicitly reports unavailable servers. Server-scoped searches remain fail-fast.
 
 ```python
 issues = await linear.list_issues({"assignee": "me", "limit": 50})
@@ -211,7 +211,7 @@ Rendered Pi output is separately truncated by `outputLimitKiB`; the full oversiz
 
 FastMCP owns MCP transports, runtime validation, and OAuth. [Pydantic Monty](https://github.com/pydantic/monty) type-checks and executes agent-written Python without host filesystem, environment, network, or subprocess access. Code Mode can only call the typed MCP tool and saved-chain facades exposed in the generated stubs.
 
-`/codemcp` configures servers, saved chains, per-tool policy, timeouts, call limits, output limits, cache TTL, and warmup, and shows bounded lifetime/recent telemetry in its Stats tab. Server, chain, tool-policy, and setting toggles stay local and instantaneous until one `Ctrl+S` batch save/reload. Discovery, revalidation, and deletion remain explicit immediate actions. The sandbox also has a fixed memory ceiling; executions are serialized per Pi session. There are no automatic retries or cross-service rollback.
+`/codemcp` configures servers, saved chains, per-tool policy, timeouts, call limits, output limits, cache TTL, and warmup, and shows bounded lifetime/recent telemetry in its Stats tab. Server, chain, tool-policy, and setting changes are persisted immediately. Discovery, revalidation, and deletion remain explicit immediate actions. The sandbox also has a fixed memory ceiling; executions are serialized per Pi session. There are no automatic retries or cross-service rollback.
 
 Enabled tools retain their upstream permissions. Saved chains never bypass server or per-tool policy and are checked against the current enabled catalog whenever they run. Preflight safety does not make upstream tools transactional: if a later call fails after earlier calls succeeded, pi-codemcp does not roll those upstream side effects back.
 

package/extensions/index.ts

@@ -5,21 +5,23 @@ import {
   type ExtensionCommandContext,
 } from "@earendil-works/pi-coding-agent";
 import { SavedChainManager } from "../src/chains.js";
-import { setMcpServersEnabled } from "../src/config.js";
+import { setMcpServerEnabled } from "../src/config.js";
 import { summarizeError } from "../src/errors.js";
 import { CodeMcpLifecycle } from "../src/lifecycle.js";
 import type { SidecarClientOptions } from "../src/mcp-client.js";
 import {
-  type ChainModalState,
   chainStatesFromViews,
-  type ChainEnabledChange as ModalChainEnabledChange,
-  type ServerEnabledChange,
   type ServerModalState,
   serverStatesFromStatus,
   showServerManagerModal,
   statsStateFromSnapshot,
 } from "../src/modal.js";
-import { type CodeMcpSettings, saveCodeMcpSettings } from "../src/settings.js";
+import {
+  type CodeMcpSettings,
+  saveCodeMcpSettings,
+  setEditableSetting,
+  setToolEnabled,
+} from "../src/settings.js";
 import { registerCodeMcpTools } from "../src/tools.js";
 
 export function createCodeMcpExtension(options: SidecarClientOptions = {}) {
@@ -50,22 +52,31 @@ export function createCodeMcpExtension(options: SidecarClientOptions = {}) {
             chains: chainStatesFromViews(savedChains),
             settings,
             stats: statsStateFromSnapshot(stats),
-            onDiscover: async (server) =>
-              requireServerStatus(
-                await lifecycle.request("discover", { server: server.name }),
+            onSetServerEnabled: (server, enabled) =>
+              setServerEnabledFromManager(lifecycle, server, enabled),
+            onDiscover: (server) => discoverServerFromManager(lifecycle, server),
+            onSetToolEnabled: async (server, tool, enabled) => {
+              const updated = setToolEnabled(
+                lifecycle.loadSettings(),
+                server.name,
+                tool.name,
+                enabled,
+              );
+              saveCodeMcpSettings(lifecycle.settingsPath, updated);
+              return requireServerStatus(
+                await lifecycle.request("reload_settings", {}),
                 server.name,
-              ),
-            onSaveChanges: (updated, serverChanges, chainChanges) =>
-              saveManagerChanges(lifecycle, chains, updated, serverChanges, chainChanges),
-            onResolveUnsaved: async () => {
-              const choice = await ctx.ui.select("Unsaved CodeMCP changes", [
-                "Save",
-                "Discard",
-                "Cancel",
-              ]);
-              if (choice === "Save") return "save";
-              if (choice === "Discard") return "discard";
-              return "cancel";
+              );
+            },
+            onSetSetting: async (key, value) => {
+              const updated = setEditableSetting(lifecycle.loadSettings(), key, value);
+              saveCodeMcpSettings(lifecycle.settingsPath, updated);
+              await lifecycle.request("reload_settings", {});
+              return updated;
+            },
+            onSetChainEnabled: async (chain, enabled) => {
+              await chains.setEnabled(chain.name, chain.scope, enabled);
+              return chainStatesFromViews(await chains.list());
             },
             onRevalidateChain: async (chain) => {
               await chains.revalidate(chain.name, chain.scope);
@@ -104,61 +115,36 @@ export function createCodeMcpExtension(options: SidecarClientOptions = {}) {
   };
 }
 
-export async function saveManagerChanges(
-  lifecycle: Pick<CodeMcpLifecycle, "configPath" | "settingsPath" | "loadSettings" | "reload">,
-  chains: Pick<SavedChainManager, "applyEnabled">,
-  updated: CodeMcpSettings,
-  serverChanges: readonly ServerEnabledChange[],
-  chainChanges: readonly ModalChainEnabledChange[],
-): Promise<{
-  settings: CodeMcpSettings;
-  servers: ServerModalState[];
-  chains: ChainModalState[];
-}> {
-  const previousSettings = lifecycle.loadSettings();
-  let serverConfigChanged = false;
+export async function discoverServerFromManager(
+  lifecycle: Pick<CodeMcpLifecycle, "configPath" | "reload" | "request">,
+  server: ServerModalState,
+): Promise<ServerModalState> {
+  if (!server.enabled) return setServerEnabledFromManager(lifecycle, server, true);
+  return requireServerStatus(
+    await lifecycle.request("discover", { server: server.name }),
+    server.name,
+  );
+}
+
+export async function setServerEnabledFromManager(
+  lifecycle: Pick<CodeMcpLifecycle, "configPath" | "reload" | "request">,
+  previous: ServerModalState,
+  enabled: boolean,
+): Promise<ServerModalState> {
+  setMcpServerEnabled(lifecycle.configPath, previous.name, enabled);
+  await lifecycle.reload();
   try {
-    saveCodeMcpSettings(lifecycle.settingsPath, updated);
-    if (serverChanges.length > 0) {
-      setMcpServersEnabled(
-        lifecycle.configPath,
-        serverChanges.map((change) => ({ name: change.name, enabled: change.enabled })),
-      );
-      serverConfigChanged = true;
-      await lifecycle.reload();
-    }
-    const applied = await chains.applyEnabled(
-      chainChanges.map((change) => ({
-        name: change.name,
-        scope: change.scope,
-        enabled: change.enabled,
-      })),
-    );
-    return {
-      settings: lifecycle.loadSettings(),
-      servers: serverStatesFromStatus(applied.status),
-      chains: chainStatesFromViews(applied.chains),
-    };
+    const status = enabled
+      ? await lifecycle.request("discover", { server: previous.name })
+      : await lifecycle.request("status", {});
+    return requireServerStatus(status, previous.name);
   } catch (error) {
-    saveCodeMcpSettings(lifecycle.settingsPath, previousSettings);
-    if (serverConfigChanged) {
-      setMcpServersEnabled(
-        lifecycle.configPath,
-        serverChanges.map((change) => ({
-          name: change.name,
-          enabled: change.previousEnabled,
-        })),
-      );
-    }
     try {
-      await lifecycle.reload();
-    } catch (rollbackError) {
-      throw new AggregateError(
-        [error, rollbackError],
-        "CodeMCP save failed and runtime rollback also failed",
-      );
+      const current = requireServerStatus(await lifecycle.request("status", {}), previous.name);
+      return { ...current, error: summarizeError(error) };
+    } catch {
+      throw error;
     }
-    throw error;
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-codemcp",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Typed, sandboxed Code Mode access to configured MCP servers for Pi",
   "type": "module",
   "packageManager": "bun@1.3.10",

package/sidecar/chains.py

@@ -5,18 +5,15 @@ import json
 import os
 import re
 import time
-from contextlib import contextmanager, suppress
+from contextlib import suppress
 from pathlib import Path
-from typing import TYPE_CHECKING, Literal, NamedTuple
+from typing import Literal, NamedTuple
 from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from .json_types import JSON_OBJECT_ADAPTER, JsonObject
 
-if TYPE_CHECKING:
-    from collections.abc import Iterator
-
 CHAIN_NAME_PATTERN = r"^[a-z][a-z0-9_]{0,63}$"
 CHAIN_STORE_VERSION: Literal[1] = 1
 type ChainScope = Literal["global", "project"]
@@ -76,14 +73,6 @@ class SavedChainManifest(BaseModel):
         return f"mcp_chain_{self.name}"
 
 
-class ChainEnabledChange(BaseModel):
-    model_config = ConfigDict(extra="forbid", strict=True)
-
-    name: str = Field(pattern=CHAIN_NAME_PATTERN)
-    scope: ChainScope
-    enabled: bool
-
-
 class ChainStatusView(BaseModel):
     model_config = ConfigDict(extra="forbid", strict=True)
 
@@ -187,6 +176,12 @@ class ChainStore:
         temporary.chmod(0o600)
         temporary.replace(path)
 
+    def set_enabled(self, name: str, enabled: bool) -> SavedChainManifest:
+        current = self.get(name)
+        updated = current.model_copy(update={"enabled": enabled, "updated_at": time.time()})
+        self.save(updated)
+        return updated
+
     def delete(self, name: str) -> None:
         self._validate_name(name)
         try:
@@ -256,38 +251,16 @@ class ScopedChainStore:
     def save(self, scope: ChainScope, chain: SavedChainManifest) -> None:
         self._store(scope).save(chain)
 
-    @contextmanager
-    def enabled_transaction(self, changes: list[ChainEnabledChange]) -> Iterator[None]:
-        keys = [(change.scope, change.name) for change in changes]
-        if len(keys) != len(set(keys)):
-            raise ValueError("Duplicate scoped saved-chain enable change")
-        previous = [self.get(change.name, change.scope) for change in changes]
-        applied: list[ScopedChain] = []
-        try:
-            self._apply_enabled_changes(changes, previous, applied)
-            yield
-        except BaseException:
-            self._restore(applied)
-            raise
-
-    def _apply_enabled_changes(
+    def set_enabled(
         self,
-        changes: list[ChainEnabledChange],
-        previous: list[ScopedChain],
-        applied: list[ScopedChain],
-    ) -> None:
-        for change, current in zip(changes, previous, strict=True):
-            if current.chain.enabled == change.enabled:
-                continue
-            updated = current.chain.model_copy(
-                update={"enabled": change.enabled, "updated_at": time.time()}
-            )
-            self.save(change.scope, updated)
-            applied.append(current)
-
-    def _restore(self, chains: list[ScopedChain]) -> None:
-        for item in reversed(chains):
-            self.save(item.scope, item.chain)
+        scope: ChainScope,
+        name: str,
+        enabled: bool,
+    ) -> ScopedChain:
+        return ScopedChain(
+            scope=scope,
+            chain=self._store(scope).set_enabled(name, enabled),
+        )
 
     def delete(self, scope: ChainScope, name: str) -> None:
         self._store(scope).delete(name)

package/sidecar/gateway.py

@@ -10,7 +10,6 @@ from typing import TYPE_CHECKING, Literal, NamedTuple, Protocol, cast
 import pydantic_monty
 from fastmcp import Client, FastMCP
 from fastmcp.mcp_config import RemoteMCPServer, StdioMCPServer
-from pydantic import BaseModel, ConfigDict
 from pydantic_core import to_json
 from rapidfuzz import fuzz, process
 
@@ -18,7 +17,6 @@ from . import json_types
 from .catalog_cache import CatalogCache
 from .chains import (
     ChainDependency,
-    ChainEnabledChange,
     ChainListResponse,
     ChainScope,
     ChainStatusView,
@@ -36,6 +34,7 @@ from .models import (
     SearchDetail,
     SearchMode,
     SearchResponse,
+    ServerDiscoveryFailure,
     ServerToolSummary,
     StatusResponse,
     UpstreamStatus,
@@ -61,13 +60,6 @@ type JsonObject = json_types.JsonObject
 type JsonValue = json_types.JsonValue
 
 
-class ManagerApplyResponse(BaseModel):
-    model_config = ConfigDict(extra="forbid", strict=True)
-
-    status: StatusResponse
-    chains: list[ChainStatusView]
-
-
 class ServerHandle:
     def __init__(
         self,
@@ -186,6 +178,7 @@ class SavedChainHandlers(NamedTuple):
     execute: Callable[[str, JsonObject], Awaitable[ExecutionResponse]]
     save: SaveChainHandler
     list: Callable[[], ChainListResponse]
+    set_enabled: Callable[[str, ChainScope, bool], Awaitable[ChainStatusView]]
     revalidate: Callable[[str, ChainScope], Awaitable[ChainStatusView]]
     delete: Callable[[str, ChainScope], Awaitable[ChainListResponse]]
 
@@ -219,6 +212,14 @@ class SavedChainRuntime:
     def list(self) -> ChainListResponse:
         return self.handlers.list()
 
+    async def set_enabled(
+        self,
+        name: str,
+        scope: ChainScope,
+        enabled: bool,
+    ) -> ChainStatusView:
+        return await self.handlers.set_enabled(name, scope, enabled)
+
     async def revalidate(self, name: str, scope: ChainScope) -> ChainStatusView:
         return await self.handlers.revalidate(name, scope)
 
@@ -255,6 +256,7 @@ class GatewayRuntime:
                 execute=self._execute_chain,
                 save=self._save_chain,
                 list=self._list_chains,
+                set_enabled=self._set_chain_enabled,
                 revalidate=self._revalidate_chain,
                 delete=self._delete_chain,
             )
@@ -377,7 +379,11 @@ class GatewayRuntime:
             discovery_servers = ()
         else:
             discovery_servers = (server,)
-        await self._ensure_servers_discovered(discovery_servers)
+        if server is None:
+            discovery_failures = await self._discover_servers_for_unscoped_search(discovery_servers)
+        else:
+            await self._ensure_servers_discovered(discovery_servers)
+            discovery_failures = []
         self.stats_store.record_phase("discovery", _elapsed_ms(discovery_started))
         bounded_limit = min(max(limit, 1), 20)
         bounded_cursor = max(cursor, 0)
@@ -439,6 +445,7 @@ class GatewayRuntime:
             has_more=next_cursor is not None,
             project_scope_available=self.chain_store.project_store is not None,
             execution_limits=self._execution_limits_view(),
+            discovery_failures=discovery_failures,
             prelude=self.catalog.stub_prelude if include_prelude else None,
             results=results,
         )
@@ -772,6 +779,33 @@ class GatewayRuntime:
         )
         return response
 
+    async def _set_chain_enabled(
+        self,
+        name: str,
+        scope: ChainScope,
+        enabled: bool,
+    ) -> ChainStatusView:
+        started = time.perf_counter()
+        try:
+            self.chain_store.set_enabled(scope, name, enabled)
+            await self._rebuild_catalog()
+            response = self._chain_view(name, scope)
+        except BaseException:
+            self.stats_store.record_operation(
+                "set_chain_enabled",
+                duration_ms=_elapsed_ms(started),
+                success=False,
+                failure_stage="error",
+            )
+            raise
+        self.stats_store.record_operation(
+            "set_chain_enabled",
+            duration_ms=_elapsed_ms(started),
+            success=True,
+            output_bytes=len(to_json(response.model_dump(mode="json"))),
+        )
+        return response
+
     async def _revalidate_chain(self, name: str, scope: ChainScope) -> ChainStatusView:
         started = time.perf_counter()
         try:
@@ -918,27 +952,6 @@ class GatewayRuntime:
         await self._rebuild_catalog()
         return self.status()
 
-    async def apply_manager_changes(
-        self,
-        changes: list[ChainEnabledChange],
-    ) -> ManagerApplyResponse:
-        previous_settings = self.settings
-        try:
-            with self.chain_store.enabled_transaction(changes):
-                self._load_settings()
-                await self._rebuild_catalog()
-        except BaseException:
-            self.settings = previous_settings
-            for handle in self.handles.values():
-                handle.cache.max_age_seconds = previous_settings.cache_ttl_seconds
-            self.executor.settings = previous_settings.execution_settings()
-            await self._rebuild_catalog()
-            raise
-        return ManagerApplyResponse(
-            status=self.status(),
-            chains=self._chain_views(),
-        )
-
     def _load_settings(self) -> None:
         self.settings = load_settings(self.settings_path)
         for handle in self.handles.values():
@@ -981,6 +994,36 @@ class GatewayRuntime:
     async def _ensure_catalog_complete(self) -> None:
         await self._ensure_servers_discovered(self.handles.keys())
 
+    async def _discover_servers_for_unscoped_search(
+        self,
+        server_names: Iterable[str],
+    ) -> list[ServerDiscoveryFailure]:
+        requested = set(server_names)
+        missing = [
+            (name, handle)
+            for name, handle in self.handles.items()
+            if name in requested and handle.tools is None
+        ]
+        if not missing:
+            return []
+        results = await asyncio.gather(
+            *(handle.discover() for _, handle in missing),
+            return_exceptions=True,
+        )
+        failures: list[ServerDiscoveryFailure] = []
+        for (name, _handle), result in zip(missing, results, strict=True):
+            if isinstance(result, Exception):
+                failures.append(
+                    ServerDiscoveryFailure(
+                        server=name,
+                        error=_discovery_error_message(result),
+                    )
+                )
+            elif isinstance(result, BaseException):
+                raise result
+        await self._rebuild_catalog()
+        return failures
+
     async def _ensure_servers_discovered(self, server_names: Iterable[str]) -> None:
         requested = set(server_names)
         missing = [
@@ -1170,6 +1213,10 @@ def _elapsed_ms(started: float) -> float:
     return (time.perf_counter() - started) * 1_000
 
 
+def _discovery_error_message(error: Exception) -> str:
+    return str(error).strip() or type(error).__name__
+
+
 def _parse_code(code: str) -> ast.AST | None:
     normalized = textwrap.dedent(code).strip("\n")
     wrapped = f"async def __codemcp_main():\n{textwrap.indent(normalized, '    ')}\n"
@@ -1276,11 +1323,13 @@ async def reload_settings() -> StatusResponse:
 
 
 @mcp.tool
-async def apply_manager_changes(
-    changes: list[ChainEnabledChange],
-) -> ManagerApplyResponse:
-    """Apply staged settings and saved-chain enable changes with one catalog rebuild."""
-    return await _require_runtime().apply_manager_changes(changes)
+async def set_chain_enabled(
+    name: str,
+    scope: ChainScope,
+    enabled: bool,
+) -> ChainStatusView:
+    """Enable or disable one saved chain in its storage scope."""
+    return await _require_runtime().chains.set_enabled(name, scope, enabled)
 
 
 @mcp.tool

package/sidecar/mcp_config.py

@@ -4,7 +4,8 @@ import hashlib
 import json
 import os
 import re
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, override
+from urllib.parse import urlsplit
 
 from fastmcp.client.auth import OAuth
 from fastmcp.mcp_config import (
@@ -58,6 +59,30 @@ class NormalizedConfig(BaseModel):
     servers: list[NormalizedServerInfo]
 
 
+class PersistentCallbackOAuth(OAuth):
+    """Reuse the callback registered with a persisted dynamic OAuth client."""
+
+    @override
+    async def _initialize(self) -> None:
+        await super()._initialize()
+        client_info = self.context.client_info
+        if client_info is None or not client_info.redirect_uris:
+            return
+        redirect_uri = client_info.redirect_uris[0]
+        parsed = urlsplit(str(redirect_uri))
+        if (
+            parsed.scheme != "http"
+            or parsed.hostname not in {"localhost", "127.0.0.1", "::1"}
+            or parsed.port is None
+        ):
+            return
+        if parsed.path != "/callback" or parsed.query or parsed.fragment:
+            return
+        self.redirect_port = parsed.port
+        self._callback_host = parsed.hostname
+        self.context.client_metadata.redirect_uris = [redirect_uri]
+
+
 def load_mcp_json(path: Path) -> JsonObject:
     if not path.exists():
         raise FileNotFoundError(f"MCP config not found: {path}")
@@ -231,7 +256,7 @@ def normalize_mcp_config(
             auth: str | httpx.Auth | None
             auth_kind: ServerAuth | None = None
             if raw_auth == "oauth":
-                auth = OAuth(
+                auth = PersistentCallbackOAuth(
                     mcp_url=url,
                     client_name=oauth_client_name,
                     token_storage=oauth_storage,

package/sidecar/models.py

@@ -63,6 +63,13 @@ class ServerToolSummary(BaseModel):
     tool_count: int
 
 
+class ServerDiscoveryFailure(BaseModel):
+    model_config = ConfigDict(extra="forbid", strict=True)
+
+    server: str
+    error: str
+
+
 class ExecutionLimitsView(BaseModel):
     model_config = ConfigDict(extra="forbid", strict=True)
 
@@ -85,6 +92,7 @@ class SearchResponse(BaseModel):
     has_more: bool = False
     project_scope_available: bool
     execution_limits: ExecutionLimitsView
+    discovery_failures: list[ServerDiscoveryFailure] = Field(default_factory=list)
     prelude: str | None = None
     results: list[ToolSchemaView]
 

package/src/chains.ts

@@ -46,17 +46,6 @@ export interface SavedChainView {
   calledBy: string[];
 }
 
-export interface ChainEnabledChange {
-  name: string;
-  scope: ChainScope;
-  enabled: boolean;
-}
-
-export interface ManagerApplyResult {
-  chains: SavedChainView[];
-  status: Record<string, unknown>;
-}
-
 export interface SaveChainInput {
   scope: ChainScope;
   name: string;
@@ -134,21 +123,21 @@ export class SavedChainManager {
     return views;
   }
 
-  async applyEnabled(
-    changes: readonly ChainEnabledChange[],
+  async setEnabled(
+    name: string,
+    scope: ChainScope,
+    enabled: boolean,
     signal?: AbortSignal,
-  ): Promise<ManagerApplyResult> {
+  ): Promise<SavedChainView> {
     const result = await this.lifecycle.request(
-      "apply_manager_changes",
-      {
-        changes: changes.map((change) => ({ ...change })),
-      },
+      "set_chain_enabled",
+      { name, scope, enabled },
       signal,
     );
-    const views = parseViewList(result.chains, "apply_manager_changes.chains");
-    const status = requireRecord(result.status, "apply_manager_changes.status");
-    this.synchronizeViews(views);
-    return { chains: views, status };
+    const view = parseSavedChainView(result, "set_chain_enabled");
+    this.upsertView(view);
+    this.refreshNativeTools();
+    return view;
   }
 
   async revalidate(name: string, scope: ChainScope, signal?: AbortSignal): Promise<SavedChainView> {

package/src/config.ts

@@ -5,54 +5,23 @@ import {
   writeJsonObjectAtomically,
 } from "./json-file.js";
 
-export interface McpServerEnabledChange {
-  name: string;
-  enabled: boolean;
-}
-
 export function setMcpServerEnabled(configPath: string, name: string, enabled: boolean): void {
-  setMcpServersEnabled(configPath, [{ name, enabled }]);
-}
-
-export function setMcpServersEnabled(
-  configPath: string,
-  changes: readonly McpServerEnabledChange[],
-): void {
-  if (changes.length === 0) return;
-  const duplicate = duplicateName(changes.map((change) => change.name));
-  if (duplicate) throw new Error(`Duplicate MCP server change: ${JSON.stringify(duplicate)}`);
-
   const root = readJsonObject(configPath, "mcp.json root");
   const hasServerBlock = Object.hasOwn(root, "mcpServers");
   const servers = hasServerBlock ? requireJsonObject(root.mcpServers, "mcp.json mcpServers") : root;
-  const updatedServers: JsonRecord = { ...servers };
+  const server = requireJsonObject(servers[name], `MCP server ${JSON.stringify(name)}`);
+  const updatedServer: JsonRecord = { ...server };
 
-  for (const change of changes) {
-    const server = requireJsonObject(
-      servers[change.name],
-      `MCP server ${JSON.stringify(change.name)}`,
-    );
-    const updatedServer: JsonRecord = { ...server };
-    if (typeof server.enabled === "boolean") {
-      updatedServer.enabled = change.enabled;
-      delete updatedServer.disabled;
-    } else {
-      updatedServer.disabled = !change.enabled;
-    }
-    updatedServers[change.name] = updatedServer;
+  if (typeof server.enabled === "boolean") {
+    updatedServer.enabled = enabled;
+    delete updatedServer.disabled;
+  } else {
+    updatedServer.disabled = !enabled;
   }
 
+  const updatedServers: JsonRecord = { ...servers, [name]: updatedServer };
   const updatedRoot: JsonRecord = hasServerBlock
     ? { ...root, mcpServers: updatedServers }
     : updatedServers;
   writeJsonObjectAtomically(configPath, updatedRoot);
 }
-
-function duplicateName(names: readonly string[]): string | undefined {
-  const seen = new Set<string>();
-  for (const name of names) {
-    if (seen.has(name)) return name;
-    seen.add(name);
-  }
-  return undefined;
-}

package/src/mcp-client.ts

@@ -22,11 +22,11 @@ export type SidecarToolName =
   | "inspect"
   | "discover"
   | "reload_settings"
-  | "apply_manager_changes"
   | "execute"
   | "save_chain"
   | "list_chains"
   | "execute_chain"
+  | "set_chain_enabled"
   | "revalidate_chain"
   | "delete_chain"
   | "stats"

package/src/modal.ts

@@ -13,13 +13,7 @@ import {
 } from "@earendil-works/pi-tui";
 import type { ChainScope, SavedChainView } from "./chains.js";
 import { summarizeError } from "./errors.js";
-import {
-  type CodeMcpSettings,
-  type EditableSettingKey,
-  type EditableSettingValue,
-  setEditableSetting,
-  setToolEnabled,
-} from "./settings.js";
+import type { CodeMcpSettings, EditableSettingKey, EditableSettingValue } from "./settings.js";
 
 export interface ToolModalState {
   name: string;
@@ -104,26 +98,6 @@ interface Keybindings {
   matches(data: string, id: "tui.select.up" | "tui.select.down" | "tui.select.cancel"): boolean;
 }
 
-export interface ServerEnabledChange {
-  name: string;
-  previousEnabled: boolean;
-  enabled: boolean;
-}
-
-export interface ChainEnabledChange {
-  name: string;
-  scope: ChainScope;
-  previousEnabled: boolean;
-  enabled: boolean;
-}
-
-interface ManagerSaveResult {
-  settings: CodeMcpSettings;
-  servers: ServerModalState[];
-  chains: ChainModalState[];
-}
-
-type UnsavedAction = "save" | "discard" | "cancel";
 export type ServerManagerResult = "report-problem" | undefined;
 
 interface ServerManagerOptions {
@@ -131,13 +105,15 @@ interface ServerManagerOptions {
   chains: ChainModalState[];
   settings: CodeMcpSettings;
   stats: StatsModalState;
+  onSetServerEnabled(server: ServerModalState, enabled: boolean): Promise<ServerModalState>;
   onDiscover(server: ServerModalState): Promise<ServerModalState>;
-  onSaveChanges(
-    settings: CodeMcpSettings,
-    serverChanges: ServerEnabledChange[],
-    chainChanges: ChainEnabledChange[],
-  ): Promise<ManagerSaveResult>;
-  onResolveUnsaved(): Promise<UnsavedAction>;
+  onSetToolEnabled(
+    server: ServerModalState,
+    tool: ToolModalState,
+    enabled: boolean,
+  ): Promise<ServerModalState>;
+  onSetSetting(key: EditableSettingKey, value: EditableSettingValue): Promise<CodeMcpSettings>;
+  onSetChainEnabled(chain: ChainModalState, enabled: boolean): Promise<ChainModalState[]>;
   onRevalidateChain(chain: ChainModalState): Promise<ChainModalState[]>;
   onDeleteChain(chain: ChainModalState): Promise<ChainModalState[]>;
 }
@@ -345,12 +321,6 @@ class ServerManagerModal implements Component, Focusable {
   private selectedToolIndex = 0;
   private selectedChainIndex = 0;
   private selectedSettingIndex = 0;
-  private savedSettings: CodeMcpSettings;
-  private draftSettings: CodeMcpSettings;
-  private savedServerEnabled: Map<string, boolean>;
-  private savedChainEnabled: Map<string, boolean>;
-  private settingsBusy = false;
-  private closePromptBusy = false;
   private settingsError: string | undefined;
   private _focused = false;
 
@@ -360,13 +330,7 @@ class ServerManagerModal implements Component, Focusable {
     private readonly keybindings: Keybindings,
     private readonly close: (result?: ServerManagerResult) => void,
     private readonly requestRender: () => void,
-  ) {
-    this.savedSettings = cloneSettings(options.settings);
-    this.draftSettings = cloneSettings(options.settings);
-    this.savedServerEnabled = serverEnabledMap(options.servers);
-    this.savedChainEnabled = chainEnabledMap(options.chains);
-    this.applyDraftToolPolicy();
-  }
+  ) {}
 
   get focused(): boolean {
     return this._focused;
@@ -401,12 +365,7 @@ class ServerManagerModal implements Component, Focusable {
   }
 
   handleInput(data: string): void {
-    if (matchesKey(data, Key.ctrl("s"))) {
-      this.saveDraft();
-      return;
-    }
-    if (this.settingsBusy || this.closePromptBusy) return;
-    if (data === "R") {
+    if (data === "R" && this.activeTab !== "chains") {
       this.focusProblemReport();
       this.requestRender();
       return;
@@ -418,8 +377,7 @@ class ServerManagerModal implements Component, Focusable {
         this.requestRender();
         return;
       }
-      if (this.hasUnsavedChanges()) this.resolveUnsavedClose();
-      else this.close();
+      this.close();
       return;
     }
     if (matchesKey(data, Key.tab)) {
@@ -443,7 +401,7 @@ class ServerManagerModal implements Component, Focusable {
   }
 
   private handleServerInput(data: string): void {
-    if (data === "d") {
+    if (data === "D") {
       this.discoverSelected();
       return;
     }
@@ -490,7 +448,7 @@ class ServerManagerModal implements Component, Focusable {
       );
       return;
     }
-    if (data === "r") {
+    if (data === "R") {
       this.revalidateSelectedChain();
       return;
     }
@@ -510,7 +468,6 @@ class ServerManagerModal implements Component, Focusable {
   }
 
   private handleSettingsInput(data: string): void {
-    if (this.settingsBusy) return;
     if (this.keybindings.matches(data, "tui.select.up") || matchesKey(data, Key.up)) {
       this.selectedSettingIndex = cycleIndex(
         this.selectedSettingIndex,
@@ -613,7 +570,7 @@ class ServerManagerModal implements Component, Focusable {
       this.theme.fg("dim", `${server.transport}${server.auth ? ` · ${server.auth}` : ""}`),
       server.busy
         ? this.theme.fg("warning", "Working…")
-        : `${this.theme.fg("accent", "[d]")} Discover tools  ${this.theme.fg("accent", "[space]")} ${server.enabled ? "Disable server" : "Enable server"}`,
+        : `${this.theme.fg("accent", "[D]")} Discover tools  ${this.theme.fg("accent", "[space]")} ${server.enabled ? "Disable server" : "Enable server"}`,
       ...(server.error ? [this.theme.fg("warning", `Error: ${server.error}`)] : []),
       this.theme.fg("dim", "─".repeat(Math.max(1, width))),
       this.theme.fg("dim", this.theme.bold("TOOLS")),
@@ -729,7 +686,7 @@ class ServerManagerModal implements Component, Focusable {
       this.theme.fg("muted", `${chain.scope} · ${chain.status} · ${chain.nativeTool}`),
       chain.busy
         ? this.theme.fg("warning", "Working…")
-        : `${this.theme.fg("accent", "[space]")} ${chain.enabled ? "Disable" : "Enable"}  ${this.theme.fg("accent", "[r]")} Revalidate  ${this.theme.fg("accent", "[del]")} Delete`,
+        : `${this.theme.fg("accent", "[space]")} ${chain.enabled ? "Disable" : "Enable"}  ${this.theme.fg("accent", "[R]")} Revalidate  ${this.theme.fg("accent", "[del]")} Delete`,
       ...(chain.error ? [this.theme.fg("warning", `Error: ${chain.error}`)] : []),
       "",
       ...wrapPlainText(chain.description, width).map((line) => this.theme.fg("muted", line)),
@@ -824,7 +781,7 @@ class ServerManagerModal implements Component, Focusable {
     for (const [index, definition] of SETTING_DEFINITIONS.entries()) {
       const selected = index === this.selectedSettingIndex;
       const prefix = selected ? this.theme.fg("accent", "→") : " ";
-      const value = settingLabel(definition, this.draftSettings[definition.key]);
+      const value = settingLabel(definition, this.options.settings[definition.key]);
       const reserved = visibleWidth(prefix) + visibleWidth(value) + 3;
       const label = truncateToWidth(definition.label, Math.max(4, leftWidth - reserved), "…");
       const gap = " ".repeat(Math.max(1, leftWidth - reserved - visibleWidth(label) + 1));
@@ -862,18 +819,13 @@ class ServerManagerModal implements Component, Focusable {
       : definition
         ? [
             this.theme.fg("accent", this.theme.bold(definition.label)),
-            this.theme.fg("muted", settingLabel(definition, this.draftSettings[definition.key])),
+            this.theme.fg("muted", settingLabel(definition, this.options.settings[definition.key])),
             "",
             ...wrapPlainText(definition.description, rightWidth).map((line) =>
               this.theme.fg("muted", line),
             ),
             "",
-            this.theme.fg("dim", "←/→ change · enter next · ctrl+s save"),
-            ...(this.settingsBusy
-              ? ["", this.theme.fg("warning", "Saving staged changes…")]
-              : this.hasUnsavedChanges()
-                ? ["", this.theme.fg("warning", "Unsaved changes")]
-                : []),
+            this.theme.fg("dim", "←/→ change · enter next"),
             ...(this.settingsError
               ? ["", this.theme.fg("warning", `Error: ${this.settingsError}`)]
               : []),
@@ -889,18 +841,17 @@ class ServerManagerModal implements Component, Focusable {
   }
 
   private footer(): string {
-    const pending = this.hasUnsavedChanges() ? " · * unsaved · ctrl+s save" : "";
     const report = ` · ${PROBLEM_REPORT_SHORTCUT}`;
     if (this.activeTab === "settings") {
-      return `tab servers · ↑/↓ navigate · ←/→ change · enter select · ctrl+s save · esc close${pending}${report}`;
+      return `tab servers · ↑/↓ navigate · ←/→ change · enter select · esc close${report}`;
     }
     if (this.activeTab === "chains") {
-      return `tab stats · ↑/↓ navigate · space toggle · r revalidate · del delete · esc close${pending}${report}`;
+      return "tab stats · ↑/↓ navigate · space toggle · R revalidate · del delete · esc close";
     }
     if (this.activeTab === "stats") {
-      return `tab settings · bounded local rollups · esc close${pending}${report}`;
+      return `tab settings · bounded local rollups · esc close${report}`;
     }
-    return `tab chains · ←/→ pane · ↑/↓ navigate · space toggle · d discover · esc close${pending}${report}`;
+    return `tab chains · ←/→ pane · ↑/↓ navigate · space toggle · D discover · esc close${report}`;
   }
 
   private moveSelection(direction: -1 | 1): void {
@@ -923,31 +874,31 @@ class ServerManagerModal implements Component, Focusable {
 
   private toggleSelectedServer(): void {
     const server = this.selectedServer();
-    if (!server || server.busy || this.settingsBusy) return;
-    server.enabled = !server.enabled;
+    if (!server || server.busy) return;
+    const enabled = !server.enabled;
+    server.busy = true;
     delete server.error;
+    void this.options
+      .onSetServerEnabled(server, enabled)
+      .then((updated) => applyServerUpdate(server, updated))
+      .catch((error: unknown) => {
+        server.error = summarizeError(error);
+      })
+      .finally(() => {
+        server.busy = false;
+        this.requestRender();
+      });
   }
 
   private discoverSelected(): void {
     const server = this.selectedServer();
-    if (!server || server.busy || this.settingsBusy) return;
-    if (server.enabled !== this.savedServerEnabled.get(server.name)) {
-      server.error = "Save this server change before discovering tools";
-      return;
-    }
-    if (!server.enabled) {
-      server.error = "Enable and save this server before discovering tools";
-      return;
-    }
+    if (!server || server.busy) return;
     server.busy = true;
     delete server.error;
     this.requestRender();
     void this.options
       .onDiscover(server)
-      .then((updated) => {
-        applyServerUpdate(server, updated);
-        this.applyDraftToolPolicy();
-      })
+      .then((updated) => applyServerUpdate(server, updated))
       .catch((error: unknown) => {
         server.error = summarizeError(error);
       })
@@ -959,31 +910,43 @@ class ServerManagerModal implements Component, Focusable {
 
   private toggleSelectedTool(): void {
     const server = this.selectedServer();
-    if (!server || server.busy || this.settingsBusy) return;
+    if (!server || server.busy) return;
     const tools = this.filteredTools(server);
     const tool = tools[this.selectedToolIndex];
     if (!tool || tool.busy) return;
-    const enabled = !tool.enabled;
-    this.draftSettings = setToolEnabled(this.draftSettings, server.name, tool.name, enabled);
-    tool.enabled = enabled;
-    server.toolCount = server.tools.filter((candidate) => candidate.enabled).length;
-    this.settingsError = undefined;
+    tool.busy = true;
+    void this.options
+      .onSetToolEnabled(server, tool, !tool.enabled)
+      .then((updated) => applyServerUpdate(server, updated))
+      .catch((error: unknown) => {
+        server.error = summarizeError(error);
+      })
+      .finally(() => {
+        tool.busy = false;
+        this.requestRender();
+      });
   }
 
   private toggleSelectedChain(): void {
     const chain = this.selectedChain();
-    if (!chain || chain.busy || this.settingsBusy) return;
-    applyChainEnabled(chain, !chain.enabled);
+    if (!chain || chain.busy) return;
+    chain.busy = true;
     delete chain.error;
+    void this.options
+      .onSetChainEnabled(chain, !chain.enabled)
+      .then((updated) => this.replaceChains(updated, chain))
+      .catch((error: unknown) => {
+        chain.error = summarizeError(error);
+      })
+      .finally(() => {
+        chain.busy = false;
+        this.requestRender();
+      });
   }
 
   private revalidateSelectedChain(): void {
     const chain = this.selectedChain();
-    if (!chain || chain.busy || this.settingsBusy) return;
-    if (chain.enabled !== this.savedChainEnabled.get(chainKey(chain))) {
-      chain.error = "Save this chain change before revalidation";
-      return;
-    }
+    if (!chain || chain.busy) return;
     chain.busy = true;
     delete chain.error;
     void this.options
@@ -998,20 +961,8 @@ class ServerManagerModal implements Component, Focusable {
       });
   }
 
-  private replaceChains(
-    updated: ChainModalState[],
-    selected?: ChainModalState,
-    preserveDrafts = true,
-  ): void {
-    const drafts = preserveDrafts ? this.chainEnabledChanges() : [];
+  private replaceChains(updated: ChainModalState[], selected?: ChainModalState): void {
     this.options.chains.splice(0, this.options.chains.length, ...updated);
-    this.savedChainEnabled = chainEnabledMap(updated);
-    for (const draft of drafts) {
-      const chain = this.options.chains.find(
-        (candidate) => candidate.name === draft.name && candidate.scope === draft.scope,
-      );
-      if (chain) applyChainEnabled(chain, draft.enabled);
-    }
     if (selected) {
       const index = this.filteredChains().findIndex(
         (chain) => chain.name === selected.name && chain.scope === selected.scope,
@@ -1043,8 +994,8 @@ class ServerManagerModal implements Component, Focusable {
 
   private cycleSelectedSetting(direction: -1 | 1): void {
     const definition = SETTING_DEFINITIONS[this.selectedSettingIndex];
-    if (!definition || this.settingsBusy) return;
-    const current = this.draftSettings[definition.key];
+    if (!definition) return;
+    const current = this.options.settings[definition.key];
     const currentIndex = Math.max(
       0,
       definition.choices.findIndex((choice) => choice.value === current),
@@ -1053,43 +1004,15 @@ class ServerManagerModal implements Component, Focusable {
       definition.choices[cycleIndex(currentIndex, direction, definition.choices.length)];
     if (!choice) return;
     this.settingsError = undefined;
-    try {
-      this.draftSettings = setEditableSetting(this.draftSettings, definition.key, choice.value);
-    } catch (error) {
-      this.settingsError = summarizeError(error);
-    }
-  }
-
-  private saveDraft(): void {
-    void this.persistDraft();
-  }
-
-  private async persistDraft(): Promise<boolean> {
-    if (this.settingsBusy) return false;
-    if (!this.hasUnsavedChanges()) return true;
-    this.settingsBusy = true;
-    this.settingsError = undefined;
-    this.requestRender();
-    try {
-      const result = await this.options.onSaveChanges(
-        cloneSettings(this.draftSettings),
-        this.serverEnabledChanges(),
-        this.chainEnabledChanges(),
-      );
-      this.savedSettings = cloneSettings(result.settings);
-      this.draftSettings = cloneSettings(result.settings);
-      this.options.servers.splice(0, this.options.servers.length, ...result.servers);
-      this.savedServerEnabled = serverEnabledMap(result.servers);
-      this.replaceChains(result.chains, undefined, false);
-      this.applyDraftToolPolicy();
-      return true;
-    } catch (error) {
-      this.settingsError = summarizeError(error);
-      return false;
-    } finally {
-      this.settingsBusy = false;
-      this.requestRender();
-    }
+    void this.options
+      .onSetSetting(definition.key, choice.value)
+      .then((settings) => {
+        this.options.settings = settings;
+      })
+      .catch((error: unknown) => {
+        this.settingsError = summarizeError(error);
+      })
+      .finally(() => this.requestRender());
   }
 
   private focusProblemReport(): void {
@@ -1100,70 +1023,7 @@ class ServerManagerModal implements Component, Focusable {
   }
 
   private openProblemReport(): void {
-    if (this.hasUnsavedChanges()) this.resolveUnsavedClose("report-problem");
-    else this.close("report-problem");
-  }
-
-  private resolveUnsavedClose(result?: ServerManagerResult): void {
-    if (this.closePromptBusy || this.settingsBusy) return;
-    this.closePromptBusy = true;
-    void this.options
-      .onResolveUnsaved()
-      .then(async (action) => {
-        if (action === "discard") {
-          this.close(result);
-          return;
-        }
-        if (action === "save" && (await this.persistDraft())) this.close(result);
-      })
-      .catch((error: unknown) => {
-        this.settingsError = summarizeError(error);
-      })
-      .finally(() => {
-        this.closePromptBusy = false;
-        this.requestRender();
-      });
-  }
-
-  private hasUnsavedChanges(): boolean {
-    return (
-      !settingsEqual(this.savedSettings, this.draftSettings) ||
-      this.serverEnabledChanges().length > 0 ||
-      this.chainEnabledChanges().length > 0
-    );
-  }
-
-  private serverEnabledChanges(): ServerEnabledChange[] {
-    return this.options.servers.flatMap((server) => {
-      const previousEnabled = this.savedServerEnabled.get(server.name);
-      return previousEnabled === undefined || previousEnabled === server.enabled
-        ? []
-        : [{ name: server.name, previousEnabled, enabled: server.enabled }];
-    });
-  }
-
-  private chainEnabledChanges(): ChainEnabledChange[] {
-    return this.options.chains.flatMap((chain) => {
-      const previousEnabled = this.savedChainEnabled.get(chainKey(chain));
-      return previousEnabled === undefined || previousEnabled === chain.enabled
-        ? []
-        : [
-            {
-              name: chain.name,
-              scope: chain.scope,
-              previousEnabled,
-              enabled: chain.enabled,
-            },
-          ];
-    });
-  }
-
-  private applyDraftToolPolicy(): void {
-    for (const server of this.options.servers) {
-      const disabled = new Set(this.draftSettings.disabledTools[server.name] ?? []);
-      for (const tool of server.tools) tool.enabled = !disabled.has(tool.name);
-      server.toolCount = server.tools.filter((tool) => tool.enabled).length;
-    }
+    this.close("report-problem");
   }
 
   private filteredServers(): ServerModalState[] {
@@ -1389,38 +1249,6 @@ function serverIcon(server: ServerModalState, theme: Theme): string {
   return theme.fg("warning", "◌");
 }
 
-function serverEnabledMap(servers: readonly ServerModalState[]): Map<string, boolean> {
-  return new Map(servers.map((server) => [server.name, server.enabled]));
-}
-
-function chainEnabledMap(chains: readonly ChainModalState[]): Map<string, boolean> {
-  return new Map(chains.map((chain) => [chainKey(chain), chain.enabled]));
-}
-
-function chainKey(chain: Pick<ChainModalState, "name" | "scope">): string {
-  return `${chain.scope}:${chain.name}`;
-}
-
-function applyChainEnabled(chain: ChainModalState, enabled: boolean): void {
-  const shadowed = chain.status === "shadowed";
-  chain.enabled = enabled;
-  if (shadowed) return;
-  chain.status = enabled ? (chain.staleDependencies.length > 0 ? "stale" : "ready") : "disabled";
-}
-
-function cloneSettings(settings: CodeMcpSettings): CodeMcpSettings {
-  return {
-    ...settings,
-    disabledTools: Object.fromEntries(
-      Object.entries(settings.disabledTools).map(([server, tools]) => [server, [...tools]]),
-    ),
-  };
-}
-
-function settingsEqual(left: CodeMcpSettings, right: CodeMcpSettings): boolean {
-  return JSON.stringify(left) === JSON.stringify(right);
-}
-
 function settingLabel(definition: SettingDefinition, value: EditableSettingValue): string {
   return definition.choices.find((choice) => choice.value === value)?.label ?? String(value);
 }

package/src/tools.ts

@@ -30,6 +30,7 @@ interface SearchRenderDetails extends CodeMcpOutputDetails {
   nextCursor?: number;
   detail: string;
   preview: string[];
+  discoveryFailures: string[];
 }
 
 const SearchParameters = Type.Object({
@@ -154,7 +155,7 @@ export function registerCodeMcpTools(
     name: "codemcp_search",
     label: "MCP Search",
     description:
-      "Search configured MCP capabilities or page through compact inventory. Default signature search includes exact stubs for up to three top matches plus compact alternatives; codemcp_inspect loads other selected stubs. Returns ranking evidence, pagination, scope, and execution limits; invalid server names fail with suggestions.",
+      "Search configured MCP capabilities or page through compact inventory. Default signature search includes exact stubs for up to three top matches plus compact alternatives; codemcp_inspect loads other selected stubs. Unscoped searches return available results plus explicit discovery failures; scoped searches remain fail-fast. Returns ranking evidence, pagination, scope, and execution limits; invalid server names fail with suggestions.",
     promptSnippet: "Discover compact MCP capabilities or inventory",
     promptGuidelines: [...SEARCH_PROMPT_GUIDELINES],
     parameters: SearchParameters,
@@ -186,6 +187,11 @@ export function registerCodeMcpTools(
             return [`${String(item.name)} ${String(item.tool_count ?? 0)}`];
           })
         : [];
+      const discoveryFailures = Array.isArray(result.discovery_failures)
+        ? result.discovery_failures.flatMap((item) =>
+            isRecord(item) && typeof item.server === "string" ? [item.server] : [],
+          )
+        : [];
       return {
         content: [{ type: "text", text: output.text }],
         details: {
@@ -197,6 +203,7 @@ export function registerCodeMcpTools(
           nextCursor: typeof result.next_cursor === "number" ? result.next_cursor : undefined,
           detail: typeof result.detail === "string" ? result.detail : "signatures",
           preview,
+          discoveryFailures,
         },
       };
     },
@@ -212,13 +219,18 @@ export function registerCodeMcpTools(
       if (isPartial) return new Text(theme.fg("warning", "Searching catalog..."), 0, 0);
       if (expanded) return renderExpandedJson(result.content);
       const details = result.details as SearchRenderDetails | undefined;
+      const discoveryFailures = details?.discoveryFailures ?? [];
+      const unavailable = discoveryFailures.length;
       let text = theme.fg(
-        "success",
-        `${details?.matchCount ?? 0} matches · ${details?.detail ?? "signatures"} · ${details?.totalToolCount ?? 0} tools · ${details?.serverCount ?? 0} servers`,
+        unavailable > 0 ? "warning" : "success",
+        `${details?.matchCount ?? 0} matches · ${details?.detail ?? "signatures"} · ${details?.totalToolCount ?? 0} tools · ${details?.serverCount ?? 0} servers${unavailable > 0 ? ` · ${unavailable} unavailable` : ""}`,
       );
       for (const name of details?.preview ?? []) {
         text += `\n${theme.fg("dim", `  ${name}`)}`;
       }
+      for (const server of discoveryFailures) {
+        text += `\n${theme.fg("warning", `  unavailable: ${server}`)}`;
+      }
       if (details?.hasMore) {
         text += `\n${theme.fg("muted", `  more at cursor ${details.nextCursor ?? "?"}`)}`;
       }
@@ -464,11 +476,8 @@ export function registerCodeMcpTools(
           details: undefined,
         });
         if (action === "enable" || action === "disable") {
-          const applied = await chains.applyEnabled(
-            [{ name: params.name, scope, enabled: action === "enable" }],
-            signal,
-          );
-          views = applied.chains;
+          await chains.setEnabled(params.name, scope, action === "enable", signal);
+          views = await chains.list(signal);
         } else if (action === "revalidate") {
           await chains.revalidate(params.name, scope, signal);
           views = await chains.list(signal);