@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-mcp-adapter/proxy-modes.js

@@ -6,20 +6,23 @@ import { abortable, throwIfAborted } from "./abort.js";
 import { combineAbortSignals, isAbortError } from "./runtime-owner.js";
 import { buildToolMetadata, getToolNames, formatSchema } from "./tool-metadata.js";
 import { renderTsShape } from "./ts-shape.js";
+import { getObservedOutput, observedOutputRecorder, renderOutputShape } from "./output-shape.js";
 import { reconstructPromptMetadata } from "./metadata-cache.js";
 import { resolveMcpResultContent, transformMcpResourceContents } from "./tool-registrar.js";
-import { guardMcpOutput, guardedMcpDetails, resolveMcpOutputGuardOptions } from "./mcp-output-guard.js";
+import { guardMcpOutput, guardedMcpDetails, resolveMcpOutputGuardOptions, scriptPipeHint } from "./mcp-output-guard.js";
 import { maybeStartUiSession, summarizeUiSessionResult } from "./ui-session.js";
-import { formatAuthRequiredMessage, formatMcpStatus, normalizeToolArguments, resolveServerUrl, truncateAtWord } from "./utils.js";
+import { formatAuthRequiredMessage, formatMcpStatus, normalizeToolArguments, resolveServerUrl, truncateAtWord, withToolCallIdMeta } from "./utils.js";
 import { authenticate, completeAuthFromInput, getAuthStatus, startAuth, supportsOAuth } from "./mcp-auth-flow.js";
 import { SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
 import { callToolViaTaskSession } from "./mcp-tasks.js";
+import { callToolPausingForElicitation } from "./elicitation-handler.js";
 import { paginate, rankSuggestions, rankToolMatches, resolveSearchKeywords } from "./search-ranking.js";
 import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-approval.js";
-import { isServerInActiveFailureBackoff } from "./failure-backoff.js";
+import { describeFailure, isServerInActiveFailureBackoff } from "./failure-backoff.js";
 import { semanticSearch } from "./semantic-search.js";
 import { getInputRequiredNeedsUiDetails } from "./errors.js";
 import { createJsonSchemaValidator } from "./json-schema-validator.js";
+import { describeProjectServerBlock, disabledServerReason } from "./project-server-trust.js";
 const require = createRequire(import.meta.url);
 const proxyArgumentValidators = new WeakMap;
 const MAX_REGEX_SEARCH_QUERY_LENGTH = 256;
@@ -89,8 +92,7 @@ function getEnabledOriginalToolMatches(state, toolName) {
   return matches;
 }
 function serverBackoffResult(state, mode, serverName) {
-  const failedAgo = getFailureAgeSeconds(state, serverName) ?? 0;
-  const message = `Server "${serverName}" not available (last failed ${failedAgo}s ago)`;
+  const message = `Server "${serverName}" not available (last ${describeFailure(state, serverName) ?? "failed 0s ago"})`;
   return {
     content: [{ type: "text", text: message }],
     details: { mode, error: "server_backoff", server: serverName }
@@ -160,8 +162,8 @@ function ambiguousServerToolResult(mode, toolName, serverName) {
     details: { mode, error: "ambiguous_tool", server: serverName, requestedTool: toolName, message }
   };
 }
-function disabledResult(mode, serverName) {
-  const message = `Server "${serverName}" is disabled. Run /mcp enable ${serverName} and /reload to enable it.`;
+function disabledResult(state, mode, serverName) {
+  const message = `Server "${serverName}" is ${disabledServerReason(state.blockedProjectServers, serverName)}`;
   return {
     content: [{ type: "text", text: message }],
     details: { mode, error: "server_disabled", server: serverName, message }
@@ -397,10 +399,11 @@ export function executeStatus(state) {
   for (const name of Object.keys(state.config.mcpServers)) {
     const definition = state.config.mcpServers[name];
     const disabled = isServerDisabled(definition);
+    const block = state.blockedProjectServers?.get(name);
     const connection = disabled ? undefined : state.manager.getConnection(name);
     const metadata = disabled ? undefined : state.toolMetadata.get(name);
     const failedAgo = disabled ? null : getFailureAgeSeconds(state, name);
-    let status = disabled ? "disabled" : "not connected";
+    let status = block ? "blocked" : disabled ? "disabled" : "not connected";
     if (!disabled && connection?.status === "connected") {
       status = "connected";
     } else if (!disabled && connection?.status === "needs-auth") {
@@ -419,20 +422,35 @@ export function executeStatus(state) {
       ...connection?.status === "connected" && connection.listenCatalogStale ? { catalogStale: true } : {},
       toolCount,
       failedAgo,
-      ...disabled ? { disabled: true } : {}
+      ...disabled ? { disabled: true } : {},
+      ...block ? { blockedReason: describeProjectServerBlock(block.reason) } : {}
     });
   }
-  const disabledCount = servers.filter((s) => s.disabled).length;
+  const blockedCount = servers.filter((s) => s.status === "blocked").length;
+  const disabledCount = servers.filter((s) => s.disabled && s.status !== "blocked").length;
   const enabledServers = servers.filter((s) => !s.disabled);
   const totalTools = enabledServers.reduce((sum, s) => sum + s.toolCount, 0);
   const connectedCount = enabledServers.filter((s) => s.status === "connected").length;
   let text = `MCP: ${connectedCount}/${enabledServers.length} servers, ${totalTools} tools`;
+  if (blockedCount > 0)
+    text += ` (${blockedCount} blocked)`;
   if (disabledCount > 0)
     text += ` (${disabledCount} disabled)`;
   text += `
 
 `;
+  if (state.migrationNotices?.length) {
+    text += `${state.migrationNotices.map((notice) => `⚠ ${notice}`).join(`
+`)}
+
+`;
+  }
   for (const server of servers) {
+    if (server.status === "blocked") {
+      text += `⊘ ${server.name} (${server.blockedReason})
+`;
+      continue;
+    }
     if (server.disabled) {
       text += `⊘ ${server.name} (disabled)
 `;
@@ -455,7 +473,7 @@ export function executeStatus(state) {
       continue;
     }
     if (server.status === "failed") {
-      text += `✗ ${server.name} (failed ${server.failedAgo ?? 0}s ago)
+      text += `✗ ${server.name} (${describeFailure(state, server.name) ?? `failed ${server.failedAgo ?? 0}s ago`})
 `;
       continue;
     }
@@ -488,7 +506,7 @@ export async function executeAuthStart(state, serverName, signal) {
     };
   }
   if (isServerDisabled(definition))
-    return disabledResult("auth-start", serverName);
+    return disabledResult(state, "auth-start", serverName);
   try {
     const serverUrl = resolveServerUrl(definition);
     if (!serverUrl || !supportsOAuth(definition)) {
@@ -537,7 +555,7 @@ export async function executeAuthComplete(state, serverName, input, signal) {
     };
   }
   if (isServerDisabled(definition))
-    return disabledResult("auth-complete", serverName);
+    return disabledResult(state, "auth-complete", serverName);
   try {
     const status = state.authStorageOptions ? ownedSignal ? await completeAuthFromInput(serverName, input, { authStorageOptions: state.authStorageOptions, signal: ownedSignal, runtime: state.oauthRuntime }) : await completeAuthFromInput(serverName, input, { authStorageOptions: state.authStorageOptions, runtime: state.oauthRuntime }) : ownedSignal ? await completeAuthFromInput(serverName, input, { signal: ownedSignal, runtime: state.oauthRuntime }) : await completeAuthFromInput(serverName, input, { runtime: state.oauthRuntime });
     if (status !== "authenticated") {
@@ -561,28 +579,46 @@ export async function executeAuthComplete(state, serverName, input, signal) {
     };
   }
 }
-export function executeDescribe(state, toolName, serverOverride) {
-  let serverName;
-  let toolMeta;
-  let disabledMatch;
-  let failedMatch;
+function formatToolHints(toolMeta) {
+  const annotations = toolMeta.annotations;
+  if (!annotations)
+    return "";
+  const hints = [];
+  const flag = (value, yes, no) => {
+    if (value !== undefined)
+      hints.push(value ? yes : no);
+  };
+  flag(annotations.readOnlyHint, "read-only", "not read-only");
+  flag(annotations.destructiveHint, "destructive", "non-destructive");
+  flag(annotations.idempotentHint, "idempotent", "not idempotent");
+  flag(annotations.openWorldHint, "open-world", "closed-world");
+  const title = annotations.title?.trim();
+  if (title && title !== toolMeta.originalName && title !== toolMeta.name)
+    hints.push(`title ${JSON.stringify(title)}`);
+  return hints.join(", ");
+}
+export function resolveDescribeTarget(state, toolName, serverOverride) {
   if (serverOverride) {
     if (!state.config.mcpServers[serverOverride]) {
       return {
-        content: [{ type: "text", text: `Server "${serverOverride}" not found. Use mcp({}) to see available servers.` }],
-        details: { mode: "describe", error: "server_not_found", server: serverOverride, requestedTool: toolName }
+        error: {
+          content: [{ type: "text", text: `Server "${serverOverride}" not found. Use mcp({}) to see available servers.` }],
+          details: { mode: "describe", error: "server_not_found", server: serverOverride, requestedTool: toolName }
+        }
       };
     }
     const match = getServerScopedToolMatch(state.toolMetadata.get(serverOverride), toolName);
     if (match === "ambiguous")
-      return ambiguousServerToolResult("describe", toolName, serverOverride);
+      return { error: ambiguousServerToolResult("describe", toolName, serverOverride) };
     if (isServerDisabled(state.config.mcpServers[serverOverride]))
-      return disabledResult("describe", serverOverride);
+      return { error: disabledResult(state, "describe", serverOverride) };
     if (isServerInActiveFailureBackoff(state, serverOverride))
-      return serverBackoffResult(state, "describe", serverOverride);
-    serverName = serverOverride;
-    toolMeta = match?.tool;
+      return { error: serverBackoffResult(state, "describe", serverOverride) };
+    if (match)
+      return { server: serverOverride, tool: match.tool };
   } else {
+    let disabledMatch;
+    let failedMatch;
     const matches = [];
     for (const [server, metadata] of state.toolMetadata.entries()) {
       const candidates = getServerScopedToolCandidates(metadata, toolName);
@@ -603,25 +639,30 @@ export function executeDescribe(state, toolName, serverOverride) {
       const precedence = Math.min(...matches.map((match) => match.precedence));
       const bestMatches = matches.filter((match) => match.precedence === precedence);
       if (bestMatches.length > 1)
-        return ambiguousToolResult("describe", toolName);
-      serverName = bestMatches[0].server;
-      toolMeta = bestMatches[0].tool;
+        return { error: ambiguousToolResult("describe", toolName) };
+      return { server: bestMatches[0].server, tool: bestMatches[0].tool };
     }
-  }
-  if (!serverName || !toolMeta) {
     if (disabledMatch)
-      return disabledResult("describe", disabledMatch);
+      return { error: disabledResult(state, "describe", disabledMatch) };
     if (failedMatch)
-      return serverBackoffResult(state, "describe", failedMatch);
-    const suggestions = rankSuggestions(state, toolName, 5, serverOverride);
-    const suggestionText = suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}` : "";
-    const scopeText = serverOverride ? ` on server "${serverOverride}"` : "";
-    const searchHint = serverOverride ? `mcp({ search: "...", server: "${serverOverride}" })` : `mcp({ search: "..." })`;
-    return {
+      return { error: serverBackoffResult(state, "describe", failedMatch) };
+  }
+  const suggestions = rankSuggestions(state, toolName, 5, serverOverride);
+  const suggestionText = suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}` : "";
+  const scopeText = serverOverride ? ` on server "${serverOverride}"` : "";
+  const searchHint = serverOverride ? `mcp({ search: "...", server: "${serverOverride}" })` : `mcp({ search: "..." })`;
+  return {
+    error: {
       content: [{ type: "text", text: `Tool "${toolName}" not found${scopeText}. Use ${searchHint} to search.${suggestionText}` }],
       details: { mode: "describe", error: "tool_not_found", server: serverOverride, requestedTool: toolName, suggestions }
-    };
-  }
+    }
+  };
+}
+export function executeDescribe(state, toolName, serverOverride) {
+  const target = resolveDescribeTarget(state, toolName, serverOverride);
+  if ("error" in target)
+    return target.error;
+  const { server: serverName, tool: toolMeta } = target;
   const approvalMarker = isToolCallApprovalRequired(state.config, serverName, toolMeta, state.toolMetadata) ? " (requires approval)" : "";
   let text = `${toolMeta.name}${approvalMarker}
 `;
@@ -631,6 +672,10 @@ export function executeDescribe(state, toolName, serverOverride) {
     text += `Type: Resource (reads from ${toolMeta.resourceUri})
 `;
   }
+  const hints = formatToolHints(toolMeta);
+  if (hints)
+    text += `Hints: ${hints}
+`;
   text += `
 ${toolMeta.description || "(no description)"}
 `;
@@ -647,6 +692,14 @@ No parameters required (resource tool).`;
   } else {
     text += `
 No parameters defined.`;
+  }
+  const observed = toolMeta.resourceUri ? undefined : getObservedOutput(state, serverName, toolMeta);
+  if (observed) {
+    const source = observed.source === "structuredContent" ? "structuredContent" : "JSON text result";
+    text += `
+
+Observed output (${source}, from earlier calls, not a contract):
+${renderOutputShape(observed.shape)}`;
   }
   return {
     content: [{ type: "text", text: text.trim() }],
@@ -726,70 +779,46 @@ ${page.items.length} of ${page.total} — offset: ${page.nextOffset} for more
     }
   };
 }
-export function executeSearch(state, query, regex, server, includeSchemas, limit = 12, offset = 0, searchMode = "lexical", signal, semanticEvaluator) {
-  const showSchemas = includeSchemas !== false;
+export function findTools(state, input) {
+  const { query, regex, server, searchMode = "lexical" } = input;
+  const failure = (text, details) => ({
+    error: { content: [{ type: "text", text }], details: { mode: "search", ...details } }
+  });
   if (searchMode !== "lexical" && searchMode !== "semantic") {
-    return {
-      content: [{ type: "text", text: "Search mode must be lexical or semantic." }],
-      details: { mode: "search", error: "invalid_search_mode", query }
-    };
+    return failure("Search mode must be lexical or semantic.", { error: "invalid_search_mode", query });
   }
   if (server && isServerDisabled(state.config.mcpServers[server]))
-    return disabledResult("search", server);
+    return { error: disabledResult(state, "search", server) };
   if (server && isServerInActiveFailureBackoff(state, server))
-    return serverBackoffResult(state, "search", server);
+    return { error: serverBackoffResult(state, "search", server) };
   if (searchMode === "semantic" && regex) {
-    return {
-      content: [{ type: "text", text: "Semantic search cannot be combined with regex search." }],
-      details: { mode: "search", error: "invalid_search_mode", query }
-    };
+    return failure("Semantic search cannot be combined with regex search.", { error: "invalid_search_mode", query });
   }
   if (searchMode === "semantic") {
-    return semanticSearch(state, query, server, signal, semanticEvaluator).then((result) => {
-      if (!result.ok) {
-        return {
-          content: [{ type: "text", text: `Semantic search failed: ${result.error.message}` }],
-          details: { mode: "search", error: result.error.code, message: result.error.message, query }
-        };
-      }
-      return renderSearchResults(state, query, server, showSchemas, limit, offset, result.matches, result.backend);
-    });
+    return semanticSearch(state, query, server, input.signal, input.semanticEvaluator, input.observedSources).then((result) => result.ok ? { matches: result.matches, backend: result.backend } : failure(`Semantic search failed: ${result.error.message}`, { error: result.error.code, message: result.error.message, query }));
   }
-  let matches;
   if (regex) {
+    if (query.length > MAX_REGEX_SEARCH_QUERY_LENGTH) {
+      return failure(`Regex query is too long; maximum length is ${MAX_REGEX_SEARCH_QUERY_LENGTH} characters.`, { error: "query_too_long", query, maxLength: MAX_REGEX_SEARCH_QUERY_LENGTH });
+    }
     let pattern;
     try {
-      if (query.length > MAX_REGEX_SEARCH_QUERY_LENGTH) {
-        return {
-          content: [{ type: "text", text: `Regex query is too long; maximum length is ${MAX_REGEX_SEARCH_QUERY_LENGTH} characters.` }],
-          details: { mode: "search", error: "query_too_long", query, maxLength: MAX_REGEX_SEARCH_QUERY_LENGTH }
-        };
-      }
       pattern = new RegExp(query, "i");
-      let safety;
-      try {
-        const { checkSync } = require("recheck");
-        safety = checkSync(query, "i", REGEX_SAFETY_CHECK_PARAMS);
-      } catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        return {
-          content: [{ type: "text", text: "Regex query rejected because safety analysis failed." }],
-          details: { mode: "search", error: "unsafe_pattern", query, reason }
-        };
-      }
-      if (safety.status !== "safe") {
-        return {
-          content: [{ type: "text", text: `Regex query rejected as unsafe (${safety.status}).` }],
-          details: { mode: "search", error: "unsafe_pattern", query, safetyStatus: safety.status }
-        };
-      }
     } catch {
-      return {
-        content: [{ type: "text", text: `Invalid regex: ${query}` }],
-        details: { mode: "search", error: "invalid_pattern", query }
-      };
+      return failure(`Invalid regex: ${query}`, { error: "invalid_pattern", query });
+    }
+    let safety;
+    try {
+      const { checkSync } = require("recheck");
+      safety = checkSync(query, "i", REGEX_SAFETY_CHECK_PARAMS);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return failure("Regex query rejected because safety analysis failed.", { error: "unsafe_pattern", query, reason });
     }
-    matches = [];
+    if (safety.status !== "safe") {
+      return failure(`Regex query rejected as unsafe (${safety.status}).`, { error: "unsafe_pattern", query, safetyStatus: safety.status });
+    }
+    const matches = [];
     const globalPrefix = state.config.settings?.toolPrefix ?? "server";
     for (const [serverName, metadata] of state.toolMetadata.entries()) {
       const definition = state.config.mcpServers[serverName];
@@ -805,18 +834,21 @@ export function executeSearch(state, query, regex, server, includeSchemas, limit
           matches.push({ server: serverName, tool, score: 0 });
       }
     }
-  } else if (query.trim().length === 0) {
-    if (!server) {
-      return {
-        content: [{ type: "text", text: "Search query cannot be empty" }],
-        details: { mode: "search", error: "empty_query" }
-      };
-    }
-    matches = (state.toolMetadata.get(server) ?? []).map((tool) => ({ server, tool, score: 0 })).sort((a, b) => a.tool.name.localeCompare(b.tool.name));
-  } else {
-    matches = rankToolMatches(state, query, server);
+    return { matches };
   }
-  return renderSearchResults(state, query, server, showSchemas, limit, offset, matches);
+  if (query.trim().length === 0) {
+    if (!server)
+      return failure("Search query cannot be empty", { error: "empty_query" });
+    return {
+      matches: (state.toolMetadata.get(server) ?? []).map((tool) => ({ server, tool, score: 0 })).sort((a, b) => a.tool.name.localeCompare(b.tool.name))
+    };
+  }
+  return { matches: rankToolMatches(state, query, server) };
+}
+export function executeSearch(state, query, regex, server, includeSchemas, limit = 12, offset = 0, searchMode = "lexical", signal, semanticEvaluator) {
+  const render = (outcome) => ("error" in outcome) ? outcome.error : renderSearchResults(state, query, server, includeSchemas !== false, limit, offset, outcome.matches, outcome.backend);
+  const outcome = findTools(state, { query, regex, server, searchMode, signal, semanticEvaluator });
+  return outcome instanceof Promise ? outcome.then(render) : render(outcome);
 }
 export function executeList(state, server) {
   const definition = state.config.mcpServers[server];
@@ -827,7 +859,7 @@ export function executeList(state, server) {
     };
   }
   if (isServerDisabled(definition))
-    return disabledResult("list", server);
+    return disabledResult(state, "list", server);
   const metadata = state.toolMetadata.get(server);
   const toolNames = metadata?.map((m) => m.name) ?? [];
   const connection = state.manager.getConnection(server);
@@ -850,45 +882,41 @@ ${preview}`;
 Use mcp({ instructions: "${server}" }) for the full text.`;
     }
   }
+  const description = definition.description?.replace(/\s+/g, " ").trim();
+  const descriptionText = description ? `
+Description: ${description}` : "";
   if (toolNames.length === 0) {
     if (connection?.status === "connected") {
       return {
-        content: [{ type: "text", text: `Server "${server}" has no tools.${instructionsText}` }],
+        content: [{ type: "text", text: `Server "${server}" has no tools.${descriptionText}${instructionsText}` }],
         details: { mode: "list", server, tools: [], count: 0, hasInstructions: Boolean(instructions) }
       };
     }
     if (metadata !== undefined) {
       return {
-        content: [{ type: "text", text: `Server "${server}" has no cached tools (not connected).${instructionsText}` }],
+        content: [{ type: "text", text: `Server "${server}" has no cached tools (not connected).${descriptionText}${instructionsText}` }],
         details: { mode: "list", server, tools: [], count: 0, cached: true, hasInstructions: Boolean(instructions) }
       };
     }
     return {
-      content: [{ type: "text", text: `Server "${server}" is configured but not connected. Use mcp({ connect: "${server}" }) or /mcp reconnect ${server} to retry.${instructionsText}` }],
+      content: [{ type: "text", text: `Server "${server}" is configured but not connected. Use mcp({ connect: "${server}" }) or /mcp-adapter reconnect ${server} to retry.${descriptionText}${instructionsText}` }],
       details: { mode: "list", server, tools: [], count: 0, error: "not_connected", hasInstructions: Boolean(instructions) }
     };
   }
   let cachedNote = "";
   if (connection?.status !== "connected") {
     if (connection?.status === "needs-auth") {
-      cachedNote = ` (needs auth — run mcp({ action: "auth-start", server: "${server}" }))`;
+      cachedNote = typeof definition.auth === "object" ? ` (needs sign-in — run /login ${definition.auth.provider}, then /mcp-adapter reconnect ${server})` : ` (needs auth — run mcp({ action: "auth-start", server: "${server}" }))`;
     } else {
       cachedNote = ` (lazy: tools from cache, not connected yet — mcp({ connect: "${server}" }) to connect)`;
     }
   }
-  let text = `${server} (${toolNames.length} tools${cachedNote}):
+  let text = `${server} (${toolNames.length} tools${cachedNote}):${descriptionText}
 
 `;
-  const descMap = new Map;
-  if (metadata) {
-    for (const m of metadata) {
-      descMap.set(m.name, m.description);
-    }
-  }
-  for (const tool of toolNames) {
-    const desc = descMap.get(tool) ?? "";
-    const truncated = truncateAtWord(desc, 50);
-    text += `- ${tool}`;
+  for (const toolMeta of metadata ?? []) {
+    const truncated = truncateAtWord(toolMeta.description, 50);
+    text += `- ${toolMeta.name}${formatParameterNames(toolMeta)}`;
     if (truncated)
       text += ` - ${truncated}`;
     text += `
@@ -900,6 +928,31 @@ Use mcp({ instructions: "${server}" }) for the full text.`;
     details: { mode: "list", server, tools: toolNames, count: toolNames.length, hasInstructions: Boolean(instructions) }
   };
 }
+const PARAMETER_NAME_UNREADABLE_KEYWORDS = ["$ref", "allOf", "anyOf", "oneOf", "not", "if", "then", "else", "dependentRequired", "dependentSchemas", "dependencies"];
+function formatParameterNames(toolMeta) {
+  if (toolMeta.resourceUri)
+    return "()";
+  const schema = toolMeta.inputSchema;
+  if (!schema || typeof schema !== "object" || Array.isArray(schema))
+    return "";
+  if (PARAMETER_NAME_UNREADABLE_KEYWORDS.some((keyword) => Object.hasOwn(schema, keyword)))
+    return "";
+  const { properties, required } = schema;
+  if (required !== undefined && !Array.isArray(required))
+    return "";
+  if (properties !== undefined && (!properties || typeof properties !== "object" || Array.isArray(properties)))
+    return "";
+  const requiredSet = new Set((required ?? []).filter((name) => typeof name === "string"));
+  if (properties === undefined && requiredSet.size === 0 && schema.type !== "object")
+    return "";
+  const names = properties ? Object.keys(properties) : [];
+  const ordered = [
+    ...names.filter((name) => requiredSet.has(name)),
+    ...[...requiredSet].filter((name) => !names.includes(name)),
+    ...names.filter((name) => !requiredSet.has(name)).map((name) => `${name}?`)
+  ];
+  return `(${ordered.join(", ")})`;
+}
 export function executeInstructions(state, server) {
   const definition = state.config.mcpServers[server];
   if (!definition) {
@@ -909,7 +962,7 @@ export function executeInstructions(state, server) {
     };
   }
   if (isServerDisabled(definition))
-    return disabledResult("instructions", server);
+    return disabledResult(state, "instructions", server);
   if (isServerInActiveFailureBackoff(state, server))
     return serverBackoffResult(state, "instructions", server);
   const instructions = state.serverInstructions.get(server);
@@ -944,7 +997,7 @@ export async function executeConnect(state, serverName, signal) {
     };
   }
   if (isServerDisabled(definition))
-    return disabledResult("connect", serverName);
+    return disabledResult(state, "connect", serverName);
   try {
     if (state.ui) {
       state.ui.setStatus("mcp", formatMcpStatus(state.config, `connecting to ${serverName}...`));
@@ -1002,7 +1055,11 @@ export async function executeConnect(state, serverName, signal) {
     };
   }
 }
-export async function executeCall(state, toolName, args, serverOverride, getPiTools, signal, origin, internalDelivery) {
+export function unscopedCallReachesServer(state, toolName, serverName) {
+  const matches = getEnabledToolMatches(state, toolName, true);
+  return matches.length === 1 && matches[0].server === serverName;
+}
+export async function executeCall(state, toolName, args, serverOverride, getPiTools, signal, origin, internalDelivery, toolCallId) {
   const ownedSignal = combineAbortSignals(state.owner?.signal, signal);
   throwIfAborted(ownedSignal);
   let serverName = serverOverride;
@@ -1010,18 +1067,13 @@ export async function executeCall(state, toolName, args, serverOverride, getPiTo
   let autoAuthAttempted = false;
   const prefixMode = state.config.settings?.toolPrefix ?? "server";
   const disabledCallResult = (disabledServer, metadata) => {
-    if (!metadata) {
-      const message = `Server "${disabledServer}" is disabled. Run /mcp enable ${disabledServer} and /reload to enable it.`;
-      return {
-        content: [{ type: "text", text: message }],
-        details: { mode: "call", error: "server_disabled", server: disabledServer, requestedTool: toolName, message }
-      };
-    }
-    const message = `Server "${disabledServer}" is disabled. Run /mcp enable ${disabledServer} and /reload to enable it.`;
-    const identity = metadata.resourceUri ? { server: disabledServer, resourceUri: metadata.resourceUri } : { server: disabledServer, tool: metadata.originalName };
+    const message = `Server "${disabledServer}" is ${disabledServerReason(state.blockedProjectServers, disabledServer)}`;
+    let identity = { requestedTool: toolName };
+    if (metadata)
+      identity = metadata.resourceUri ? { resourceUri: metadata.resourceUri } : { tool: metadata.originalName };
     return {
       content: [{ type: "text", text: message }],
-      details: { mode: "call", error: "server_disabled", ...identity, message }
+      details: { mode: "call", error: "server_disabled", server: disabledServer, ...identity, message }
     };
   };
   if (serverName && !state.config.mcpServers[serverName]) {
@@ -1137,10 +1189,10 @@ export async function executeCall(state, toolName, args, serverOverride, getPiTo
         }
       }
       if (!toolMeta) {
-        const failedAgo = getFailureAgeSeconds(state, serverName);
-        if (failedAgo !== null) {
+        const failure = describeFailure(state, serverName);
+        if (failure !== null) {
           return {
-            content: [{ type: "text", text: `Server "${serverName}" not available (last failed ${failedAgo}s ago)` }],
+            content: [{ type: "text", text: `Server "${serverName}" not available (last ${failure})` }],
             details: { mode: "call", error: "server_backoff", server: serverName, requestedTool: toolName }
           };
         }
@@ -1223,7 +1275,7 @@ export async function executeCall(state, toolName, args, serverOverride, getPiTo
       details: { mode: "call", error: "tool_not_found", requestedTool: toolName, hintServer, suggestions }
     };
   }
-  const callIdentity = toolMeta.resourceUri ? { server: serverName, resourceUri: toolMeta.resourceUri } : { server: serverName, tool: toolMeta.originalName, canonicalTool: toolMeta.name };
+  const callIdentity = toolMeta.resourceUri ? { server: serverName, resourceUri: toolMeta.resourceUri, canonicalTool: toolMeta.name } : { server: serverName, tool: toolMeta.originalName, canonicalTool: toolMeta.name };
   let connection = state.manager.getConnection(serverName);
   if (connection?.status === "needs-auth") {
     if (!autoAuthAttempted) {
@@ -1250,10 +1302,10 @@ export async function executeCall(state, toolName, args, serverOverride, getPiTo
     }
   }
   if (!connection || connection.status !== "connected") {
-    const failedAgo = getFailureAgeSeconds(state, serverName);
-    if (failedAgo !== null) {
+    const failure = describeFailure(state, serverName);
+    if (failure !== null) {
       return {
-        content: [{ type: "text", text: `Server "${serverName}" not available (last failed ${failedAgo}s ago)` }],
+        content: [{ type: "text", text: `Server "${serverName}" not available (last ${failure})` }],
         details: { mode: "call", error: "server_backoff", ...callIdentity }
       };
     }
@@ -1340,21 +1392,8 @@ ${formatSchema(toolMeta.inputSchema)}`;
       details: { mode: "call", error: "call_failed", ...callIdentity, message: validationError, ...guardedMcpDetails(guarded) }
     };
   }
-  const approval = await ensureToolCallApproved(state, serverName, toolMeta, normalizedArgs, ownedSignal, origin ?? (toolMeta.resourceUri ? "resource" : "proxy"));
-  if (approval.ok === false) {
-    const denied = approval.reason === "denied";
-    const message = denied ? `The user declined approval to run MCP tool "${toolMeta.originalName}" on server "${serverName}".` : `MCP tool "${toolMeta.originalName}" on server "${serverName}" is approval-gated and requires an interactive session.`;
-    return {
-      content: [{ type: "text", text: message }],
-      details: {
-        mode: "call",
-        error: denied ? "approval_denied" : "approval_required",
-        server: serverName,
-        tool: toolMeta.originalName
-      }
-    };
-  }
   let uiSession = null;
+  const uiResourceUri = state.config.mcpServers[serverName]?.openUi === false ? undefined : toolMeta.uiResourceUri;
   const requestOptions = withUiProgressBridge(state.manager.getRequestOptions?.(serverName, ownedSignal) ?? (ownedSignal ? { signal: ownedSignal } : undefined), state.ui, serverName, toolMeta.originalName);
   const outputGuardOptions = resolveMcpOutputGuardOptions(state.config.settings);
   const recoverAuthConnection = async () => {
@@ -1384,9 +1423,24 @@ ${formatSchema(toolMeta.inputSchema)}`;
     }
     return state.manager.getConnection(serverName);
   };
+  let approval;
   try {
     state.manager.touch(serverName);
     state.manager.incrementInFlight(serverName);
+    approval = await ensureToolCallApproved(state, serverName, toolMeta, normalizedArgs, ownedSignal, origin ?? (toolMeta.resourceUri ? "resource" : "proxy"));
+    if (approval.ok === false) {
+      const denied = approval.reason === "denied";
+      const message = denied ? `The user declined approval to run MCP tool "${toolMeta.originalName}" on server "${serverName}".` : `MCP tool "${toolMeta.originalName}" on server "${serverName}" is approval-gated and requires an interactive session.`;
+      return {
+        content: [{ type: "text", text: message }],
+        details: {
+          mode: "call",
+          error: denied ? "approval_denied" : "approval_required",
+          server: serverName,
+          tool: toolMeta.originalName
+        }
+      };
+    }
     if (toolMeta.resourceUri) {
       const result = await withSessionRecovery({
         manager: state.manager,
@@ -1410,15 +1464,17 @@ ${formatSchema(toolMeta.inputSchema)}`;
         details: { mode: "call", ...callIdentity, ...guardedMcpDetails(guarded) }
       };
     }
