@humain/terminal 0.0.13 → 0.0.15

package/dist/humain/mcp-adapter/vendor/index.bundle.mjs

@@ -1106,12 +1106,18 @@ import stripJsonComments2 from "strip-json-comments";
 function getPiGlobalConfigPath(overridePath) {
   return overridePath ? resolve4(overridePath) : getAgentPath("mcp.json");
 }
+function getGenericGlobalConfigPath() {
+  return GENERIC_GLOBAL_CONFIG_PATH;
+}
 function getProjectConfigPath(cwd = process.cwd()) {
   return resolve4(cwd, PROJECT_CONFIG_NAME);
 }
 function getProjectPiConfigPath(cwd = process.cwd()) {
   return resolve4(cwd, getConfigDirName(), PROJECT_PI_CONFIG_NAME);
 }
+function getSharedConfigPath(target, cwd = process.cwd()) {
+  return target === "project" ? getProjectConfigPath(cwd) : getGenericGlobalConfigPath();
+}
 function getConfigSourceSummaries(sourceSpecs) {
   return sourceSpecs.map((source) => {
     const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
@@ -1897,13 +1903,13 @@ function buildStarterProjectConfig() {
     mcpServers: {}
   };
 }
-function previewStarterProjectConfig(cwd = process.cwd()) {
-  const targetPath = getProjectConfigPath(cwd);
+function previewStarterSharedConfig(target, cwd = process.cwd()) {
+  const targetPath = getSharedConfigPath(target, cwd);
   const nextRaw = { mcpServers: buildStarterProjectConfig().mcpServers };
   return buildConfigWritePreview(targetPath, nextRaw);
 }
-function writeStarterProjectConfig(cwd = process.cwd()) {
-  const targetPath = getProjectConfigPath(cwd);
+function writeStarterSharedConfig(target, cwd = process.cwd()) {
+  const targetPath = getSharedConfigPath(target, cwd);
   const raw = { mcpServers: buildStarterProjectConfig().mcpServers };
   writeRawConfigObject(targetPath, raw);
   return targetPath;
@@ -2529,6 +2535,7 @@ var init_mcp_setup_panel = __esm({
         this.actionCursor = 0;
         this.importCursor = 0;
         this.pathCursor = 0;
+        this.sharedConfigTarget = "project";
         this.selectedImports = /* @__PURE__ */ new Set();
         this.busy = false;
         this.notice = null;
@@ -2566,9 +2573,13 @@ var init_mcp_setup_panel = __esm({
         if (this.discovery.imports.length > 0) {
           actions.push({ id: "adopt-imports", label: "Adopt detected compatibility imports", description: `Choose which host-specific MCP configs Pi should import into its own override file. ${this.discovery.imports.length} source${this.discovery.imports.length === 1 ? "" : "s"} found.` });
         }
-        actions.push({ id: "view-example", label: "View example `.mcp.json`", description: "Preview a working shared MCP config you can paste or adapt." });
-        if (!this.discovery.sources.some((source) => source.id === "shared-project" && source.exists)) {
-          actions.push({ id: "scaffold-project", label: "Scaffold project `.mcp.json`", description: "Write a minimal project config using the standard shared MCP file path, then reload Pi." });
+        actions.push(
+          { id: "select-shared-target", label: `${this.sharedConfigTarget === "project" ? "\u25CF" : "\u25CB"} Add to this project (.mcp.json)`, description: "Write new shared MCP servers to the project/team config.", target: "project" },
+          { id: "select-shared-target", label: `${this.sharedConfigTarget === "global" ? "\u25CF" : "\u25CB"} Add globally (~/.config/mcp/mcp.json)`, description: "Write new shared MCP servers to your all-projects config.", target: "global" }
+        );
+        actions.push({ id: "view-example", label: "View example shared config", description: "Preview a working shared MCP config you can paste or adapt." });
+        if (!this.selectedSharedConfigExists()) {
+          actions.push({ id: "scaffold-shared-config", label: `Scaffold ${this.sharedTargetLabel()}`, description: "Write a minimal config at the selected normal MCP setup path, then reload Pi." });
         }
         actions.push({ id: "show-precedence", label: "Explain config precedence", description: "Show the read order and where Pi writes compatibility settings." });
         if (this.getDetectedPaths().length > 0) {
@@ -2578,7 +2589,7 @@ var init_mcp_setup_panel = __esm({
           actions.push({ id: "add-known-server", label: preset.name, description: preset.summary, preset });
         }
         if (!this.discovery.repoPrompt.configured && this.discovery.repoPrompt.executablePath && this.discovery.repoPrompt.targetPath && this.discovery.repoPrompt.entry && this.discovery.repoPrompt.serverName) {
-          actions.push({ id: "add-repoprompt", label: "Add RepoPrompt to shared MCP config", description: "Write a standard MCP entry for RepoPrompt to the recommended shared target, then reload MCP in-session." });
+          actions.push({ id: "add-repoprompt", label: "Add RepoPrompt to selected shared config", description: "Write a standard MCP entry for RepoPrompt to the selected normal setup path, then reload MCP in-session." });
         }
         actions.push({ id: "close", label: "Close", description: "Exit the onboarding flow." });
         return actions;
@@ -2590,6 +2601,13 @@ var init_mcp_setup_panel = __esm({
         ];
         return [...new Set(paths)];
       }
+      sharedTargetLabel() {
+        return this.sharedConfigTarget === "project" ? "project .mcp.json" : "global ~/.config/mcp/mcp.json";
+      }
+      selectedSharedConfigExists() {
+        const sourceId = this.sharedConfigTarget === "project" ? "shared-project" : "shared-global";
+        return this.discovery.sources.some((source) => source.id === sourceId && source.exists);
+      }
       getSelectedAction() {
         const actions = this.getActions();
         return actions[this.actionCursor];
@@ -2704,9 +2722,15 @@ var init_mcp_setup_panel = __esm({
           this.tui.requestRender();
           return;
         }
-        if (action.id === "scaffold-project") {
+        if (action.id === "select-shared-target" && action.target) {
+          this.sharedConfigTarget = action.target;
+          this.notice = { text: `New shared servers will be written to ${this.sharedTargetLabel()}.`, tone: "muted" };
+          this.tui.requestRender();
+          return;
+        }
+        if (action.id === "scaffold-shared-config") {
           await this.runBusy(async () => {
-            const result = await this.callbacks.scaffoldProjectConfig();
+            const result = await this.callbacks.scaffoldConfig(this.sharedConfigTarget);
             this.callbacks.markSetupCompleted();
             this.notice = { text: `Wrote starter config to ${result.path}. Pi will reload after this panel closes.`, tone: "success" };
           });
@@ -2714,7 +2738,7 @@ var init_mcp_setup_panel = __esm({
         }
         if (action.id === "add-repoprompt") {
           await this.runBusy(async () => {
-            const result = await this.callbacks.addRepoPrompt();
+            const result = await this.callbacks.addRepoPrompt(this.sharedConfigTarget);
             this.callbacks.markSetupCompleted();
             this.notice = { text: `Added ${result.serverName} to ${result.path}. Pi will reload after this panel closes.`, tone: "success" };
           });
@@ -2723,7 +2747,7 @@ var init_mcp_setup_panel = __esm({
         if (action.id === "add-known-server" && action.preset) {
           const preset = action.preset;
           await this.runBusy(async () => {
-            const result = await this.callbacks.addKnownServer(preset);
+            const result = await this.callbacks.addKnownServer(preset, this.sharedConfigTarget);
             this.callbacks.markSetupCompleted();
             this.notice = { text: `Added ${result.serverName} to ${result.path}. Pi will reload after this panel closes.`, tone: "success" };
           });
@@ -2812,8 +2836,11 @@ var init_mcp_setup_panel = __esm({
         for (let index = start; index < end; index++) {
           const action = actions[index];
           if (!action) continue;
+          if (action.id === "select-shared-target" && (index === start || actions[index - 1]?.id !== "select-shared-target")) {
+            lines.push(this.padLine(fg(this.t.title, "Choose where new shared servers go"), innerW));
+          }
           if (action.id === "add-known-server" && (index === start || actions[index - 1]?.id !== "add-known-server")) {
-            lines.push(this.padLine(fg(this.t.title, "Add a known server"), innerW));
+            lines.push(this.padLine(fg(this.t.title, `Add a known server to ${this.sharedTargetLabel()}`), innerW));
           }
           const selected = index === this.actionCursor;
           const cursor = selected ? fg(this.t.selected, "\u203A") : " ";
@@ -2878,12 +2905,12 @@ var init_mcp_setup_panel = __esm({
         const hostNote = this.discovery.hostConfigs.length > 0 ? ` Host discovery is ${this.discovery.hostConfigDiscovery}; ${this.discovery.hostConfigs.length} host source${this.discovery.hostConfigs.length === 1 ? "" : "s"} detected.` : "";
         const conflictNote = this.discovery.conflicts.length > 0 ? ` ${this.discovery.conflicts.length} same-name conflict${this.discovery.conflicts.length === 1 ? "" : "s"} reported.` : "";
         if (!this.discovery.hasAnyConfig) {
-          return `Create a shared .mcp.json, adopt host imports, or quick-add RepoPrompt from this screen.${hostNote}${conflictNote}`;
+          return `Add shared servers to .mcp.json for this project/team or ~/.config/mcp/mcp.json for all projects. Adopt host imports or quick-add RepoPrompt from this screen.${hostNote}${conflictNote}`;
         }
         if (this.discovery.totalServerCount === 0 && this.discovery.imports.length > 0) {
           return `Detected ${this.discovery.imports.length} compatibility import source${this.discovery.imports.length === 1 ? "" : "s"}. Adopt them into Pi or inspect the underlying files.${hostNote}${conflictNote}`;
         }
-        return `Shared MCP files are preferred. Pi-owned files are only for compatibility imports and adapter-specific overrides.${hostNote}${conflictNote}`;
+        return `Use .mcp.json for project/team servers or ~/.config/mcp/mcp.json for all projects. Pi-owned files are for compatibility imports and adapter-specific overrides, not another normal setup path.${hostNote}${conflictNote}`;
       }
       visibleActionRange(total) {
         if (total <= COMPACT_ACTION_ROWS) return { start: 0, end: total };
@@ -2913,6 +2940,12 @@ var init_mcp_setup_panel = __esm({
               ],
               previewW
             );
+          case "select-shared-target":
+            return this.formatPreview([
+              action.target === "project" ? "Project target: .mcp.json" : "Global target: ~/.config/mcp/mcp.json",
+              "Known server presets and starter configs will be written to the selected normal MCP setup path.",
+              "Pi-owned mcp.json files remain compatibility and adapter-only override state."
+            ], previewW);
           case "view-example":
             return this.formatPreview([
               "Example shared `.mcp.json`:",
@@ -2925,10 +2958,17 @@ var init_mcp_setup_panel = __esm({
               "  }",
               "}",
               "",
-              "Use Scaffold project `.mcp.json` when you want a safe empty shell instead of a live example server."
+              "Use Scaffold selected config when you want a safe empty shell instead of a live example server."
             ], previewW);
           case "show-precedence":
             return this.formatPreview([
+              "Recommended shared config:",
+              "  project/team: .mcp.json",
+              "  all projects: ~/.config/mcp/mcp.json",
+              "",
+              "Advanced compatibility and Pi-owned layers:",
+              "  host imports, .agents files, package MCP manifests, and Pi overrides",
+              "",
               "Read order (later entries win):",
               "0. detected host configs (opt-in lowest-precedence fallback)",
               "1. ~/.config/mcp/mcp.json",
@@ -2947,7 +2987,7 @@ var init_mcp_setup_panel = __esm({
             return this.formatPreview(this.getDetectedPaths().length > 0 ? ["Detected paths:", ...this.getDetectedPaths()] : ["No config paths were detected."], previewW);
           case "add-repoprompt": {
             const repoPrompt = this.discovery.repoPrompt;
-            const preview = this.callbacks.previewRepoPrompt();
+            const preview = this.callbacks.previewRepoPrompt(this.sharedConfigTarget);
             if (!preview) {
               return this.formatPreview(["RepoPrompt is not available to add from this setup screen."], previewW);
             }
@@ -2956,7 +2996,7 @@ var init_mcp_setup_panel = __esm({
               preview,
               [
                 `Executable: ${repoPrompt.executablePath ?? "not found"}`,
-                `Target: ${repoPrompt.targetPath ?? "n/a"}`,
+                `Target: ${this.sharedTargetLabel()}`,
                 `Server name: ${repoPrompt.serverName ?? "repoprompt"}`
               ],
               previewW
@@ -2967,17 +3007,17 @@ var init_mcp_setup_panel = __esm({
             if (!preset) return this.formatPreview(["Known server preset is unavailable."], previewW);
             return this.formatWritePreview(
               `${preset.name} write preview`,
-              this.callbacks.previewKnownServer(preset),
-              [preset.summary],
+              this.callbacks.previewKnownServer(preset, this.sharedConfigTarget),
+              [preset.summary, `Target: ${this.sharedTargetLabel()}`],
               previewW
             );
           }
-          case "scaffold-project":
+          case "scaffold-shared-config":
             return this.formatWritePreview(
-              "Starter project `.mcp.json` write preview",
-              this.callbacks.previewStarterProject(),
+              `${this.sharedTargetLabel()} starter write preview`,
+              this.callbacks.previewStarterConfig(this.sharedConfigTarget),
               [
-                "This writes a minimal `.mcp.json` in the current project using the shared MCP layout.",
+                "This writes a minimal config at the selected normal MCP setup path.",
                 "It intentionally avoids adding a fake placeholder server that would fail on first reload."
               ],
               previewW
@@ -3373,6 +3413,7 @@ var init_mcp_panel = __esm({
           }
           const status = callbacks.getConnectionStatus(serverName);
           const failureMessage = callbacks.getFailureMessage?.(serverName) ?? null;
+          const serverDisabled = isServerDisabled(definition);
           let directCount = 0;
           let directTokens = 0;
           for (const tool of tools) {
@@ -3388,6 +3429,8 @@ var init_mcp_panel = __esm({
             ...definition.includeTools !== void 0 ? { includeTools: definition.includeTools } : {},
             ...definition.excludeTools !== void 0 ? { excludeTools: definition.excludeTools } : {},
             exposeResources: definition.exposeResources !== false,
+            disabled: serverDisabled,
+            wasDisabled: serverDisabled,
             connectionStatus: status,
             failureMessage,
             tools,
@@ -3409,7 +3452,7 @@ var init_mcp_panel = __esm({
         if (this.inactivityTimeout) clearTimeout(this.inactivityTimeout);
         this.inactivityTimeout = setTimeout(() => {
           this.cleanup();
-          this.done({ cancelled: true, changes: /* @__PURE__ */ new Map() });
+          this.done({ cancelled: true, changes: /* @__PURE__ */ new Map(), disabledChanges: /* @__PURE__ */ new Map() });
         }, _McpPanel.INACTIVITY_MS);
       }
       cleanup() {
@@ -3460,11 +3503,15 @@ var init_mcp_panel = __esm({
         }
       }
       updateDirty() {
-        this.dirty = this.servers.some((s) => s.tools.some((t) => t.isDirect !== t.wasDirect));
+        this.dirty = this.servers.some((s) => s.disabled !== s.wasDisabled || s.tools.some((t) => t.isDirect !== t.wasDirect));
       }
       buildResult() {
         const changes = /* @__PURE__ */ new Map();
+        const disabledChanges = /* @__PURE__ */ new Map();
         for (const server2 of this.servers) {
+          if (server2.disabled !== server2.wasDisabled) {
+            disabledChanges.set(server2.name, server2.disabled);
+          }
           const changed = server2.tools.some((t) => t.isDirect !== t.wasDirect);
           if (!changed) continue;
           const directTools = server2.tools.filter((t) => t.isDirect);
@@ -3476,7 +3523,7 @@ var init_mcp_panel = __esm({
             changes.set(server2.name, directTools.map((t) => t.name));
           }
         }
-        return { changes, cancelled: false };
+        return { changes, disabledChanges, cancelled: false };
       }
       handleInput(data) {
         this.resetInactivityTimeout();
@@ -3488,7 +3535,7 @@ var init_mcp_panel = __esm({
         }
         if (matchesKey3(data, "ctrl+c")) {
           this.cleanup();
-          this.done({ cancelled: true, changes: /* @__PURE__ */ new Map() });
+          this.done({ cancelled: true, changes: /* @__PURE__ */ new Map(), disabledChanges: /* @__PURE__ */ new Map() });
           return;
         }
         if (this.keys.save(data)) {
@@ -3546,7 +3593,7 @@ var init_mcp_panel = __esm({
             return;
           }
           this.cleanup();
-          this.done({ cancelled: true, changes: /* @__PURE__ */ new Map() });
+          this.done({ cancelled: true, changes: /* @__PURE__ */ new Map(), disabledChanges: /* @__PURE__ */ new Map() });
           return;
         }
         if (this.keys.selectUp(data)) {
@@ -3599,6 +3646,16 @@ var init_mcp_panel = __esm({
           if (server2) this.reconnectServer(server2);
           return;
         }
+        if (matchesKey3(data, "ctrl+d")) {
+          const item = this.visibleItems[this.cursorIndex];
+          if (!item || item.type !== "server" || this.authOnly) return;
+          const server2 = this.servers[item.serverIndex];
+          if (!server2) return;
+          server2.disabled = !server2.disabled;
+          this.updateDirty();
+          this.tui.requestRender();
+          return;
+        }
         if (matchesKey3(data, "ctrl+y")) {
           const item = this.visibleItems[this.cursorIndex];
           if (!item) return;
@@ -3737,7 +3794,7 @@ var init_mcp_panel = __esm({
       handleDiscardInput(data) {
         if (matchesKey3(data, "ctrl+c")) {
           this.cleanup();
-          this.done({ cancelled: true, changes: /* @__PURE__ */ new Map() });
+          this.done({ cancelled: true, changes: /* @__PURE__ */ new Map(), disabledChanges: /* @__PURE__ */ new Map() });
           return;
         }
         if (matchesKey3(data, "escape") || data === "n" || data === "N") {
@@ -3747,7 +3804,7 @@ var init_mcp_panel = __esm({
         if (this.keys.selectConfirm(data)) {
           this.cleanup();
           if (this.discardSelected === 0) {
-            this.done({ cancelled: true, changes: /* @__PURE__ */ new Map() });
+            this.done({ cancelled: true, changes: /* @__PURE__ */ new Map(), disabledChanges: /* @__PURE__ */ new Map() });
           } else {
             this.done(this.buildResult());
           }
@@ -3755,7 +3812,7 @@ var init_mcp_panel = __esm({
         }
         if (data === "y" || data === "Y") {
           this.cleanup();
-          this.done({ cancelled: true, changes: /* @__PURE__ */ new Map() });
+          this.done({ cancelled: true, changes: /* @__PURE__ */ new Map(), disabledChanges: /* @__PURE__ */ new Map() });
           return;
         }
         if (matchesKey3(data, "left") || matchesKey3(data, "right") || matchesKey3(data, "tab")) {
@@ -3949,6 +4006,7 @@ var init_mcp_panel = __esm({
           italic("\u23CE") + " expand/auth",
           italic("ctrl+a") + " auth",
           italic("ctrl+r") + " reconnect",
+          italic("ctrl+d") + " disable/enable",
           ...this.selectedServerHasFailureMessage() ? [italic("ctrl+y") + " copy error"] : [],
           italic("?") + " desc search",
           ...saveLabel ? [italic(saveLabel) + " save"] : [],
@@ -4048,7 +4106,7 @@ var init_mcp_panel = __esm({
       renderConnectionStatus(server2) {
         const t = this.t;
         if (this.authInFlight === server2.name) return `  ${fg2(t.needsAuth, "authenticating")}`;
-        if (server2.connectionStatus === "disabled") return `  ${fg2(t.description, "disabled")}`;
+        if (server2.disabled) return `  ${fg2(t.description, "disabled")}`;
         if (server2.connectionStatus === "needs-auth") return `  ${fg2(t.needsAuth, "needs auth")}`;
         if (server2.connectionStatus === "connecting") return `  ${fg2(t.needsAuth, "connecting")}`;
         if (server2.connectionStatus === "failed") return `  ${fg2(t.cancel, "failed")}`;
@@ -4179,6 +4237,89 @@ function wrapError(error, context) {
     ...cause !== void 0 ? { cause } : {}
   });
 }
+var INPUT_REQUIRED_NEEDS_UI = "input_required_needs_ui";
+var INPUT_REQUIRED_METHODS = /* @__PURE__ */ new Set([
+  "elicitation/create",
+  "sampling/createMessage"
+]);
+var MAX_INPUT_REQUIRED_SERVER_LENGTH = 96;
+var MAX_INPUT_REQUIRED_TARGET_LENGTH = 160;
+var MAX_INPUT_REQUIRED_DETAIL_LENGTH = 128;
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function boundedText(value, maxLength) {
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  return value.length <= maxLength ? value : `${value.slice(0, maxLength - 1)}\u2026`;
+}
+function findEmbeddedInputRequest(error) {
+  let current = error;
+  const seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; depth < 8 && current !== void 0 && current !== null; depth++) {
+    if (seen.has(current)) return void 0;
+    seen.add(current);
+    const record = asRecord(current);
+    if (!record) return void 0;
+    if (record.code === INPUT_REQUIRED_NEEDS_UI) {
+      const details = asRecord(record.details);
+      const inputKey = boundedText(details?.inputKey, MAX_INPUT_REQUIRED_DETAIL_LENGTH);
+      const inputMethod = boundedText(details?.inputMethod, MAX_INPUT_REQUIRED_DETAIL_LENGTH);
+      if (inputKey && inputMethod && INPUT_REQUIRED_METHODS.has(inputMethod)) {
+        const server2 = boundedText(details?.server, MAX_INPUT_REQUIRED_SERVER_LENGTH);
+        const tool = boundedText(details?.tool, MAX_INPUT_REQUIRED_TARGET_LENGTH);
+        const resourceUri = boundedText(details?.resourceUri, MAX_INPUT_REQUIRED_TARGET_LENGTH);
+        return {
+          inputKey,
+          inputMethod,
+          ...server2 ? { server: server2 } : {},
+          ...tool ? { tool } : {},
+          ...resourceUri ? { resourceUri } : {}
+        };
+      }
+    }
+    if (record.code === "CAPABILITY_NOT_SUPPORTED") {
+      const data = asRecord(record.data);
+      const inputKey = boundedText(data?.key, MAX_INPUT_REQUIRED_DETAIL_LENGTH);
+      const inputMethod = boundedText(data?.method, MAX_INPUT_REQUIRED_DETAIL_LENGTH);
+      if (inputKey && inputMethod && INPUT_REQUIRED_METHODS.has(inputMethod)) {
+        return { inputKey, inputMethod };
+      }
+    }
+    current = record.cause;
+  }
+  return void 0;
+}
+function getInputRequiredNeedsUiDetails(error, identity) {
+  const request = findEmbeddedInputRequest(error);
+  if (!request) return void 0;
+  const server2 = boundedText(request.server ?? identity.server, MAX_INPUT_REQUIRED_SERVER_LENGTH) ?? "unknown";
+  const tool = boundedText(request.tool ?? identity.tool, MAX_INPUT_REQUIRED_TARGET_LENGTH);
+  const resourceUri = boundedText(request.resourceUri ?? identity.resourceUri, MAX_INPUT_REQUIRED_TARGET_LENGTH);
+  const target = resourceUri ? `read resource "${resourceUri}"` : tool ? `call tool "${tool}"` : "complete the MCP request";
+  const guidance = request.inputMethod === "elicitation/create" ? "Run this call in an interactive Pi session with elicitation enabled, then retry." : "Run this call in an interactive Pi session with the required MCP capability enabled, then retry.";
+  const message = `MCP server "${server2}" requested input to ${target}, but this session has no handler for "${request.inputMethod}" (input "${request.inputKey}"). ${guidance}`;
+  return {
+    error: INPUT_REQUIRED_NEEDS_UI,
+    server: server2,
+    ...tool ? { tool } : {},
+    ...resourceUri ? { resourceUri } : {},
+    inputKey: request.inputKey,
+    inputMethod: request.inputMethod,
+    message
+  };
+}
+var InputRequiredNeedsUiError = class extends McpUiError {
+  constructor(details, cause) {
+    super(details.message, {
+      code: INPUT_REQUIRED_NEEDS_UI,
+      context: { ...details },
+      recoveryHint: "Run this call in an interactive Pi session with the required MCP input handler enabled, then retry.",
+      ...cause ? { cause } : {}
+    });
+    this.details = details;
+    this.name = "InputRequiredNeedsUiError";
+  }
+};
 
 // packages/coding-agent/src/humain/mcp-adapter/vendor/logger.ts
 var LEVEL_PRIORITY = {
@@ -4968,14 +5109,14 @@ function readNpxCachePayload(cachePath) {
     return null;
   }
 }
-function asRecord(value) {
+function asRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }
 function createCacheEntries() {
   return /* @__PURE__ */ Object.create(null);
 }
 function toNpxCacheEntry(value) {
-  const raw = asRecord(value);
+  const raw = asRecord2(value);
   if (!raw) return null;
   if (typeof raw.resolvedBin !== "string") return null;
   if (typeof raw.resolvedAt !== "number" || !Number.isFinite(raw.resolvedAt)) return null;
@@ -4989,9 +5130,9 @@ function toNpxCacheEntry(value) {
   };
 }
 function toNpxCache(value) {
-  const raw = asRecord(value);
+  const raw = asRecord2(value);
   if (!raw || raw.version !== CACHE_VERSION) return null;
-  const rawEntries = asRecord(raw.entries);
+  const rawEntries = asRecord2(raw.entries);
   if (!rawEntries) return null;
   const entries = createCacheEntries();
   for (const [key, rawEntry] of Object.entries(rawEntries)) {
@@ -5002,7 +5143,7 @@ function toNpxCache(value) {
 }
 function clearLegacyCache() {
   const cachePath = getNpxCachePath();
-  const raw = asRecord(readNpxCachePayload(cachePath));
+  const raw = asRecord2(readNpxCachePayload(cachePath));
   if (raw?.version !== 1) return false;
   try {
     unlinkSync(cachePath);
@@ -8713,6 +8854,9 @@ function appendStderrTail(tail, chunk) {
   return combined.length > MAX_CAPTURED_STDERR_BYTES ? Buffer.from(combined.subarray(combined.length - MAX_CAPTURED_STDERR_BYTES)) : combined;
 }
 var KEEP_ALIVE_REFRESH_TIMEOUT_MS = 5e3;
+var LISTEN_RETRY_DELAY_MS = 5e3;
+var RECENT_RESOURCE_TTL_MS = 10 * 6e4;
+var MAX_RESOURCE_SUBSCRIPTIONS = 32;
 function isTransientHttpConnectError(error) {
   let current = error;
   while (current instanceof Error) {
@@ -8729,6 +8873,7 @@ var McpServerManager = class {
     this.connectPromises = /* @__PURE__ */ new Map();
     this.reconnectPromises = /* @__PURE__ */ new Map();
     this.uiStreamListeners = /* @__PURE__ */ new Map();
+    this.resourceUpdatedListeners = /* @__PURE__ */ new Map();
     this.pendingMetadataPublications = /* @__PURE__ */ new Map();
     this.authStorageOptions = {};
     this.acceptedUrlElicitations = /* @__PURE__ */ new Map();
@@ -8743,6 +8888,9 @@ var McpServerManager = class {
   setMetadataListChangedListener(listener) {
     this.metadataListChangedListener = listener;
   }
+  setListenStateChangedListener(listener) {
+    this.listenStateChangedListener = listener;
+  }
   publishMetadataChanged(name, expectedConnection, reason) {
     const current = this.connections.get(name);
     if (current !== expectedConnection || current.status !== "connected") return false;
@@ -8830,6 +8978,10 @@ var McpServerManager = class {
         throw new Error(`MCP connection for ${name} was closed while connecting`);
       }
       this.connections.set(name, connection);
+      this.watchListenSubscription(name, connection, connection.listenSubscription);
+      if ([...this.resourceUpdatedListeners.values()].some((registration) => registration.serverName === name)) {
+        void this.ensureListen(name, connection);
+      }
       return connection;
     } finally {
       if (this.connectPromises.get(name) === promise) this.connectPromises.delete(name);
@@ -8876,6 +9028,7 @@ var McpServerManager = class {
     if (current !== expectedConnection || current.status !== "connected") {
       return "superseded";
     }
+    await this.ensureListen(name, expectedConnection);
     const requestOptions = this.buildRequestOptions(expectedConnection.definition, signal);
     const timeout = Math.min(requestOptions?.timeout ?? KEEP_ALIVE_REFRESH_TIMEOUT_MS, KEEP_ALIVE_REFRESH_TIMEOUT_MS);
     const healthOptions = {
@@ -8947,6 +9100,198 @@ var McpServerManager = class {
       this.pendingMetadataPublications.delete(name);
     }
   }
+  setListenState(name, connection, state) {
+    if (connection.listenState === state) return;
+    connection.listenState = state;
+    if (this.connections.get(name) === connection) {
+      try {
+        this.listenStateChangedListener?.(name, state);
+      } catch {
+      }
+    }
+  }
+  catalogListenFilter(connection) {
+    const capabilities = connection.client.getServerCapabilities?.();
+    return {
+      ...capabilities?.tools?.listChanged ? { toolsListChanged: true } : {},
+      ...capabilities?.prompts?.listChanged ? { promptsListChanged: true } : {},
+      ...capabilities?.resources?.listChanged ? { resourcesListChanged: true } : {}
+    };
+  }
+  currentListenFilter(name, connection) {
+    const now = Date.now();
+    const recent = connection.recentResourceUris;
+    if (recent) {
+      for (const [uri, touchedAt] of recent) {
+        if (now - touchedAt > RECENT_RESOURCE_TTL_MS) recent.delete(uri);
+      }
+    }
+    const openResourceUris = [...new Set(
+      [...this.resourceUpdatedListeners.values()].filter((registration) => registration.serverName === name).map((registration) => registration.uri)
+    )].slice(-MAX_RESOURCE_SUBSCRIPTIONS);
+    const openSet = new Set(openResourceUris);
+    const recentSlots = MAX_RESOURCE_SUBSCRIPTIONS - openResourceUris.length;
+    const recentResourceUris = recentSlots > 0 ? [...recent?.keys() ?? []].filter((uri) => !openSet.has(uri)).slice(-recentSlots) : [];
+    const resourceSubscriptions = [...openResourceUris, ...recentResourceUris];
+    return {
+      ...this.catalogListenFilter(connection),
+      ...resourceSubscriptions.length > 0 ? { resourceSubscriptions } : {}
+    };
+  }
+  watchListenSubscription(name, connection, subscription) {
+    if (!subscription) return;
+    void subscription.closed.then((cause) => {
+      if (this.stopped || this.connections.get(name) !== connection || connection.status !== "connected" || connection.listenSubscription !== subscription) return;
+      if (cause === "remote") {
+        const staleUris = connection.listenFilter?.resourceSubscriptions ?? [];
+        if (staleUris.length > 0) connection.resourceReadRefreshUris = new Set(staleUris);
+        connection.listenCatalogStale = true;
+        connection.listenRetryAfter = Date.now();
+        this.setListenState(name, connection, "dropped");
+      } else if (cause === "graceful" || connection.listenState !== "re-establishing") {
+        connection.listenStopped = true;
+        this.setListenState(name, connection, "not-listening");
+      }
+    });
+  }
+  /** Quietly repairs a modern catalog listen at an existing activity boundary. */
+  async ensureListen(name, expectedConnection) {
+    if (this.stopped || this.connections.get(name) !== expectedConnection || expectedConnection.status !== "connected" || expectedConnection.listenStopped || expectedConnection.client.getProtocolEra?.() !== "modern") return;
+    const filter = this.currentListenFilter(name, expectedConnection);
+    if (Object.keys(filter).length === 0) {
+      this.setListenState(name, expectedConnection, "not-listening");
+      return;
+    }
+    if (expectedConnection.listenPromise) {
+      await expectedConnection.listenPromise;
+      return this.ensureListen(name, expectedConnection);
+    }
+    if ((expectedConnection.listenRetryAfter ?? 0) > Date.now()) return;
+    const sameFilter = isDeepStrictEqual(expectedConnection.listenFilter, filter);
+    if (expectedConnection.listenState === "active" && sameFilter) {
+      if (!expectedConnection.listenCatalogStale) return;
+      const attempt2 = (async () => {
+        this.setListenState(name, expectedConnection, "re-establishing");
+        const confirmed = await this.reconcileCatalogAfterListen(name, expectedConnection, this.buildRequestOptions(expectedConnection.definition));
+        if (!confirmed) expectedConnection.listenRetryAfter = Date.now() + LISTEN_RETRY_DELAY_MS;
+        this.setListenState(name, expectedConnection, "active");
+      })().finally(() => {
+        if (expectedConnection.listenPromise === attempt2) delete expectedConnection.listenPromise;
+      });
+      expectedConnection.listenPromise = attempt2;
+      return attempt2;
+    }
+    const attempt = (async () => {
+      const recoverDroppedListen = expectedConnection.listenState === "dropped";
+      this.setListenState(name, expectedConnection, "re-establishing");
+      const previous = expectedConnection.listenSubscription;
+      if (previous) await previous.close().catch(() => {
+      });
+      if (this.connections.get(name) !== expectedConnection || expectedConnection.status !== "connected") return;
+      try {
+        const requestOptions = this.buildRequestOptions(expectedConnection.definition);
+        const subscription = await expectedConnection.client.listen(
+          filter,
+          {
+            ...requestOptions,
+            timeout: Math.min(requestOptions?.timeout ?? KEEP_ALIVE_REFRESH_TIMEOUT_MS, KEEP_ALIVE_REFRESH_TIMEOUT_MS)
+          }
+        );
+        if (this.connections.get(name) !== expectedConnection || expectedConnection.status !== "connected") {
+          await subscription.close().catch(() => {
+          });
+          return;
+        }
+        expectedConnection.listenSubscription = subscription;
+        expectedConnection.listenFilter = filter;
+        delete expectedConnection.listenStopped;
+        delete expectedConnection.listenRetryAfter;
+        this.watchListenSubscription(name, expectedConnection, subscription);
+        const confirmed = recoverDroppedListen ? await this.reconcileCatalogAfterListen(name, expectedConnection, requestOptions) : true;
+        if (!confirmed) expectedConnection.listenRetryAfter = Date.now() + LISTEN_RETRY_DELAY_MS;
+        this.setListenState(name, expectedConnection, "active");
+      } catch (error) {
+        if (this.connections.get(name) !== expectedConnection || expectedConnection.status !== "connected") return;
+        if (expectedConnection.listenSubscription) await expectedConnection.listenSubscription.close().catch(() => {
+        });
+        expectedConnection.listenRetryAfter = Date.now() + LISTEN_RETRY_DELAY_MS;
+        this.setListenState(name, expectedConnection, "dropped");
+        logger.debug(`MCP: catalog listen repair failed for ${name}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    })().finally(() => {
+      if (expectedConnection.listenPromise === attempt) delete expectedConnection.listenPromise;
+    });
+    expectedConnection.listenPromise = attempt;
+    return attempt;
+  }
+  async reconcileCatalogAfterListen(name, expectedConnection, requestOptions) {
+    const timeout = Math.min(requestOptions?.timeout ?? KEEP_ALIVE_REFRESH_TIMEOUT_MS, KEEP_ALIVE_REFRESH_TIMEOUT_MS);
+    const refreshSignal = combineAbortSignals(requestOptions?.signal, AbortSignal.timeout(timeout));
+    const refreshOptions = {
+      ...requestOptions,
+      timeout,
+      cacheMode: "refresh",
+      ...refreshSignal ? { signal: refreshSignal } : {}
+    };
+    const [toolResult, resources, promptResult] = await Promise.allSettled([
+      this.fetchAllTools(expectedConnection.client, refreshOptions),
+      this.fetchAllResources(expectedConnection.client, refreshOptions, true),
+      this.fetchAllPrompts(expectedConnection.client, refreshOptions)
+    ]);
+    if (this.connections.get(name) !== expectedConnection || expectedConnection.status !== "connected") return false;
+    const nextTools = toolResult.status === "fulfilled" ? toolResult.value : void 0;
+    const nextResources = resources.status === "fulfilled" ? resources.value : void 0;
+    const nextPrompts = promptResult.status === "fulfilled" && !promptResult.value.failed ? promptResult.value : void 0;
+    const confirmed = nextTools !== void 0 && nextResources !== void 0 && nextPrompts !== void 0;
+    const changed = nextTools !== void 0 && (!isDeepStrictEqual(expectedConnection.tools, nextTools.tools) || !isDeepStrictEqual(expectedConnection.toolListHints, nextTools.hints)) || nextResources !== void 0 && !isDeepStrictEqual(expectedConnection.resources, nextResources) || nextPrompts !== void 0 && (!isDeepStrictEqual(expectedConnection.prompts, nextPrompts.prompts) || expectedConnection.promptDiscoveryFailed !== false);
+    if (!changed) {
+      this.retryPendingMetadataPublication(name, expectedConnection);
+      if (confirmed) delete expectedConnection.listenCatalogStale;
+      else expectedConnection.listenCatalogStale = true;
+      return confirmed;
+    }
+    if (nextTools !== void 0) {
+      expectedConnection.tools = nextTools.tools;
+      expectedConnection.toolListHints = nextTools.hints;
+      expectedConnection.toolsRevision = (expectedConnection.toolsRevision ?? 0) + 1;
+    }
+    if (nextResources !== void 0) expectedConnection.resources = nextResources;
+    if (nextPrompts !== void 0) {
+      expectedConnection.prompts = nextPrompts.prompts;
+      expectedConnection.promptDiscoveryFailed = false;
+    }
+    if (confirmed) delete expectedConnection.listenCatalogStale;
+    else expectedConnection.listenCatalogStale = true;
+    this.metadataListChangedListener?.(name, "listen-recovered");
+    this.pendingMetadataPublications.delete(name);
+    return confirmed;
+  }
+  async prepareResourceUse(name, uri, expectedConnection) {
+    if (this.connections.get(name) !== expectedConnection || expectedConnection.status !== "connected") return false;
+    const refreshRead = expectedConnection.listenState === "dropped" || expectedConnection.listenState === "re-establishing" || expectedConnection.resourceReadRefreshUris?.has(uri) === true;
+    const recent = expectedConnection.recentResourceUris ?? /* @__PURE__ */ new Map();
+    recent.delete(uri);
+    recent.set(uri, Date.now());
+    while (recent.size > MAX_RESOURCE_SUBSCRIPTIONS) {
+      const oldest = recent.keys().next().value;
+      if (oldest === void 0) break;
+      recent.delete(oldest);
+    }
+    expectedConnection.recentResourceUris = recent;
+    await this.ensureListen(name, expectedConnection);
+    expectedConnection.resourceReadRefreshUris?.delete(uri);
+    return refreshRead;
+  }
+  registerResourceUpdatedListener(token, serverName, uri, listener) {
+    this.removeResourceUpdatedListener(token);
+    this.resourceUpdatedListeners.set(token, { serverName, uri, listener });
+    const connection = this.connections.get(serverName);
+    if (!connection || connection.status !== "connected") return;
+    void this.prepareResourceUse(serverName, uri, connection);
+  }
+  removeResourceUpdatedListener(token) {
+    this.resourceUpdatedListeners.delete(token);
+  }
   async doReconnect(name, definition, staleConnection, signal) {
     throwIfAborted(signal);
     const current = this.connections.get(name);
@@ -9031,6 +9376,7 @@ var McpServerManager = class {
           lastUsedAt: Date.now(),
           inFlight: 0,
           status: "needs-auth",
+          listenState: "disconnected",
           credentialsInvalidated: invalidated
         };
       }
@@ -9051,6 +9397,8 @@ var McpServerManager = class {
       }
       this.attachAdapterNotificationHandlers(name, client);
       const instructions = client.getInstructions?.();
+      const protocolEra = client.getProtocolEra?.();
+      const autoOpenedSubscription = client.autoOpenedSubscription;
       const connection = {
         client,
         transport,
@@ -9062,8 +9410,13 @@ var McpServerManager = class {
         ...instructions !== void 0 ? { instructions } : {},
         lastUsedAt: Date.now(),
         inFlight: 0,
-        status: "connected"
+        status: "connected",
+        listenState: protocolEra === "modern" ? autoOpenedSubscription ? "active" : "not-listening" : "legacy",
+        ...autoOpenedSubscription ? {
+          listenSubscription: autoOpenedSubscription
+        } : {}
       };
+      if (autoOpenedSubscription) connection.listenFilter = this.catalogListenFilter(connection);
       client.onclose = () => {
         if (this.connections.get(name) === connection) {
           connection.status = "closed";
@@ -9106,6 +9459,7 @@ var McpServerManager = class {
           lastUsedAt: Date.now(),
           inFlight: 0,
           status: "needs-auth",
+          listenState: "disconnected",
           credentialsInvalidated: invalidated
         };
       }
@@ -9316,7 +9670,16 @@ var McpServerManager = class {
       this.authStorageOptions,
       this.oauthRuntime?.signal
     );
-    let authState = supportsOAuth(definition) ? definition.auth === void 0 ? { status: "implicit-deferred" } : { status: "explicit", provider: createAuthProvider() } : { status: "disabled" };
+    let implicitStoredAuth;
+    if (definition.auth === void 0 && supportsOAuth(definition)) {
+      try {
+        implicitStoredAuth = inspectAuthForUrl(serverName, serverUrl, this.authStorageOptions);
+      } catch {
+      }
+    }
+    const hasImplicitStoredTokens = implicitStoredAuth?.status === "present" && implicitStoredAuth.entry.tokens !== void 0;
+    if (hasImplicitStoredTokens) invalidateAuthEntryCache(serverName);
+    let authState = supportsOAuth(definition) ? definition.auth === void 0 ? hasImplicitStoredTokens ? { status: "implicit-stored", provider: createAuthProvider() } : { status: "implicit-deferred" } : { status: "explicit", provider: createAuthProvider() } : { status: "disabled" };
     const attempt = async (kind2) => {
       const authProvider = "provider" in authState ? authState.provider : void 0;
       const transportOptions = {
@@ -9421,7 +9784,7 @@ var McpServerManager = class {
       return { prompts: [], failed: true };
     }
   }
-  async fetchAllResources(client, requestOptions) {
+  async fetchAllResources(client, requestOptions, strict = false) {
     const capabilities = client.getServerCapabilities?.();
     if (!capabilities?.resources) return [];
     try {
@@ -9438,10 +9801,24 @@ var McpServerManager = class {
         throwIfAborted(requestOptions.signal);
       }
       if (isUnauthorizedHttpError(error)) throw error;
+      if (strict) throw error;
       return [];
     }
   }
   attachAdapterNotificationHandlers(serverName, client) {
+    client.setNotificationHandler("notifications/resources/updated", (notification) => {
+      const uri = notification.params.uri;
+      const connection = this.connections.get(serverName);
+      if (!connection || connection.client !== client || connection.status !== "connected") return;
+      for (const registration of this.resourceUpdatedListeners.values()) {
+        if (registration.serverName === serverName && registration.uri === uri) {
+          try {
+            registration.listener(serverName, uri);
+          } catch {
+          }
+        }
+      }
+    });
     client.setNotificationHandler(
       SERVER_STREAM_RESULT_PATCH_METHOD,
       { params: serverStreamResultPatchNotificationSchema.shape.params },
@@ -9466,6 +9843,7 @@ var McpServerManager = class {
     try {
       this.touch(name);
       this.incrementInFlight(name);
+      await this.ensureListen(name, connection);
       return await connection.client.getPrompt(
         { name: promptName, ...args ? { arguments: args } : {} },
         this.getRequestOptions(name, signal)
@@ -9486,7 +9864,12 @@ var McpServerManager = class {
     try {
       this.touch(name);
       this.incrementInFlight(name);
-      return await connection.client.readResource({ uri }, this.getRequestOptions(name, signal));
+      const refreshRead = await this.prepareResourceUse(name, uri, connection);
+      const requestOptions = this.getRequestOptions(name, signal);
+      return await connection.client.readResource(
+        { uri },
+        refreshRead ? { ...requestOptions, cacheMode: "refresh" } : requestOptions
+      );
     } finally {
       this.decrementInFlight(name);
       this.touch(name);
@@ -9546,6 +9929,7 @@ var McpServerManager = class {
     const lateResults = await Promise.allSettled(lateNames.map((name) => this.close(name)));
     const failures = [...pendingResults, ...results, ...lateResults].flatMap((result) => result.status === "rejected" ? [result.reason] : []).filter((error) => this.containsCleanupFailure(error));
     this.uiStreamListeners.clear();
+    this.resourceUpdatedListeners.clear();
     this.acceptedUrlElicitations.clear();
     this.pendingMetadataPublications.clear();
     this.samplingConfig = void 0;
@@ -10320,7 +10704,14 @@ var UiResourceHandler = class {
               ...options.onNeedsAuth ? { onNeedsAuth: options.onNeedsAuth } : {}
             },
             serverName,
-            (connection) => connection.client.readResource({ uri }, this.manager.getRequestOptions(serverName, options.signal))
+            async (connection) => {
+              const refreshRead = await this.manager.prepareResourceUse?.(serverName, uri, connection);
+              const requestOptions = this.manager.getRequestOptions(serverName, options.signal);
+              return connection.client.readResource(
+                { uri },
+                refreshRead ? { ...requestOptions, cacheMode: "refresh" } : requestOptions
+              );
+            }
           );
         } finally {
           this.manager.decrementInFlight(serverName);
@@ -10331,6 +10722,10 @@ var UiResourceHandler = class {
       }
     } catch (error) {
       if (error instanceof UrlElicitationRequiredError || error instanceof SessionRecoveryAuthRequiredError) throw error;
+      const inputRequired = getInputRequiredNeedsUiDetails(error, { server: serverName, resourceUri: uri });
+      if (inputRequired) {
+        throw new InputRequiredNeedsUiError(inputRequired, error instanceof Error ? error : void 0);
+      }
       const message = error instanceof Error ? error.message : String(error);
       log.error("Failed to read resource", error instanceof Error ? error : void 0);
       throw new ResourceFetchError(uri, message, {
@@ -10538,7 +10933,9 @@ function createMcpStatusSnapshot(state) {
     servers.push({
       name,
       status,
+      listenState: connection?.status === "connected" ? connection.listenState : "disconnected",
       toolCount,
+      ...connection?.status === "connected" && connection.listenCatalogStale ? { catalogStale: true } : {},
       ...resourceCount !== void 0 ? { resourceCount } : {},
       ...status === "failed" && failedAgoSeconds !== null ? { failedAgoSeconds } : {},
       disabled
@@ -10725,6 +11122,10 @@ async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), options =
     notifyToolMetadataUpdated(state, serverName, reason);
     updateStatusBar(state);
   });
+  manager.setListenStateChangedListener?.(() => {
+    if (!owner.isActive()) return;
+    updateStatusBar(state);
+  });
   owner.addCleanup(() => lifecycle.gracefulShutdown());
   owner.addCleanup(() => {
     if (state.uiServer) {
@@ -11087,6 +11488,7 @@ async function lazyConnect(state, serverName, signal) {
     return false;
   }
   if (connection?.status === "connected") {
+    await state.manager.ensureListen?.(serverName, connection);
     updateServerMetadata(state, serverName);
     markKeepAliveAfterConnect(state, serverName);
     return true;
@@ -11209,6 +11611,13 @@ function canRenderPanel(ctx) {
 async function showStatus(state, ctx) {
   if (!ctx.hasUI) return;
   const lines = ["MCP Server Status:", ""];
+  if (!state.programmaticConfig) {
+    lines.push(
+      "Shared MCP config: .mcp.json for this project/team or ~/.config/mcp/mcp.json for all projects.",
+      "Pi-owned files hold compatibility imports and adapter-specific overrides.",
+      ""
+    );
+  }
   for (const name of Object.keys(state.config.mcpServers)) {
     const definition = state.config.mcpServers[name];
     if (isServerDisabled(definition)) {
@@ -11219,11 +11628,11 @@ async function showStatus(state, ctx) {
     const metadata = state.toolMetadata.get(name);
     const toolCount = metadata?.length ?? 0;
     const failedAgo = getFailureAgeSeconds(state, name);
-    let status = "not connected";
+    let status = "not listening (disconnected)";
     let statusIcon = "\u25CB";
     let failed = false;
     if (connection?.status === "connected") {
-      status = "connected";
+      status = connection.listenState === "active" ? connection.listenCatalogStale ? "connected; listen active; catalog may be stale" : "connected; listen active" : connection.listenState === "dropped" ? "connected; catalog may be stale \u2014 will reconcile on next keep-alive or tool use" : connection.listenState === "re-establishing" ? "connected; re-establishing listen" : connection.listenState === "legacy" ? "connected; legacy notification path" : "connected; not listening for catalog updates";
       statusIcon = "\u2713";
     } else if (connection?.status === "needs-auth") {
       status = "needs auth";
@@ -11234,14 +11643,17 @@ async function showStatus(state, ctx) {
       statusIcon = "\u2717";
       failed = true;
     } else if (metadata !== void 0) {
-      status = "cached";
+      status = "cached; not listening (disconnected)";
     }
-    const toolSuffix = failed ? "" : ` (${toolCount} tools${status === "cached" ? ", cached" : ""})`;
+    const toolSuffix = failed ? "" : ` (${toolCount} tools${status.startsWith("cached") ? ", cached" : ""})`;
     lines.push(`${statusIcon} ${name}: ${status}${toolSuffix}`);
   }
+  if (state.config.settings?.freezeDirectTools === true) {
+    lines.push("", "Direct tools frozen; active registrations may differ from current metadata.");
+  }
   if (Object.keys(state.config.mcpServers).length === 0) {
     lines.push("No MCP servers configured");
-    lines.push("Run /mcp setup to adopt imports or scaffold a starter .mcp.json");
+    lines.push("Run /mcp setup to add a server to .mcp.json or ~/.config/mcp/mcp.json");
   }
   ctx.ui.notify(lines.join("\n"), "info");
 }
@@ -11530,15 +11942,17 @@ async function manageBearerToken(action, serverName, state, ctx) {
 function buildSharedConfigNoticeLines(configOverridePath, cwd) {
   const discovery = getMcpStandardConfigSummary(configOverridePath, cwd);
   const onboardingState = loadOnboardingState();
-  if (!discovery.hasSharedServers || onboardingState.sharedConfigHintShown) {
+  const sharedSources = discovery.sources.filter(
+    (source) => (source.id === "shared-project" || source.id === "shared-global") && source.serverCount > 0
+  );
+  if (sharedSources.length === 0 || onboardingState.sharedConfigHintShown) {
     return { lines: [], fingerprint: null };
   }
-  const sharedSources = discovery.sources.filter((source) => source.kind === "shared" && source.serverCount > 0);
   const sourceList = sharedSources.map((source) => source.path).join(", ");
   return {
     lines: [
       `Using standard MCP config from ${sourceList}.`,
-      "Pi only writes compatibility imports and adapter-specific overrides into Pi-owned files when needed."
+      "Use .mcp.json for project/team config or ~/.config/mcp/mcp.json for all projects. Pi only writes compatibility imports and adapter-specific overrides into Pi-owned files when needed."
     ],
     fingerprint: discovery.fingerprint
   };
@@ -11559,34 +11973,34 @@ async function openMcpSetup(state, pi, ctx, configOverridePath, mode = "setup",
   let configChanged = false;
   const callbacks = {
     previewImports: (imports) => previewCompatibilityImports(imports, configOverridePath),
-    previewStarterProject: () => previewStarterProjectConfig(ctx.cwd),
-    previewRepoPrompt: () => {
+    previewStarterConfig: (target) => previewStarterSharedConfig(target, ctx.cwd),
+    previewRepoPrompt: (target) => {
       const repoPrompt = getMcpDiscoverySummary(configOverridePath, ctx.cwd, options).repoPrompt;
       if (!repoPrompt.entry || !repoPrompt.targetPath || !repoPrompt.serverName) return null;
-      return previewSharedServerEntry(repoPrompt.targetPath, repoPrompt.serverName, repoPrompt.entry);
+      return previewSharedServerEntry(getSharedConfigPath(target, ctx.cwd), repoPrompt.serverName, repoPrompt.entry);
     },
-    previewKnownServer: (preset) => previewSharedServerEntry(getProjectConfigPath(ctx.cwd), preset.id, preset.entry),
+    previewKnownServer: (preset, target) => previewSharedServerEntry(getSharedConfigPath(target, ctx.cwd), preset.id, preset.entry),
     adoptImports: async (imports) => {
       const result = ensureCompatibilityImports(imports, configOverridePath);
       if (result.added.length > 0) configChanged = true;
       return result;
     },
-    scaffoldProjectConfig: async () => {
-      const path2 = writeStarterProjectConfig(ctx.cwd);
+    scaffoldConfig: async (target) => {
+      const path2 = writeStarterSharedConfig(target, ctx.cwd);
       configChanged = true;
       return { path: path2 };
     },
-    addRepoPrompt: async () => {
+    addRepoPrompt: async (target) => {
       const repoPrompt = getMcpDiscoverySummary(configOverridePath, ctx.cwd, options).repoPrompt;
       if (!repoPrompt.entry || !repoPrompt.targetPath || !repoPrompt.serverName) {
         throw new Error("RepoPrompt is not available to add from this setup screen.");
       }
-      const path2 = writeSharedServerEntry(repoPrompt.targetPath, repoPrompt.serverName, repoPrompt.entry);
+      const path2 = writeSharedServerEntry(getSharedConfigPath(target, ctx.cwd), repoPrompt.serverName, repoPrompt.entry);
       configChanged = true;
       return { path: path2, serverName: repoPrompt.serverName };
     },
-    addKnownServer: async (preset) => {
-      const path2 = writeSharedServerEntry(getProjectConfigPath(ctx.cwd), preset.id, preset.entry);
+    addKnownServer: async (preset, target) => {
+      const path2 = writeSharedServerEntry(getSharedConfigPath(target, ctx.cwd), preset.id, preset.entry);
       configChanged = true;
       return { path: path2, serverName: preset.name };
     },
@@ -11689,6 +12103,18 @@ async function openMcpPanel(state, pi, ctx, configOverridePath, onDirectToolsCon
       (tui, _theme, keybindings, done) => {
         return createMcpPanel2(config, cache, provenanceMap, callbacks, tui, (result) => {
           void (async () => {
+            if (!result.cancelled && result.disabledChanges.size > 0) {
+              for (const [serverName, disabled] of result.disabledChanges) {
+                try {
+                  const override = writeProjectServerDisabledOverride(configPath, ctx.cwd, serverName, disabled);
+                  if (override.changed) {
+                    configChanged = true;
+                  }
+                } catch (error) {
+                  ctx.ui.notify(`Failed to ${disabled ? "disable" : "enable"} server "${serverName}": ${error instanceof Error ? error.message : String(error)}`, "error");
+                }
+              }
+            }
             if (!result.cancelled && result.changes.size > 0) {
               writeDirectToolsConfig(result.changes, provenanceMap, config);
               await onDirectToolsConfigChanged?.(result.changes);
@@ -12171,7 +12597,7 @@ async function compactMcpResultOmission(summary, marker, maxBytes) {
 }
 async function summarizeMcpResult(result, raw, rawBytes) {
   const { path: fullResultPath, error: resultWriteError } = await saveArtifact("mcp-result", raw);
-  const record = asRecord2(result);
+  const record = asRecord3(result);
   const content = Array.isArray(record?.content) ? record.content : [];
   const summary = {
     omitted: true,
@@ -12198,7 +12624,7 @@ async function summarizeMcpResult(result, raw, rawBytes) {
 }
 function summarizeContent(content) {
   const summaries = content.slice(0, CONTENT_SUMMARY_LIMIT).map((block) => {
-    const record = asRecord2(block);
+    const record = asRecord3(block);
     if (!record) return { type: typeof block, omitted: true };
     if (record.type === "text") {
       const text = typeof record.text === "string" ? record.text : "";
@@ -12216,7 +12642,7 @@ function summarizeContent(content) {
   return summaries;
 }
 function summarizeValue(value) {
-  const record = asRecord2(value);
+  const record = asRecord3(value);
   if (!record) {
     return { type: value === null ? "null" : typeof value, estimatedBytes: estimateValueBytes(value), omitted: true };
   }
@@ -12230,7 +12656,7 @@ function summarizeValue(value) {
   };
 }
 function summarizeStructuredContent(value) {
-  const record = asRecord2(value);
+  const record = asRecord3(value);
   if (!record || Array.isArray(value)) return summarizeValue(value);
   const keys = Object.keys(record);
   const entries = Object.entries(record).slice(0, KEY_PREVIEW_LIMIT);
@@ -12260,7 +12686,7 @@ function estimateValueBytes(value, depth = 0) {
   if (value === null || value === void 0) return 0;
   if (typeof value === "string") return byteLength(value);
   if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return byteLength(String(value));
-  const record = asRecord2(value);
+  const record = asRecord3(value);
   if (!record || depth >= 2) return 0;
   const values = Array.isArray(value) ? value.slice(0, KEY_PREVIEW_LIMIT) : Object.values(record).slice(0, KEY_PREVIEW_LIMIT);
   return values.reduce((total, item) => total + estimateValueBytes(item, depth + 1), 0);
@@ -12304,7 +12730,7 @@ async function discardArtifact(path2) {
   } catch {
   }
 }
-function asRecord2(value) {
+function asRecord3(value) {
   return typeof value === "object" && value !== null ? value : void 0;
 }
 function safeStringify(value) {
@@ -12357,6 +12783,8 @@ init_utils();
 // packages/coding-agent/src/humain/mcp-adapter/vendor/host-html-template.ts
 var DEFAULT_APP_BRIDGE_MODULE_URL = "/app-bridge.bundle.js";
 var APP_SANDBOX = "allow-scripts allow-forms allow-modals allow-popups allow-downloads";
+var APP_PROXY_SANDBOX = `${APP_SANDBOX} allow-same-origin`;
+var APP_INNER_SANDBOX = APP_PROXY_SANDBOX;
 function buildHostHtmlTemplate(input) {
   const hostContext = input.hostContext ?? {};
   const sessionToken = safeInlineJSON(input.sessionToken);
@@ -12369,6 +12797,9 @@ function buildHostHtmlTemplate(input) {
   const requireToolConsent = safeInlineJSON(input.requireToolConsent);
   const cacheToolConsent = safeInlineJSON(input.cacheToolConsent);
   const moduleUrl = safeInlineJSON(input.appBridgeModuleUrl ?? DEFAULT_APP_BRIDGE_MODULE_URL);
+  const sandboxProxyUrl = safeInlineJSON(input.sandboxProxyUrl);
+  const resourceCsp = safeInlineJSON(input.resource.meta.csp);
+  const resourcePermissions = safeInlineJSON(input.resource.meta.permissions);
   return `<!doctype html>
 <html lang="en">
 <head>
@@ -12449,7 +12880,7 @@ function buildHostHtmlTemplate(input) {
     </div>
   </header>
   <main>
-    <iframe id="mcp-app" sandbox="${APP_SANDBOX}" referrerpolicy="no-referrer"></iframe>
+    <iframe id="mcp-app" sandbox="${APP_PROXY_SANDBOX}" referrerpolicy="no-referrer"></iframe>
   </main>
   <div class="overlay" id="error-overlay">
     <div class="panel">
@@ -12475,6 +12906,10 @@ function buildHostHtmlTemplate(input) {
     const ALLOW_ATTRIBUTE = ${allowAttribute};
     const REQUIRE_TOOL_CONSENT = ${requireToolConsent};
     const CACHE_TOOL_CONSENT = ${cacheToolConsent};
+    const SANDBOX_PROXY_URL = ${sandboxProxyUrl};
+    const RESOURCE_CSP = ${resourceCsp};
+    const RESOURCE_PERMISSIONS = ${resourcePermissions};
+    const INNER_SANDBOX = ${safeInlineJSON(APP_INNER_SANDBOX)};
     const STREAM_CONTEXT_KEY = "pi-mcp-adapter/stream";
     const STREAM_PATCH_METHOD = "notifications/pi-mcp-adapter/ui-result-patch";
 
@@ -12485,6 +12920,7 @@ function buildHostHtmlTemplate(input) {
     const errorOverlay = document.getElementById("error-overlay");
     const completionOverlay = document.getElementById("completion-overlay");
     const errorMessage = document.getElementById("error-message");
+    const sandboxProxyOrigin = new URL(SANDBOX_PROXY_URL).origin;
 
     document.getElementById("server-name").textContent = SERVER_NAME;
     document.getElementById("tool-name").textContent = TOOL_NAME;
@@ -12542,10 +12978,41 @@ function buildHostHtmlTemplate(input) {
     const bridge = new AppBridge(
       null,
       { name: "pi", version: "1.0.0" },
-      { serverTools: {}, openLinks: {}, logging: {}, updateModelContext: {}, message: {} },
+      {
+        serverTools: {},
+        openLinks: {},
+        logging: {},
+        updateModelContext: {},
+        message: {},
+        sandbox: {
+          ...(RESOURCE_CSP ? { csp: RESOURCE_CSP } : {}),
+          ...(RESOURCE_PERMISSIONS ? { permissions: RESOURCE_PERMISSIONS } : {}),
+        },
+      },
       { hostContext: HOST_CONTEXT }
     );
 
+    let sandboxResourceSent = false;
+    bridge.onsandboxready = async () => {
+      if (sandboxResourceSent) return;
+      sandboxResourceSent = true;
+      try {
+        const response = await fetch("/ui-app?resource=" + encodeURIComponent(UI_RESOURCE_TOKEN), {
+          headers: { Accept: "text/html" },
+        });
+        if (!response.ok) throw new Error("UI resource request failed: HTTP " + response.status);
+        const html = await response.text();
+        await bridge.sendSandboxResourceReady({
+          html,
+          sandbox: INNER_SANDBOX,
+          ...(RESOURCE_CSP ? { csp: RESOURCE_CSP } : {}),
+          ...(RESOURCE_PERMISSIONS ? { permissions: RESOURCE_PERMISSIONS } : {}),
+        });
+      } catch (error) {
+        showError("Failed to load MCP App resource: " + String(error));
+      }
+    };
+
     bridge.oncalltool = async (params) => {
       if (!consentGranted) {
         const accepted = window.confirm("Allow this UI to call server tools for this session?");
@@ -12577,7 +13044,7 @@ function buildHostHtmlTemplate(input) {
     // Also listen for raw postMessage events with custom types (notify, prompt, intent, etc.)
     // These bypass the AppBridge protocol but are used by some MCP UI implementations
     window.addEventListener("message", async (event) => {
-      if (event.source !== iframe.contentWindow) return;
+      if (event.source !== iframe.contentWindow || event.origin !== sandboxProxyOrigin) return;
       const data = event.data;
       if (!data || typeof data !== "object") return;
 
@@ -12641,6 +13108,12 @@ function buildHostHtmlTemplate(input) {
     }
 
     // Connect bridge BEFORE loading iframe to ensure we're listening when the app sends ui/initialize
+    const sandboxMessageGuard = (event) => {
+      if (event.source === iframe.contentWindow && event.origin !== sandboxProxyOrigin) {
+        event.stopImmediatePropagation();
+      }
+    };
+    window.addEventListener("message", sandboxMessageGuard, true);
     try {
       const transport = new PostMessageTransport(iframe.contentWindow, iframe.contentWindow);
       await bridge.connect(transport);
@@ -12652,7 +13125,7 @@ function buildHostHtmlTemplate(input) {
     const iframeLoaded = new Promise((resolve) => {
       iframe.onload = resolve;
     });
-    iframe.src = "/ui-app?resource=" + encodeURIComponent(UI_RESOURCE_TOKEN);
+    iframe.src = SANDBOX_PROXY_URL;
     await iframeLoaded;
 
     const eventSource = new EventSource("/events?session=" + encodeURIComponent(SESSION_TOKEN));
@@ -12677,6 +13150,9 @@ function buildHostHtmlTemplate(input) {
         showError("Failed to forward cancellation: " + String(error));
       }
     });
+    eventSource.addEventListener("resource-updated", () => {
+      setStatus("Resource updated on the server. Reopen this UI to load the latest version.");
+    });
     eventSource.addEventListener("result-patch", async (event) => {
       try {
         await bridge.notification({
@@ -12764,12 +13240,205 @@ function sanitizeCspDomains(domains) {
   ))];
 }
 function safeInlineJSON(value) {
-  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+  const json = JSON.stringify(value);
+  if (json === void 0) return "undefined";
+  return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
 }
 function escapeHtml2(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 
+// packages/coding-agent/src/humain/mcp-adapter/vendor/sandbox-proxy-template.ts
+var SANDBOX_PROXY_SANDBOX = "allow-scripts allow-forms allow-modals allow-popups allow-downloads allow-same-origin";
+var SANDBOX_INNER_SANDBOX = SANDBOX_PROXY_SANDBOX;
+var SANDBOX_PROXY_PATH = "/sandbox";
+function buildSandboxProxyHtml(input) {
+  const parentOrigin = safeInlineJSON2(input.parentOrigin);
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>MCP App Sandbox</title>
+  <style>
+    html, body { margin: 0; padding: 0; width: 100%; height: 100%; overflow: hidden; background: transparent; }
+    iframe { display: block; width: 100%; height: 100%; border: 0; }
+  </style>
+</head>
+<body>
+  <iframe id="mcp-app" title="MCP App" sandbox="${SANDBOX_INNER_SANDBOX}" referrerpolicy="no-referrer"></iframe>
+  <script>
+    const EXPECTED_PARENT_ORIGIN = ${parentOrigin};
+    const SANDBOX_PROXY_READY_METHOD = "ui/notifications/sandbox-proxy-ready";
+    const SANDBOX_RESOURCE_READY_METHOD = "ui/notifications/sandbox-resource-ready";
+    const INNER_SANDBOX = ${safeInlineJSON2(SANDBOX_INNER_SANDBOX)};
+    const MAX_PENDING_MESSAGES = 64;
+    const innerFrame = document.getElementById("mcp-app");
+    const pendingToInner = [];
+    let innerReady = false;
+
+    const isObject = (value) => value !== null && typeof value === "object";
+    const isMessageFromParent = (event) =>
+      event.source === window.parent && event.origin === EXPECTED_PARENT_ORIGIN;
+    const isMessageFromInner = (event) =>
+      event.source === innerFrame.contentWindow && event.origin === window.location.origin;
+
+    const postToParent = (data) => {
+      window.parent.postMessage(data, EXPECTED_PARENT_ORIGIN);
+    };
+
+    const postToInner = (data) => {
+      if (!innerReady || !innerFrame.contentWindow) {
+        if (pendingToInner.length < MAX_PENDING_MESSAGES) pendingToInner.push(data);
+        return;
+      }
+      innerFrame.contentWindow.postMessage(data, window.location.origin);
+    };
+
+    const flushPendingMessages = () => {
+      if (!innerFrame.contentWindow) return;
+      innerReady = true;
+      for (const data of pendingToInner.splice(0)) {
+        innerFrame.contentWindow.postMessage(data, window.location.origin);
+      }
+    };
+
+    const sanitizeDomains = (domains) => {
+      if (!Array.isArray(domains)) return [];
+      return [...new Set(domains.filter((domain) =>
+        typeof domain === "string" &&
+        domain.length > 0 &&
+        /^[\\x21-\\x7E]+$/.test(domain) &&
+        !/[;'"]/.test(domain),
+      ))];
+    };
+
+    const toDirective = (name, trustedSources, domains) =>
+      name + " " + [...new Set([...trustedSources, ...domains])].join(" ");
+
+    const buildResourceCsp = (csp) => {
+      const resourceDomains = sanitizeDomains(csp?.resourceDomains);
+      const connectDomains = sanitizeDomains(csp?.connectDomains);
+      const frameDomains = sanitizeDomains(csp?.frameDomains);
+      const baseUriDomains = sanitizeDomains(csp?.baseUriDomains);
+      return [
+        "default-src 'none'",
+        "sandbox " + INNER_SANDBOX,
+        toDirective("script-src", ["'self'", "'unsafe-inline'"], resourceDomains),
+        toDirective("style-src", ["'self'", "'unsafe-inline'"], resourceDomains),
+        toDirective("font-src", ["'self'"], resourceDomains),
+        toDirective("img-src", ["'self'", "data:"], resourceDomains),
+        toDirective("media-src", ["'self'", "data:"], resourceDomains),
+        connectDomains.length > 0 ? "connect-src " + connectDomains.join(" ") : "connect-src 'none'",
+        frameDomains.length > 0 ? "frame-src " + frameDomains.join(" ") : "frame-src 'none'",
+        "worker-src 'none'",
+        "object-src 'none'",
+        baseUriDomains.length > 0 ? "base-uri " + baseUriDomains.join(" ") : "base-uri 'self'",
+      ].join("; ");
+    };
+
+    const escapeAttribute = (value) => value
+      .replace(/&/g, "&amp;")
+      .replace(/"/g, "&quot;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;");
+
+    const injectCsp = (html, csp) => {
+      const meta = '<meta http-equiv="Content-Security-Policy" content="' + escapeAttribute(csp) + '">';
+      const head = html.match(/<head(?:\\s[^>]*)?>/i);
+      if (head && head.index !== undefined) {
+        const end = head.index + head[0].length;
+        return html.slice(0, end) + meta + html.slice(end);
+      }
+      return meta + html;
+    };
+
+    const safeSandbox = (requested) => {
+      const requestedTokens = typeof requested === "string" ? requested.split(/\\s+/) : [];
+      const allowedTokens = new Set(INNER_SANDBOX.split(" "));
+      const tokens = requestedTokens.filter((token) => allowedTokens.has(token));
+      // Provider HTML needs both script execution and a real proxy-origin
+      // storage context. Never accept popup escape or top-navigation tokens.
+      return [...new Set([
+        "allow-scripts",
+        "allow-same-origin",
+        ...tokens,
+      ])].filter((token) => allowedTokens.has(token)).join(" ");
+    };
+
+    const buildAllowAttribute = (permissions) => {
+      if (!isObject(permissions) || Array.isArray(permissions)) return "";
+      const allowed = [];
+      if (permissions.camera) allowed.push("camera");
+      if (permissions.microphone) allowed.push("microphone");
+      if (permissions.geolocation) allowed.push("geolocation");
+      if (permissions.clipboardWrite) allowed.push("clipboard-write");
+      return allowed.join("; ");
+    };
+
+    const loadResource = (params) => {
+      if (!isObject(params) || typeof params.html !== "string" || !innerFrame.contentDocument) return;
+      innerFrame.setAttribute("sandbox", safeSandbox(params.sandbox));
+      const allow = buildAllowAttribute(params.permissions);
+      if (allow) innerFrame.setAttribute("allow", allow);
+      else innerFrame.removeAttribute("allow");
+      innerReady = false;
+      const document = innerFrame.contentDocument;
+      document.open();
+      document.write(injectCsp(params.html, buildResourceCsp(params.csp)));
+      document.close();
+      flushPendingMessages();
+    };
+
+    window.addEventListener("message", (event) => {
+      if (isMessageFromParent(event)) {
+        const data = event.data;
+        if (!isObject(data)) return;
+        if (data.method === SANDBOX_RESOURCE_READY_METHOD) {
+          loadResource(data.params);
+          return;
+        }
+        if (data.method === SANDBOX_PROXY_READY_METHOD) return;
+        if (typeof data.method === "string" && data.method.startsWith("ui/notifications/sandbox-")) return;
+        postToInner(data);
+        return;
+      }
+
+      if (!isMessageFromInner(event)) return;
+      const data = event.data;
+      if (!isObject(data)) return;
+      if (typeof data.method === "string" && data.method.startsWith("ui/notifications/sandbox-")) return;
+      postToParent(data);
+    });
+
+    postToParent({
+      jsonrpc: "2.0",
+      method: SANDBOX_PROXY_READY_METHOD,
+      params: {},
+    });
+  </script>
+</body>
+</html>`;
+}
+function buildSandboxProxyCsp() {
+  return [
+    "default-src 'none'",
+    "script-src 'unsafe-inline'",
+    "style-src 'unsafe-inline'",
+    "frame-src 'self'",
+    "connect-src 'none'",
+    "worker-src 'none'",
+    "object-src 'none'",
+    "base-uri 'none'",
+    `sandbox ${SANDBOX_PROXY_SANDBOX}`
+  ].join("; ");
+}
+function safeInlineJSON2(value) {
+  const json = JSON.stringify(value);
+  if (json === void 0) return "undefined";
+  return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+
 // packages/coding-agent/src/humain/mcp-adapter/vendor/tool-approval.ts
 import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
 init_types();
@@ -12939,6 +13608,11 @@ async function startUiServer(options) {
   const eventLog = [];
   let latestCheckpointEventId;
   let streamSummary;
+  let server2 = null;
+  let sandboxProxyServer = null;
+  let sandboxProxyUrl = null;
+  let closeTimer = null;
+  let listenersClosed = false;
   const sessionMessages = {
     prompts: [],
     notifications: [],
@@ -13086,6 +13760,32 @@ data: ${JSON.stringify(payload)}
     clearInterval(watchdog);
     watchdog = null;
   };
+  const closeListeners = () => {
+    if (listenersClosed) return;
+    listenersClosed = true;
+    stopWatchdog();
+    if (closeTimer) {
+      clearTimeout(closeTimer);
+      closeTimer = null;
+    }
+    try {
+      server2?.close();
+    } catch {
+    }
+    try {
+      sandboxProxyServer?.close();
+    } catch {
+    }
+    closeSse();
+  };
+  const scheduleListenerClose = () => {
+    if (closeTimer || listenersClosed) return;
+    closeTimer = setTimeout(() => {
+      closeTimer = null;
+      closeListeners();
+    }, 20);
+    closeTimer.unref();
+  };
   const markCompleted = (reason) => {
     if (completed) return;
     log.debug("Session completed", { reason });
@@ -13093,8 +13793,9 @@ data: ${JSON.stringify(payload)}
     completed = true;
     stopWatchdog();
     options.onComplete?.(reason);
+    scheduleListenerClose();
   };
-  const server2 = http.createServer(async (req, res) => {
+  const hostServer = http.createServer(async (req, res) => {
     try {
       const method = req.method || "GET";
       const hostHeader = req.headers.host;
@@ -13118,6 +13819,10 @@ data: ${JSON.stringify(payload)}
         }
         if (!validateTokenQuery(url, sessionToken, res)) return;
         touchHeartbeat();
+        if (!sandboxProxyUrl) {
+          sendText(res, 503, "Sandbox proxy is not ready");
+          return;
+        }
         const html = buildHostHtmlTemplate({
           sessionToken,
           uiResourceToken,
@@ -13128,7 +13833,8 @@ data: ${JSON.stringify(payload)}
           allowAttribute: buildAllowAttribute(options.resource.meta.permissions),
           requireToolConsent: options.consentManager.requiresPrompt(options.serverName),
           cacheToolConsent: options.consentManager.shouldCacheConsent(),
-          hostContext
+          hostContext,
+          sandboxProxyUrl
         });
         res.writeHead(200, {
           "Content-Type": "text/html; charset=utf-8",
@@ -13292,8 +13998,14 @@ data: ${JSON.stringify(payload)}
               ...options.onNeedsAuth ? { onNeedsAuth: options.onNeedsAuth } : {}
             },
             options.serverName,
-            (conn) => conn.client.callTool(callArgs, options.manager.getRequestOptions?.(options.serverName))
-          ) : await connection.client.callTool(callArgs, options.manager.getRequestOptions?.(options.serverName));
+            async (conn) => {
+              await options.manager.ensureListen?.(options.serverName, conn);
+              return conn.client.callTool(callArgs, options.manager.getRequestOptions?.(options.serverName));
+            }
+          ) : await (async () => {
+            await options.manager.ensureListen?.(options.serverName, connection);
+            return connection.client.callTool(callArgs, options.manager.getRequestOptions?.(options.serverName));
+          })();
           sendJson(res, 200, { ok: true, result });
         } finally {
           options.manager.decrementInFlight(options.serverName);
@@ -13393,13 +14105,6 @@ data: ${JSON.stringify(payload)}
         const reason = typeof params.reason === "string" ? params.reason : "done";
         markCompleted(reason);
         sendJson(res, 200, { ok: true, result: {} });
-        setTimeout(() => {
-          try {
-            server2.close();
-          } catch {
-          }
-          closeSse();
-        }, 20).unref();
         return;
       }
       sendJson(res, 404, { ok: false, error: "Not found" });
@@ -13418,6 +14123,7 @@ data: ${JSON.stringify(payload)}
       sendJson(res, status, { ok: false, error: wrapped.message });
     }
   });
+  server2 = hostServer;
   if (options.initialResultPromise) {
     options.initialResultPromise.then(
       (result) => pushEvent("tool-result", result),
@@ -13431,22 +14137,78 @@ data: ${JSON.stringify(payload)}
     if (completed) return;
     if (Date.now() - lastHeartbeatAt <= ABANDONED_GRACE_MS) return;
     markCompleted("stale");
-    try {
-      server2.close();
-    } catch {
-    }
-    closeSse();
   }, WATCHDOG_INTERVAL_MS);
   watchdog.unref();
   return new Promise((resolve7, reject) => {
     const candidates = resolvePortCandidates(options.port);
     let candidateIndex = 0;
+    const startSandboxProxy = (parentOrigin) => {
+      const proxy = http.createServer((req, res) => {
+        try {
+          const method = req.method || "GET";
+          const hostHeader = req.headers.host;
+          const url = new URL(req.url || "/", `http://${hostHeader || "127.0.0.1"}`);
+          if (hostHeader !== void 0 && !isAllowedHost(url.hostname)) {
+            sendText(res, 403, "Invalid host");
+            return;
+          }
+          if (method === "HEAD" && url.pathname === SANDBOX_PROXY_PATH) {
+            res.writeHead(200, {
+              "Content-Type": "text/html; charset=utf-8",
+              "Cache-Control": "no-store",
+              "Content-Security-Policy": buildSandboxProxyCsp()
+            });
+            res.end();
+            return;
+          }
+          if (method === "GET" && url.pathname === SANDBOX_PROXY_PATH) {
+            res.writeHead(200, {
+              "Content-Type": "text/html; charset=utf-8",
+              "Cache-Control": "no-store",
+              "Content-Security-Policy": buildSandboxProxyCsp(),
+              "Referrer-Policy": "no-referrer",
+              "X-Content-Type-Options": "nosniff"
+            });
+            res.end(buildSandboxProxyHtml({ parentOrigin }));
+            return;
+          }
+          sendJson(res, 404, { ok: false, error: "Not found" });
+        } catch (error) {
+          sendJson(res, 500, { ok: false, error: error instanceof Error ? error.message : String(error) });
+        }
+      });
+      sandboxProxyServer = proxy;
+      return new Promise((resolveProxy, rejectProxy) => {
+        const onError2 = (error) => {
+          proxy.off("listening", onListening2);
+          rejectProxy(error);
+        };
+        const onListening2 = () => {
+          proxy.off("error", onError2);
+          const address = proxy.address();
+          if (!address || typeof address === "string") {
+            rejectProxy(new ServerError("invalid sandbox proxy address"));
+            return;
+          }
+          resolveProxy(address.port);
+        };
+        proxy.once("error", onError2);
+        proxy.listen(0, "127.0.0.1", onListening2);
+      });
+    };
     const listen = () => {
-      server2.once("error", onError);
-      server2.listen(candidates[candidateIndex], "127.0.0.1", onListening);
+      const candidate = candidates[candidateIndex];
+      if (candidate === void 0) {
+        const error = new ServerError("no UI server port candidates available");
+        closeListeners();
+        reject(error);
+        return;
+      }
+      hostServer.once("error", onError);
+      hostServer.listen(candidate, "127.0.0.1", onListening);
     };
     const onError = (error) => {
-      server2.off("listening", onListening);
+      hostServer.off("listening", onListening);
       if (error.code === "EADDRINUSE" && candidateIndex < candidates.length - 1) {
         candidateIndex += 1;
         listen();
@@ -13454,56 +14216,73 @@ data: ${JSON.stringify(payload)}
       }
       log.error("Failed to start server", error);
       const port = candidates[candidateIndex];
+      closeListeners();
       reject(new ServerError(error.message, {
         ...port !== void 0 ? { port } : {},
         cause: error
       }));
     };
     const onListening = () => {
-      server2.off("error", onError);
-      const address = server2.address();
+      hostServer.off("error", onError);
+      const address = hostServer.address();
       if (!address || typeof address === "string") {
         const err = new ServerError("invalid address");
         log.error("Invalid server address", err);
+        closeListeners();
         reject(err);
         return;
       }
-      log.debug("Server started", { port: address.port });
-      rememberMoshiDiscoveryPort(address.port);
-      const handle = {
-        url: `http://localhost:${address.port}/?session=${sessionToken}`,
-        port: address.port,
-        sessionToken,
-        serverName: options.serverName,
-        toolName: options.toolName,
-        close: (reason) => {
-          markCompleted(reason ?? "closed");
-          try {
-            server2.close();
-          } catch {
-          }
-          closeSse();
-        },
-        sendToolInput: (args) => {
-          pushEvent("tool-input", { arguments: args });
-        },
-        sendToolResult: (result) => {
-          pushEvent("tool-result", result);
-        },
-        sendResultPatch: (result) => {
-          pushEvent("result-patch", result);
-        },
-        sendToolCancelled: (reason) => {
-          pushEvent("tool-cancelled", { reason });
-        },
-        sendHostContext: (context) => {
-          Object.assign(hostContext, context);
-          pushEvent("host-context", context);
-        },
-        getSessionMessages: () => ({ ...sessionMessages }),
-        getStreamSummary: () => streamSummary ? { ...streamSummary, phases: [...streamSummary.phases] } : void 0
-      };
-      resolve7(handle);
+      const parentOrigin = `http://localhost:${address.port}`;
+      void startSandboxProxy(parentOrigin).then((proxyPort) => {
+        if (completed || listenersClosed) {
+          closeListeners();
+          reject(new ServerError("UI session completed before sandbox proxy was ready"));
+          return;
+        }
+        sandboxProxyUrl = `http://localhost:${proxyPort}${SANDBOX_PROXY_PATH}`;
+        log.debug("Servers started", { port: address.port, proxyPort });
+        rememberMoshiDiscoveryPort(address.port);
+        const handle = {
+          url: `http://localhost:${address.port}/?session=${sessionToken}`,
+          port: address.port,
+          proxyUrl: sandboxProxyUrl,
+          proxyPort,
+          sessionToken,
+          serverName: options.serverName,
+          toolName: options.toolName,
+          close: (reason) => {
+            markCompleted(reason ?? "closed");
+            closeListeners();
+          },
+          sendToolInput: (args) => {
+            pushEvent("tool-input", { arguments: args });
+          },
+          sendToolResult: (result) => {
+            pushEvent("tool-result", result);
+          },
+          sendResultPatch: (result) => {
+            pushEvent("result-patch", result);
+          },
+          sendToolCancelled: (reason) => {
+            pushEvent("tool-cancelled", { reason });
+          },
+          sendResourceUpdated: (uri) => {
+            pushEvent("resource-updated", { uri });
+          },
+          sendHostContext: (context) => {
+            Object.assign(hostContext, context);
+            pushEvent("host-context", context);
+          },
+          getSessionMessages: () => ({ ...sessionMessages }),
+          getStreamSummary: () => streamSummary ? { ...streamSummary, phases: [...streamSummary.phases] } : void 0
+        };
+        resolve7(handle);
+      }).catch((error) => {
+        log.error("Failed to start sandbox proxy", error instanceof Error ? error : void 0);
+        closeListeners();
+        const wrapped = error instanceof ServerError ? error : new ServerError(error instanceof Error ? error.message : String(error), { cause: error });
+        reject(wrapped);
+      });
     };
     listen();
   });
@@ -13749,10 +14528,12 @@ function remoteAccessHint(opts) {
     lines.push(`Browser launch failed: ${opts.openError}`);
   }
   if (opts.moshi) {
-    lines.push("Moshi: tap the preview button in the terminal title bar and pick this MCP UI server.");
+    lines.push(
+      `Moshi: tap the preview button in the terminal title bar and pick this MCP UI server (it must reach ports ${opts.port} and ${opts.proxyPort}).`
+    );
   }
   lines.push(
-    `SSH: run \`ssh -L ${opts.port}:127.0.0.1:${opts.port} <this-host>\` on your local machine, then open the URL above.`,
+    `SSH: run \`ssh -L ${opts.port}:127.0.0.1:${opts.port} -L ${opts.proxyPort}:127.0.0.1:${opts.proxyPort} <this-host>\` on your local machine, then open the URL above.`,
     "mosh can't forward ports - run that ssh command in a separate terminal."
   );
   return lines.join("\n");
@@ -13773,7 +14554,7 @@ async function maybeStartUiSession(state, request) {
       const streamToken2 = streamMode2 ? randomUUID4() : void 0;
       let active2 = true;
       let nextStreamSequence2 = 0;
-      const cleanupStreamListener2 = () => {
+      const cleanupStreamListener = () => {
         if (streamToken2) {
           state.manager.removeUiStreamListener(streamToken2);
         }
@@ -13827,7 +14608,7 @@ async function maybeStartUiSession(state, request) {
         },
         close: () => {
           active2 = false;
-          cleanupStreamListener2();
+          cleanupStreamListener();
         }
       };
     }
@@ -13859,10 +14640,12 @@ async function maybeStartUiSession(state, request) {
     let active = true;
     let nextStreamSequence = 0;
     let handle;
-    const cleanupStreamListener = () => {
+    const resourceListenerToken = randomUUID4();
+    const cleanupListeners = () => {
       if (streamToken) {
         state.manager.removeUiStreamListener(streamToken);
       }
+      state.manager.removeResourceUpdatedListener?.(resourceListenerToken);
     };
     handle = await startUiServer({
       serverName: request.serverName,
@@ -13935,7 +14718,7 @@ ${update.summary}` }],
       },
       onComplete: (reason) => {
         active = false;
-        cleanupStreamListener();
+        cleanupListeners();
         if (state.uiServer === handle) {
           const messages = handle.getSessionMessages();
           const stream = handle.getStreamSummary();
@@ -13982,6 +14765,15 @@ ${update.summary}` }],
         handle.sendResultPatch(withStreamEnvelope(notification.result, streamId, nextStreamSequence));
       });
     }
+    state.manager.registerResourceUpdatedListener?.(
+      resourceListenerToken,
+      request.serverName,
+      request.uiResourceUri,
+      (_serverName, uri) => {
+        if (!active || state.uiServer !== handle) return;
+        handle.sendResourceUpdated(uri);
+      }
+    );
     state.uiServer = handle;
     const viewerPref = process.env.MCP_UI_VIEWER?.toLowerCase();
     const uiSuppressed = viewerPref === "none" || viewerPref === "off" || viewerPref === "disabled";
@@ -13991,7 +14783,11 @@ ${update.summary}` }],
     if (uiSuppressed) {
       viewer = "suppressed";
       windowOpen = false;
-      state.ui?.notify(`MCP UI window suppressed (MCP_UI_VIEWER=${viewerPref}). Open manually: ${handle.url}`, "info");
+      state.ui?.notify(
+        `MCP UI window suppressed (MCP_UI_VIEWER=${viewerPref}). Open manually: ${handle.url}
+If this session is remote, run ssh -L ${handle.port}:127.0.0.1:${handle.port} -L ${handle.proxyPort}:127.0.0.1:${handle.proxyPort} <this-host> first.`,
+        "info"
+      );
       log.info("Suppressing MCP UI window (MCP_UI_VIEWER=" + viewerPref + ")", { url: handle.url });
     } else {
       const remoteLikely = remoteByEnv || await hasActiveRemoteLogin();
@@ -13999,6 +14795,7 @@ ${update.summary}` }],
         state.ui?.notify(remoteAccessHint({
           url: handle.url,
           port: handle.port,
+          proxyPort: handle.proxyPort,
           moshi: await probeMoshiGateway(),
           openError,
           openedOnHost
@@ -14075,12 +14872,12 @@ ${update.summary}` }],
       },
       close: (reason) => {
         active = false;
-        cleanupStreamListener();
+        cleanupListeners();
         handle.close(reason);
       }
     };
   } catch (error) {
-    if (error instanceof UrlElicitationRequiredError2 || isAbortError(error, runtimeSignal)) throw error;
+    if (error instanceof UrlElicitationRequiredError2 || error instanceof InputRequiredNeedsUiError || isAbortError(error, runtimeSignal)) throw error;
     const message = error instanceof Error ? error.message : String(error);
     log.error("Failed to start UI session", error instanceof Error ? error : void 0);
     state.ui?.notify(
@@ -14475,7 +15272,13 @@ function createDirectToolExecutor(getState, getInitPromise, spec) {
             onNeedsAuth: recoverAuthConnection
           },
           spec.serverName,
-          (conn) => conn.client.readResource({ uri: spec.resourceUri }, requestOptions)
+          async (conn) => {
+            const refreshRead = await state.manager.prepareResourceUse?.(spec.serverName, spec.resourceUri, conn);
+            return conn.client.readResource(
+              { uri: spec.resourceUri },
+              refreshRead ? { ...requestOptions, cacheMode: "refresh" } : requestOptions
+            );
+          }
         );
         const content2 = transformMcpResourceContents(result2.contents ?? [], state.owner?.signal);
         const guarded2 = await guardMcpOutput(content2.length > 0 ? content2 : [{ type: "text", text: "(empty resource)" }], {
@@ -14505,11 +15308,14 @@ function createDirectToolExecutor(getState, getInitPromise, spec) {
           onNeedsAuth: recoverAuthConnection
         },
         spec.serverName,
-        (conn) => abortable(conn.client.callTool({
-          name: spec.originalName,
-          arguments: normalizedParams,
-          _meta: uiSession?.requestMeta
-        }, requestOptions), ownedSignal)
+        async (conn) => {
+          await state.manager.ensureListen?.(spec.serverName, conn);
+          return abortable(conn.client.callTool({
+            name: spec.originalName,
+            arguments: normalizedParams,
+            _meta: uiSession?.requestMeta
+          }, requestOptions), ownedSignal);
+        }
       );
       uiSession?.sendToolResult(result);
       if (result.isError) {
@@ -14581,6 +15387,14 @@ ${uiSummary.message}`,
           details: { error: "url_elicitation_required", server: spec.serverName, action }
         };
       }
+      const inputRequired = getInputRequiredNeedsUiDetails(error, spec.resourceUri ? { server: spec.serverName, resourceUri: spec.resourceUri } : { server: spec.serverName, tool: spec.originalName });
+      if (inputRequired) {
+        uiSession?.sendToolCancelled(inputRequired.message);
+        return {
+          content: [{ type: "text", text: inputRequired.message }],
+          details: { ...inputRequired }
+        };
+      }
       const message = error instanceof Error ? error.message : String(error);
       const aborted = isAbortError(error, ownedSignal);
       if (!aborted) {
@@ -15451,7 +16265,16 @@ function executeStatus(state) {
       status = "cached";
     }
     const toolCount = status === "failed" ? 0 : metadata?.length ?? 0;
-    servers.push({ name, status, toolCount, failedAgo, ...disabled ? { disabled: true } : {} });
+    const listenState = connection?.status === "connected" ? connection.listenState : "disconnected";
+    servers.push({
+      name,
+      status,
+      listenState,
+      ...connection?.status === "connected" && connection.listenCatalogStale ? { catalogStale: true } : {},
+      toolCount,
+      failedAgo,
+      ...disabled ? { disabled: true } : {}
+    });
   }
   const disabledCount = servers.filter((s) => s.disabled).length;
   const enabledServers = servers.filter((s) => !s.disabled);
@@ -15467,7 +16290,8 @@ function executeStatus(state) {
       continue;
     }
     if (server2.status === "connected") {
-      text += `\u2713 ${server2.name} (${server2.toolCount} tools)
+      const listen = server2.listenState === "active" ? server2.catalogStale ? ", listen active, catalog may be stale" : ", listen active" : server2.listenState === "dropped" ? ", catalog may be stale; will reconcile on next keep-alive or tool use" : server2.listenState === "re-establishing" ? ", re-establishing listen" : server2.listenState === "legacy" ? ", legacy notification path" : ", not listening for catalog updates";
+      text += `\u2713 ${server2.name} (${server2.toolCount} tools${listen})
 `;
       continue;
     }
@@ -15477,7 +16301,7 @@ function executeStatus(state) {
       continue;
     }
     if (server2.status === "cached") {
-      text += `\u25CB ${server2.name} (${server2.toolCount} tools, cached)
+      text += `\u25CB ${server2.name} (${server2.toolCount} tools, cached; not listening)
 `;
       continue;
     }
@@ -15486,16 +16310,20 @@ function executeStatus(state) {
 `;
       continue;
     }
-    text += `\u25CB ${server2.name} (not connected)
+    text += `\u25CB ${server2.name} (not listening; disconnected)
 `;
   }
+  const directToolsFrozen = state.config.settings?.freezeDirectTools === true;
+  if (directToolsFrozen) {
+    text += "\nDirect tools frozen; active registrations may differ from current metadata.\n";
+  }
   if (servers.length > 0) {
     text += `
 mcp({ server: "name" }) to list tools, mcp({ search: "..." }) to search`;
   }
   return {
     content: [{ type: "text", text: text.trim() }],
-    details: { mode: "status", servers, totalTools, connectedCount, disabledCount }
+    details: { mode: "status", servers, totalTools, connectedCount, disabledCount, directToolsFrozen }
   };
 }
 async function executeAuthStart(state, serverName, signal) {
@@ -15810,7 +16638,14 @@ Use mcp({ instructions: "${server2}" }) for the full text.`;
       details: { mode: "list", server: server2, tools: [], count: 0, error: "not_connected", hasInstructions: Boolean(instructions) }
     };
   }
-  const cachedNote = connection?.status === "connected" ? "" : " (not connected, cached)";
+  let cachedNote = "";
+  if (connection?.status !== "connected") {
+    if (connection?.status === "needs-auth") {
+      cachedNote = ` (needs auth \u2014 run mcp({ action: "auth-start", server: "${server2}" }))`;
+    } else {
+      cachedNote = ` (lazy: tools from cache, not connected yet \u2014 mcp({ connect: "${server2}" }) to connect)`;
+    }
+  }
   let text = `${server2} (${toolNames.length} tools${cachedNote}):
 
 `;
@@ -16301,7 +17136,13 @@ async function executeCall(state, toolName, args, serverOverride, getPiTools, si
           onNeedsAuth: recoverAuthConnection
         },
         serverName,
-        (conn) => conn.client.readResource({ uri: toolMeta.resourceUri }, requestOptions)
+        async (conn) => {
+          const refreshRead = await state.manager.prepareResourceUse?.(serverName, toolMeta.resourceUri, conn);
+          return conn.client.readResource(
+            { uri: toolMeta.resourceUri },
+            refreshRead ? { ...requestOptions, cacheMode: "refresh" } : requestOptions
+          );
+        }
       );
       const content2 = transformMcpResourceContents(result2.contents ?? [], state.owner?.signal);
       const guarded2 = await guardMcpOutput(content2.length > 0 ? content2 : [{ type: "text", text: "(empty resource)" }], outputGuardOptions);
@@ -16327,11 +17168,14 @@ async function executeCall(state, toolName, args, serverOverride, getPiTools, si
         onNeedsAuth: recoverAuthConnection
       },
       serverName,
-      (conn) => abortable(conn.client.callTool({
-        name: toolMeta.originalName,
-        arguments: normalizedArgs,
-        _meta: uiSession?.requestMeta
-      }, requestOptions), ownedSignal)
+      async (conn) => {
+        await state.manager.ensureListen?.(serverName, conn);
+        return abortable(conn.client.callTool({
+          name: toolMeta.originalName,
+          arguments: normalizedArgs,
+          _meta: uiSession?.requestMeta
+        }, requestOptions), ownedSignal);
+      }
     );
     if (toolMeta.uiResourceUri) {
       uiSession?.sendToolResult(result);
@@ -16406,6 +17250,14 @@ ${formatSchema(toolMeta.inputSchema)}` : "";
         details: { mode: "call", error: "url_elicitation_required", ...callIdentity, action }
       };
     }
+    const inputRequired = getInputRequiredNeedsUiDetails(error, callIdentity);
+    if (inputRequired) {
+      uiSession?.sendToolCancelled(inputRequired.message);
+      return {
+        content: [{ type: "text", text: inputRequired.message }],
+        details: { mode: "call", ...inputRequired }
+      };
+    }
     const message = error instanceof Error ? error.message : String(error);
     uiSession?.sendToolCancelled(message);
     const schemaText = toolMeta.inputSchema ? `
@@ -16748,7 +17600,13 @@ function createMcpToolResultRenderer(renderOptions) {
 function toolErrorOverride(details) {
   if (details && typeof details === "object" && "error" in details) {
     const code = details.error;
-    if (code === "tool_error" || code === "call_failed") {
+    if (code === "tool_error" || code === "call_failed" || code === INPUT_REQUIRED_NEEDS_UI) {
+      return { isError: true };
+    }
+  }
+  if (details && typeof details === "object" && details.mode === "script") {
+    const calls = details.calls;
+    if (Array.isArray(calls) && calls.some((call) => !!call && typeof call === "object" && call.error === INPUT_REQUIRED_NEEDS_UI)) {
       return { isError: true };
     }
   }
@@ -17860,7 +18718,7 @@ function installMcpAdapter(pi, options) {
       initPromise = null;
       if (earlyConfig.settings?.freezeDirectTools === true) {
         directToolsFrozen = true;
-        logger.info(`MCP: direct tools frozen after initial sync \u2014 reconnects won't rebuild the system prompt; use mcp({ connect: "server" }) to rediscover`);
+        logger.info("MCP: direct tools frozen after initial sync \u2014 metadata can refresh without rebuilding the active tool surface");
       }
     }).catch(async (err) => {
       if (!owner.isActive() || generation !== lifecycleGeneration) {
@@ -18053,7 +18911,6 @@ function installMcpAdapter(pi, options) {
         case "reconnect":
           commandOwner?.throwIfInactive();
           await reconnectServers(state, commandCtx, targetServer);
-          if (directToolsFrozen) syncToolSurface(commandCtx);
           break;
         case "tools":
           await showTools(state, commandCtx);
@@ -18364,7 +19221,7 @@ function installMcpAdapter(pi, options) {
         }
         if (params.connect) {
           const result = await executeConnect(state, params.connect, signal);
-          syncToolSurface(_ctx);
+          if (!directToolsFrozen) syncToolSurface(_ctx);
           return result;
         }
         if (params.describe) {