-    uiSession = toolMeta.uiResourceUri ? await maybeStartUiSession(state, {
+    uiSession = uiResourceUri ? await maybeStartUiSession(state, {
       serverName,
       toolName: toolMeta.originalName,
       toolArgs: normalizedArgs,
-      uiResourceUri: toolMeta.uiResourceUri,
+      uiResourceUri,
       ...toolMeta.uiStreamMode !== undefined ? { streamMode: toolMeta.uiStreamMode } : {},
       ...signal ? { signal } : {},
       onNeedsAuth: recoverAuthConnection
     }) : null;
+    const requestMeta = withToolCallIdMeta(uiSession?.requestMeta, toolCallId);
+    const recordOutput = observedOutputRecorder(state, serverName, toolMeta.originalName);
     const result = await withSessionRecovery({
       manager: state.manager,
       config: state.config,
@@ -1430,18 +1486,20 @@ ${formatSchema(toolMeta.inputSchema)}`;
         return await callToolViaTaskSession(conn.taskSession, {
           name: toolMeta.originalName,
           args: normalizedArgs ?? {},
-          meta: uiSession?.requestMeta,
+          meta: requestMeta,
           signal: ownedSignal,
           requestTimeoutMs: requestOptions?.timeout
         });
       }
-      return abortable(conn.client.callTool({
+      return abortable(callToolPausingForElicitation(conn.client, {
         name: toolMeta.originalName,
         arguments: normalizedArgs,
-        _meta: uiSession?.requestMeta
+        _meta: requestMeta
       }, requestOptions), ownedSignal);
     });
-    if (toolMeta.uiResourceUri) {
+    if (!result.isError)
+      recordOutput(result);
+    if (uiResourceUri) {
       uiSession?.sendToolResult(result);
     }
     if (!result.isError && internalDelivery) {
@@ -1449,7 +1507,7 @@ ${formatSchema(toolMeta.inputSchema)}`;
       internalDelivery.onSuccess(result);
       return { content: [], details: { mode: "call", ...callIdentity } };
     }
-    if (toolMeta.uiResourceUri) {
+    if (uiResourceUri) {
       if (result.isError) {
         const content = resolveMcpResultContent(result, state.owner?.signal);
         const outputContent = content.length > 0 ? content : [{ type: "text", text: "(empty result)" }];
@@ -1488,12 +1546,15 @@ ${uiSummary.message}`, rawMcpResult: result });
     }
     const content = resolveMcpResultContent(result, state.owner?.signal);
     const outputContent = content.length > 0 ? content : [{ type: "text", text: "(empty result)" }];
-    const guarded = await guardMcpOutput(outputContent, { ...outputGuardOptions, rawMcpResult: result });
+    const pipeHint = scriptPipeHint(origin !== "script" && state.scriptTool, outputContent);
+    const guarded = await guardMcpOutput(outputContent, { ...outputGuardOptions, ...pipeHint, rawMcpResult: result });
     return {
       content: guarded.content,
       details: { mode: "call", ...guardedMcpDetails(guarded), ...callIdentity }
     };
   } catch (error) {
+    if (!approval)
+      throw error;
     if (error instanceof SessionRecoveryAuthRequiredError) {
       const message = error.authMessage ?? getAuthRequiredMessage(state, serverName);
       uiSession?.sendToolCancelled(message);