@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-mcp-adapter/index.js

@@ -1,10 +1,13 @@
+import { registerProtocolBridge } from "./runtime-protocol.js";
+export { registerMcpProtocol, MCP_PROTOCOL_EVENT } from "./runtime-protocol.js";
 import { withFileMutationQueue } from "@duckmind/dm-coding-agent";
 import { resolve } from "node:path";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { isServerDisabled } from "./types.js";
 import { Type } from "typebox";
-import { cloneMcpConfig, discoverConfiguredClaudePluginSkills, getPiGlobalConfigPath, getProjectConfigPath, loadMcpConfig, resolveConfiguredClaudePluginMcp, writeProjectServerDisabledOverride, writeSharedServerEntry } from "./config.js";
+import { cloneMcpConfig, discoverConfiguredClaudePluginSkills, getLegacyMcpMigrationNotices, getPiGlobalConfigPath, getPiMcpAuthPath, getProjectConfigPath, loadMcpConfig, resolveConfiguredClaudePluginMcp, setPiMcpConfigEnabled, translatePiMcpServer, writeProjectServerDisabledOverride, writeSharedServerEntry } from "./config.js";
+import { approveProjectServer, excludeProjectServersAtLoadTime, hasProjectServerDefinitions } from "./project-server-trust.js";
 import { buildProxyDescription, getLargeDirectToolsAdvisory, getMissingConfiguredDirectToolServers, prepareDirectToolArguments, resolveDirectTools } from "./direct-tool-surface.js";
 import { isServerInActiveFailureBackoff } from "./failure-backoff.js";
 import { computeServerHash, isServerCacheValid, loadMetadataCache, parseDirectToolSelectors } from "./metadata-cache.js";
@@ -14,10 +17,14 @@ import { formatMcpFooterStatus, formatTerminalError, getConfigPathFromArgv, norm
 import { createMcpDirectToolCallRenderer, createMcpProxyToolCallRenderer, createMcpScriptToolCallRenderer, createMcpToolResultRenderer, resolveMcpToolRenderOptions } from "./tool-result-renderer.js";
 import { toolErrorOverride } from "./error-signal.js";
 import { createMcpRuntimeOwner, createOwnedUi, isAbortError } from "./runtime-owner.js";
+import { cleanupMaterializedBinaryResources } from "./tool-registrar.js";
 import { publishMcpStatusShutdown } from "./mcp-status.js";
 import { syncNamespaceProxyTools } from "./namespace-tools.js";
 import { restoreSessionApprovalState } from "./session-approvals.js";
 import { createRetryableLoader } from "./lazy-loader.js";
+import { toToolParameters } from "./tool-parameters.js";
+import { readPanelOpenKeys } from "./panel-keys.js";
+import { getAgentPath } from "./agent-dir.js";
 export {
   namespaceProxyName,
   parseMcpReference,
@@ -38,6 +45,21 @@ const loadInstallParsing = createRetryableLoader(() => import("./mcp-install.js"
 const INIT_WAIT_TIMEOUT_MS = 30000;
 const INIT_FAILURE_MESSAGE_MAX_CHARS = 1000;
 const INIT_WAIT_TIMED_OUT = Symbol("init-wait-timed-out");
+function piSupportsMcp(pi) {
+  const host = pi;
+  return typeof host.registerMcpServer === "function" && typeof host.getMcpServers === "function";
+}
+function toCallToolResult(result) {
+  const extended = result;
+  return {
+    ...result,
+    structuredContent: {
+      content: result.content,
+      ...extended.structuredContent !== undefined ? { structuredContent: extended.structuredContent } : {},
+      ...result.details?.error !== undefined ? { isError: true } : {}
+    }
+  };
+}
 function hasEnabledServerWithoutValidMetadata(config, cache, directSpecs = []) {
   return Object.entries(config.mcpServers).some(([serverName, definition]) => {
     if (isServerDisabled(definition) || directSpecs.some((spec) => spec.serverName === serverName))
@@ -50,6 +72,8 @@ export const MCP_RUNTIME_REGISTER_EVENT = "dm-mcp-adapter:runtime-register:v1";
 export const MCP_RUNTIME_REGISTER_VERSION = 1;
 export const MCP_RUNTIME_SNAPSHOT_EVENT = "dm-mcp-adapter:runtime-snapshot:v1";
 export const MCP_RUNTIME_SNAPSHOT_VERSION = 1;
+export const MCP_RUNTIME_TOOL_CALL_EVENT = "dm-mcp-adapter:runtime-tool-call:v1";
+export const MCP_RUNTIME_TOOL_CALL_VERSION = 1;
 const runtimeRegistrars = new WeakMap;
 const runtimeSnapshotters = new WeakMap;
 function resolveProgrammaticClaudePluginPath(path, cwd) {
@@ -100,7 +124,10 @@ function resolveNamespaceEnvOverride(raw, selectors) {
 function installMcpAdapter(pi, options) {
   const sessionConfig = options.config !== undefined ? cloneMcpConfig(options.config) : undefined;
   const programmaticConfig = sessionConfig !== undefined;
+  if (!programmaticConfig)
+    setPiMcpConfigEnabled(piSupportsMcp(pi));
   let state = null;
+  let sessionCtx = null;
   let initPromise = null;
   let initStartedPromise = null;
   let currentOwner = null;
@@ -224,7 +251,8 @@ function installMcpAdapter(pi, options) {
     restoreSessionApprovalState(targetState, branch);
   }
   const earlyConfigPath = programmaticConfig ? undefined : options.configPath ?? getConfigPathFromArgv();
-  const earlyConfig = programmaticConfig ? resolveConfiguredClaudePluginMcp(cloneMcpConfig(sessionConfig), process.cwd()) : loadMcpConfig(earlyConfigPath);
+  const earlyConfig = programmaticConfig ? resolveConfiguredClaudePluginMcp(cloneMcpConfig(sessionConfig), process.cwd()) : excludeProjectServersAtLoadTime(loadMcpConfig(earlyConfigPath));
+  const scriptTool = earlyConfig.settings?.scriptMode === true;
   const earlyCache = loadMetadataCache();
   const envRaw = process.env.MCP_DIRECT_TOOLS;
   const envDirectToolOverride = parseEnvDirectToolOverride(envRaw);
@@ -238,6 +266,8 @@ function installMcpAdapter(pi, options) {
   const fallbackDeactivatedTools = new Set;
   const lazyDirectTools = new Set;
   const searchActivatedTools = new Set;
+  const deferSearchTools = piSupportsMcp(pi);
+  const deferredToolDefinitions = new Map;
   const toolRenderOptions = resolveMcpToolRenderOptions(earlyConfig.settings);
   const toolRenderShell = toolRenderOptions.resultRendering === "compact" ? "self" : "default";
   const renderMcpToolResult = createMcpToolResultRenderer(toolRenderOptions);
@@ -245,7 +275,10 @@ function installMcpAdapter(pi, options) {
   let proxyToolDescription = null;
   let directToolsFrozen = false;
   let largeDirectToolsAdvisoryDelivered = false;
+  let sessionMigrationNotices = [];
   const runtimeServers = new Map;
+  let piRegistered = [];
+  const piServers = new Map;
   function attachRuntimeServerLifecycle(targetState, name, definition) {
     const lifecycleMode = definition.lifecycle ?? "lazy";
     const persistsAfterFirstSpawn = lifecycleMode === "eager" || lifecycleMode === "lazy-keep-alive";
@@ -254,7 +287,6 @@ function installMcpAdapter(pi, options) {
     if (lifecycleMode === "keep-alive")
       targetState.lifecycle.markKeepAlive(name, definition);
   }
-  const toToolParameters = (schema) => typeof Type.Unsafe === "function" ? Type.Unsafe(schema) : schema;
   function directToolFingerprint(spec) {
     return JSON.stringify({
       serverName: spec.serverName,
@@ -268,6 +300,34 @@ function installMcpAdapter(pi, options) {
       lazy: spec.lazy === true
     });
   }
+  function deferredToolFields(spec, config, cache) {
+    if (!deferSearchTools || !spec.lazy)
+      return;
+    const serverCache = cache?.servers[spec.serverName];
+    const tool = spec.resourceUri ? undefined : serverCache?.tools?.find((candidate) => candidate.name === spec.originalName);
+    const description = config.mcpServers[spec.serverName]?.description?.trim();
+    const instructions = serverCache?.instructions;
+    const { title: _title, ...annotations } = tool?.annotations ?? {};
+    return {
+      exposure: "deferred",
+      namespace: {
+        name: `mcp__${spec.serverName.replace(/-/g, "_")}`,
+        ...description ? { description } : {},
+        ...instructions ? { instructions } : {}
+      },
+      ...Object.keys(annotations).length > 0 ? { annotations } : {},
+      outputSchema: {
+        type: "object",
+        properties: {
+          content: { type: "array", items: { type: "object" } },
+          ...tool?.outputSchema !== undefined ? { structuredContent: tool.outputSchema } : {},
+          isError: { type: "boolean" },
+          _meta: { type: "object" }
+        },
+        required: ["content"]
+      }
+    };
+  }
   function forgetReportedDirectToolName(serverName, toolName) {
     if (!serverName)
       return;
@@ -278,15 +338,16 @@ function installMcpAdapter(pi, options) {
     if (reportedNames.size === 0)
       reportedDirectToolNamesByServer.delete(serverName);
   }
-  function registerDirectTool(spec, config) {
+  function registerDirectTool(spec, config, deferred) {
     finalizationRegistrations?.add(spec.prefixedName);
-    callReentrant(() => pi.registerTool({
+    const definition = {
       name: spec.prefixedName,
       label: `MCP: ${spec.originalName}`,
       description: spec.description || "(no description)",
       promptSnippet: truncateAtWord(spec.description, 100) || `MCP tool from ${spec.serverName}`,
       parameters: toToolParameters(normalizeDirectToolInputSchema(spec.inputSchema)),
       ...config.settings?.strictDirectToolArguments === true ? { prepareArguments: (args) => prepareDirectToolArguments(spec.inputSchema, args) } : {},
+      ...deferred,
       async execute(toolCallId, params, signal, onUpdate, ctx) {
         let executor;
         let guard;
@@ -297,7 +358,7 @@ function installMcpAdapter(pi, options) {
           guard = captureRuntimeGuard(targetState);
           const executionGuard = guard;
           const { createDirectToolExecutor } = await loadForRuntime(loadDirectExecution, executionGuard);
-          executor = createDirectToolExecutor(() => executionGuard.state, () => initPromise, spec);
+          executor = createDirectToolExecutor(() => executionGuard.state, () => initPromise, spec, deferred !== undefined);
         } catch (error) {
           if (guard && (isRuntimeGuardStale(guard) || guard.owner && isOwnerAbortError(error, guard.owner)))
             throw error;
@@ -315,10 +376,19 @@ function installMcpAdapter(pi, options) {
       renderShell: toolRenderShell,
       renderCall: createMcpDirectToolCallRenderer(spec.prefixedName, toolRenderOptions),
       renderResult: renderMcpToolResult
-    }));
+    };
+    if (deferred) {
+      const run = definition.execute;
+      definition.execute = async (...args) => toCallToolResult(await run(...args));
+    }
+    callReentrant(() => pi.registerTool(definition));
+    if (deferred)
+      deferredToolDefinitions.set(spec.prefixedName, definition);
+    else
+      deferredToolDefinitions.delete(spec.prefixedName);
   }
   function holdLazyToolsInactive() {
-    if (lazyDirectTools.size === 0)
+    if (deferSearchTools || lazyDirectTools.size === 0)
       return;
     const activeTools = getActiveToolsIfReady();
     if (!activeTools)
@@ -375,6 +445,13 @@ function installMcpAdapter(pi, options) {
     const unregisterTool = pi.unregisterTool;
     const unregistered = toolNames.filter((toolName) => callReentrant(() => unregisterTool?.(toolName)) === true);
     const fallbackNames = toolNames.filter((toolName) => !unregistered.includes(toolName));
+    for (const toolName of fallbackNames) {
+      const definition = deferredToolDefinitions.get(toolName);
+      if (!definition)
+        continue;
+      deferredToolDefinitions.delete(toolName);
+      callReentrant(() => pi.registerTool({ ...definition, exposure: "hidden" }));
+    }
     const activeTools = getActiveToolsIfReady();
     if (!activeTools)
       return unregistered;
@@ -396,11 +473,12 @@ function installMcpAdapter(pi, options) {
     const updated = [];
     const deactivated = [];
     for (const spec of specs) {
-      const fingerprint = directToolFingerprint(spec);
+      const deferred = deferredToolFields(spec, config, cache);
+      const fingerprint = directToolFingerprint(spec) + (deferred ? JSON.stringify(deferred) : "");
       const previous = registeredDirectTools.get(spec.prefixedName);
       if (previous !== fingerprint) {
         const previousServer = registeredDirectToolServers.get(spec.prefixedName);
-        registerDirectTool(spec, config);
+        registerDirectTool(spec, config, deferred);
         finalizationGuard?.();
         registeredDirectTools.set(spec.prefixedName, fingerprint);
         registeredDirectToolServers.set(spec.prefixedName, spec.serverName);
@@ -417,6 +495,12 @@ function installMcpAdapter(pi, options) {
         (previous ? updated : added).push(spec.prefixedName);
       }
       if (spec.lazy) {
+        if (deferSearchTools && previous !== undefined && !lazyDirectTools.has(spec.prefixedName)) {
+          const activeTools = getActiveToolsIfReady();
+          if (activeTools?.includes(spec.prefixedName)) {
+            callReentrant(() => pi.setActiveTools(activeTools.filter((name) => name !== spec.prefixedName)));
+          }
+        }
         lazyDirectTools.add(spec.prefixedName);
       } else if (lazyDirectTools.delete(spec.prefixedName)) {
         searchActivatedTools.delete(spec.prefixedName);
@@ -453,22 +537,19 @@ function installMcpAdapter(pi, options) {
   function loadToolSurfaceCache(config) {
     const cache = loadMetadataCache();
     const currentState = state;
-    if (!currentState || !cache)
+    if (!currentState?.sessionMetadata?.size)
       return cache;
-    const servers = { ...cache.servers };
-    const connections = callReentrant(() => [...currentState.manager.getAllConnections()]);
-    for (const [serverName, connection] of connections) {
+    const servers = { ...cache?.servers };
+    for (const [serverName, entry] of currentState.sessionMetadata) {
       const definition = config.mcpServers[serverName];
-      const entry = servers[serverName];
-      if (connection.status !== "connected" || !entry || !definition || isServerDisabled(definition))
+      if (!definition || isServerDisabled(definition))
         continue;
-      const configHash = computeServerHash(definition);
-      if (computeServerHash(connection.definition) !== configHash || entry.configHash !== configHash)
+      if (entry.configHash !== computeServerHash(definition))
         continue;
-      const { ttlMs: _liveTtl, ...liveEntry } = entry;
-      servers[serverName] = liveEntry;
+      const { ttlMs: _sessionTtl, cacheScope: _sessionScope, ...sessionEntry } = entry;
+      servers[serverName] = { ...sessionEntry, cachedAt: Date.now() };
     }
-    return { ...cache, servers };
+    return { version: 1, servers };
   }
   function syncToolSurface(ctx) {
     const notificationGeneration = lifecycleGeneration;
@@ -510,7 +591,15 @@ function installMcpAdapter(pi, options) {
     }
   }
   function getDeferredSessionSnapshot(cwd) {
-    const config = programmaticConfig ? resolveConfiguredClaudePluginMcp(cloneMcpConfig(sessionConfig), cwd ?? process.cwd()) : loadMcpConfig(earlyConfigPath, cwd);
+    let config;
+    if (programmaticConfig) {
+      config = resolveConfiguredClaudePluginMcp(cloneMcpConfig(sessionConfig), cwd ?? process.cwd());
+    } else {
+      const loadedConfig = loadMcpConfig(earlyConfigPath, cwd);
+      if (hasProjectServerDefinitions(loadedConfig))
+        return;
+      config = loadedConfig;
+    }
     const cache = loadMetadataCache();
     const enabledServers = Object.values(config.mcpServers).filter((definition) => !isServerDisabled(definition));
     if (enabledServers.some((definition) => definition.lifecycle === "eager" || definition.lifecycle === "keep-alive"))
@@ -530,6 +619,7 @@ function installMcpAdapter(pi, options) {
       activeDirectNames,
       existingNamespaceNames: registeredNamespaceProxyTools,
       unavailableServers: activeFailureServers(),
+      fallbackDeactivatedNames: fallbackDeactivatedTools,
       pi,
       getState: () => state,
       getInitPromise: () => initPromise,
@@ -644,7 +734,27 @@ function installMcpAdapter(pi, options) {
       persisted: false
     };
   };
-  runtimeRegistrars.set(pi, registerRuntimeServer);
+  const registerAdapterServer = (name, definition) => {
+    if (piSupportsMcp(pi) && !piServers.has(name) && pi.getMcpServers().some((server) => server.name === name)) {
+      throw new Error(`MCP server "${name}" is already registered`);
+    }
+    const registration = registerRuntimeServer(name, definition);
+    return {
+      dispose: async () => {
+        try {
+          await registration.dispose();
+        } finally {
+          const activeState = state;
+          const ctx = sessionCtx;
+          if (activeState && ctx && piServers.get(name)?.registration === null && !Object.hasOwn(activeState.config.mcpServers, name)) {
+            piServers.delete(name);
+            await callReentrant(() => applyPiMcpServers(activeState, ctx));
+          }
+        }
+      }
+    };
+  };
+  runtimeRegistrars.set(pi, registerAdapterServer);
   runtimeSnapshotters.set(pi, getRuntimeServerSnapshot);
   pi.events.on(MCP_RUNTIME_REGISTER_EVENT, (rawRequest) => {
     if (typeof rawRequest !== "object" || rawRequest === null || Array.isArray(rawRequest))
@@ -657,7 +767,7 @@ function installMcpAdapter(pi, options) {
       return;
     }
     try {
-      request.result = { ok: true, registration: registerRuntimeServer(request.name, request.definition) };
+      request.result = { ok: true, registration: registerAdapterServer(request.name, request.definition) };
     } catch (error) {
       request.result = { ok: false, error: error instanceof Error ? error : new Error(String(error)) };
     }
@@ -678,12 +788,118 @@ function installMcpAdapter(pi, options) {
       request.result = { ok: false, error: error instanceof Error ? error : new Error(String(error)) };
     }
   });
+  pi.events.on(MCP_RUNTIME_TOOL_CALL_EVENT, (rawRequest) => {
+    if (typeof rawRequest !== "object" || rawRequest === null || Array.isArray(rawRequest))
+      return;
+    const request = rawRequest;
+    if (request.result !== undefined)
+      return;
+    const ctx = sessionCtx;
+    request.result = (async () => {
+      try {
+        if (request.version !== MCP_RUNTIME_TOOL_CALL_VERSION) {
+          throw new Error(`Unsupported MCP runtime tool-call version: ${String(request.version)}`);
+        }
+        if (typeof request.tool !== "string" || request.tool.trim() === "") {
+          throw new Error("MCP runtime tool-call requires a non-empty `tool` name");
+        }
+        if (!ctx)
+          throw new Error("MCP runtime tool calls require an active DM session");
+        const callState = await awaitWithTimeout(ensureSessionRuntime(ctx), INIT_WAIT_TIMEOUT_MS);
+        if (callState === INIT_WAIT_TIMED_OUT) {
+          throw new Error(`MCP initialization is still in progress after ${INIT_WAIT_TIMEOUT_MS}ms`);
+        }
+        if (!callState)
+          throw new Error("MCP is not initialized");
+        const guard = captureRuntimeGuard(callState);
+        const { executeCall } = await loadForRuntime(loadProxyModes, guard);
+        const result = await executeCall(callState, request.tool, request.args, request.server, getPiTools, undefined, "script");
+        assertRuntimeGuard(guard);
+        const failure = result.details?.error;
+        if (failure !== undefined)
+          return { ok: false, error: new Error(`MCP tool call failed: ${String(failure)}`) };
+        return { ok: true, result };
+      } catch (error) {
+        return { ok: false, error: error instanceof Error ? error : new Error(String(error)) };
+      }
+    })();
+  });
+  registerProtocolBridge(pi, async (name) => {
+    if (!sessionCtx)
+      throw new Error("MCP connections require an active DM session");
+    const target = await ensureSessionRuntime(sessionCtx);
+    if (!target)
+      throw new Error("MCP is not initialized");
+    const guard = captureRuntimeGuard(target);
+    const definition = target.config.mcpServers[name];
+    if (!Object.hasOwn(target.config.mcpServers, name) || !definition || isServerDisabled(definition)) {
+      throw new Error("MCP server is not configured or enabled");
+    }
+    const core = await loadForRuntime(loadCoreRuntime, guard);
+    if (!await core.lazyConnect(target, name, target.owner.signal))
+      throw new Error("MCP server could not connect; check /mcp-adapter");
+    assertRuntimeGuard(guard);
+    if (target.config.mcpServers[name] !== definition || isServerDisabled(definition)) {
+      throw new Error("MCP server configuration changed while connecting");
+    }
+    const connection = target.manager.getConnection(name);
+    if (!connection || connection.status !== "connected")
+      throw new Error("MCP connection is unavailable");
+    return { connection, signal: target.owner.signal };
+  });
+  function applyPiMcpServers(activeState, ctx) {
+    const next = new Map(piRegistered.map((server) => [server.name, JSON.stringify(server.config)]));
+    const disposals = [];
+    for (const [name, applied] of piServers) {
+      if (next.get(name) === applied.config)
+        continue;
+      piServers.delete(name);
+      if (applied.registration)
+        disposals.push(applied.registration.dispose());
+    }
+    const report = (message) => ctx.hasUI ? ctx.ui.notify(message, "warning") : console.warn(`MCP: ${message}`);
+    const configured = activeState.config.mcpServers;
+    for (const { name, config, extensionPath } of piRegistered) {
+      if (piServers.has(name))
+        continue;
+      const label = `MCP server "${name}" registered by ${extensionPath}`;
+      const translated = translatePiMcpServer(name, config);
+      let registration = null;
+      if (typeof translated === "string") {
+        report(`${label} is not connected: ${translated}.`);
+      } else if (Object.hasOwn(configured, name) && configured[name] !== runtimeServers.get(name)?.entry) {
+        report(`${label} is overridden by the configured server of the same name.`);
+      } else if (runtimeServers.has(name)) {
+        report(`${label} is overridden by the server registered earlier with dm-mcp-adapter's registerMcpServer().`);
+      } else {
+        const { directTools, ...entry } = translated.entry;
+        const ignored = [
+          ...translated.ignored,
+          ...Array.isArray(directTools) ? directTools.map((tool) => `toolExposure ${JSON.stringify(tool)}: direct`) : directTools !== undefined ? [`exposure: ${config.exposure}`] : []
+        ];
+        if (ignored.length > 0)
+          report(`${label}: ignored settings ${ignored.join(", ")}.`);
+        registration = registerRuntimeServer(name, entry);
+      }
+      piServers.set(name, { config: JSON.stringify(config), registration });
+    }
+    return Promise.all(disposals).then(() => {
+      return;
+    });
+  }
+  if (piSupportsMcp(pi)) {
+    pi.on("mcp_servers_change", async (event, ctx) => {
+      piRegistered = event.servers;
+      if (state)
+        await applyPiMcpServers(state, ctx);
+    });
+  }
   const getPiTools = () => pi.getAllTools();
   pi.registerFlag("mcp-config", {
     description: "Path to MCP config file",
     type: "string"
   });
-  function startInitialization(ctx, owner, generation, staleReason) {
+  function startInitialization(ctx, owner, generation, staleReason, excludeProjectServers = false) {
     let oauthRuntime = null;
     let markStarted;
     initStartedPromise = new Promise((resolve) => {
@@ -711,25 +927,20 @@ function installMcpAdapter(pi, options) {
       }
       currentOAuthRuntime = oauthRuntime;
       assertRuntimeGuard(guard);
-      owner.addCleanup(async () => {
-        const { cleanupMaterializedBinaryResources } = await import("./tool-registrar.js");
-        cleanupMaterializedBinaryResources(owner.signal);
-      });
+      owner.addCleanup(() => cleanupMaterializedBinaryResources(owner.signal));
       assertRuntimeGuard(guard);
       const initialization = core.initializeMcp(pi, ctx, owner, {
         ...programmaticConfig || options.configPath !== undefined ? {
           ...earlyConfigPath !== undefined ? { configPath: earlyConfigPath } : {},
           ...sessionConfig !== undefined ? { config: sessionConfig } : {}
         } : {},
-        oauthRuntime
+        oauthRuntime,
+        excludeProjectServers,
+        onProjectTrustResolved: markStarted
       });
       assertRuntimeGuard(guard);
-      markStarted();
       return initialization;
-    })().catch((error) => {
-      markStarted();
-      throw error;
-    }).then((value) => value);
+    })().finally(markStarted);
     let promise;
     promise = initializationPromise.then(async (nextState) => {
       if (!owner.isActive() || generation !== lifecycleGeneration || initPromise !== promise) {
@@ -748,12 +959,17 @@ function installMcpAdapter(pi, options) {
       };
       const registeredDuringFinalization = new Set;
       let statusPublicationAttempted = false;
+      nextState.scriptTool = scriptTool;
       state = nextState;
+      nextState.migrationNotices = [...sessionMigrationNotices];
       finalizationGuard = guard;
       finalizationRegistrations = registeredDuringFinalization;
       try {
         guard();
         callReentrant(() => restoreCurrentSessionApprovals(nextState));
+        for (const { registration } of piServers.values())
+          registration?.dispose();
+        piServers.clear();
         for (const [name, { entry }] of runtimeServers) {
           guard();
           if (Object.hasOwn(nextState.config.mcpServers, name)) {
@@ -765,6 +981,8 @@ function installMcpAdapter(pi, options) {
           callReentrant(() => attachRuntimeServerLifecycle(nextState, name, entry));
         }
         guard();
+        callReentrant(() => applyPiMcpServers(nextState, ctx));
+        guard();
         nextState.onToolMetadataUpdated = (_serverName, _reason) => {
           if (state !== nextState || !owner.isActive())
             return;
@@ -888,21 +1106,25 @@ function installMcpAdapter(pi, options) {
         model: undefined,
         modelRegistry: undefined,
         signal: undefined
-      }, owner, generation, "stale_load_time_initialization");
+      }, owner, generation, "stale_load_time_initialization", true);
     });
   }
+  const scriptingSkillPath = fileURLToPath(new URL("./skills/mcp-scripting/SKILL.md", import.meta.url));
   pi.on("resources_discover", (event) => {
     const resourceConfig = programmaticConfig ? cloneMcpConfig(sessionConfig) : loadMcpConfig(earlyConfigPath, event.cwd);
     const skillPaths = discoverConfiguredClaudePluginSkills(resourceConfig, event.cwd);
-    if (earlyConfig.settings?.scriptMode !== false) {
-      const scriptingSkillPath = fileURLToPath(new URL("./skills/mcp-scripting/SKILL.md", import.meta.url));
-      if (existsSync(scriptingSkillPath) && !skillPaths.includes(scriptingSkillPath)) {
-        skillPaths.push(scriptingSkillPath);
-      }
+    if (scriptTool && existsSync(scriptingSkillPath) && !skillPaths.includes(scriptingSkillPath)) {
+      skillPaths.push(scriptingSkillPath);
     }
     return skillPaths.length > 0 ? { skillPaths } : undefined;
   });
   pi.on("session_start", async (_event, ctx) => {
+    sessionCtx = null;
+    sessionMigrationNotices = programmaticConfig ? [] : getLegacyMcpMigrationNotices(ctx.cwd, earlyConfigPath);
+    if (ctx.hasUI) {
+      for (const notice of sessionMigrationNotices)
+        ctx.ui.notify(notice, "warning");
+    }
     searchActivatedTools.clear();
     holdLazyToolsInactive();
     const generation = ++lifecycleGeneration;
@@ -917,6 +1139,8 @@ function installMcpAdapter(pi, options) {
     initPromise = null;
     initStartedPromise = null;
     clearRetainedInitFailure();
+    if (piSupportsMcp(pi))
+      piRegistered = pi.getMcpServers();
     const stopPrevious = previousOwner?.stop("MCP extension session restarted") ?? Promise.resolve();
     try {
       await Promise.all([
@@ -929,6 +1153,31 @@ function installMcpAdapter(pi, options) {
     }
     if (generation !== lifecycleGeneration || !owner.isActive())
       return;
+    if (!programmaticConfig && earlyConfigPath === undefined && piSupportsMcp(pi)) {
+      const report = (message, level) => {
+        if (generation !== lifecycleGeneration || !owner.isActive())
+          return;
+        if (ctx.hasUI)
+          ctx.ui.notify(message, level);
+        else
+          console.error(message);
+      };
+      import("./pi-builtin-mcp.js").then(({ turnOffPiBuiltinMcp }) => turnOffPiBuiltinMcp()).then((turnedOff) => {
+        if (turnedOff)
+          report("Turned off the host's built-in MCP so it doesn't run next to dm-mcp-adapter. If you remove the adapter, turn it back on in the host's extension settings.", "info");
+      }).catch((error) => report(`MCP: could not turn off DM's built-in MCP: ${formatTerminalError(error)}`, "warning"));
+    }
+    if (ctx.hasUI && !programmaticConfig && existsSync(getPiMcpAuthPath())) {
+      try {
+        const { offerPiSignInImports } = await import("./pi-signin-import.js");
+        await offerPiSignInImports(ctx, excludeProjectServersAtLoadTime(loadMcpConfig(earlyConfigPath, ctx.cwd)), owner.signal);
+      } catch (error) {
+        console.error(`MCP: could not offer DM sign-in import: ${formatTerminalError(error)}`);
+      }
+      if (generation !== lifecycleGeneration || !owner.isActive())
+        return;
+    }
+    sessionCtx = ctx;
     if (state)
       return;
     if (!initPromise) {
@@ -1007,6 +1256,7 @@ function installMcpAdapter(pi, options) {
     }
   });
   pi.on("session_shutdown", async () => {
+    sessionCtx = null;
     ++lifecycleGeneration;
     const currentState = state;
     const owner = currentOwner;
@@ -1136,7 +1386,7 @@ function installMcpAdapter(pi, options) {
         }
         case "jev": {
           if (parts[1] !== "setup" || parts.length !== 2) {
-            commandCtx.ui?.notify("Usage: /mcp jev setup", "error");
+            commandCtx.ui?.notify("Usage: /mcp-adapter jev setup", "error");
             break;
           }
           if (programmaticConfig) {
@@ -1158,7 +1408,7 @@ function installMcpAdapter(pi, options) {
           }
           const target = parts[1] ?? "project";
           if (target !== "project" && target !== "global") {
-            commandCtx.ui?.notify("Usage: /mcp edit [project|global]", "error");
+            commandCtx.ui?.notify("Usage: /mcp-adapter edit [project|global]", "error");
             return;
           }
           commandOwner?.throwIfInactive();
@@ -1173,7 +1423,7 @@ function installMcpAdapter(pi, options) {
           const serverName = rest;
           if (!serverName) {
             if (commandCtx.hasUI)
-              commandCtx.ui?.notify("Usage: /mcp logout <server>", "error");
+              commandCtx.ui?.notify("Usage: /mcp-adapter logout <server>", "error");
             return;
           }
           commandOwner?.throwIfInactive();
@@ -1185,12 +1435,12 @@ function installMcpAdapter(pi, options) {
           const serverName = parts.slice(2).join(" ");
           if (action !== "set" && action !== "remove" && action !== "status") {
             if (commandCtx.hasUI)
-              commandCtx.ui?.notify("Usage: /mcp token set|remove|status <server>", "error");
+              commandCtx.ui?.notify("Usage: /mcp-adapter token set|remove|status <server>", "error");
             return;
           }
           if (!serverName) {
             if (commandCtx.hasUI)
-              commandCtx.ui?.notify("Usage: /mcp token set|remove|status <server>", "error");
+              commandCtx.ui?.notify("Usage: /mcp-adapter token set|remove|status <server>", "error");
             return;
           }
           commandOwner?.throwIfInactive();
@@ -1201,11 +1451,11 @@ function installMcpAdapter(pi, options) {
         case "enable": {
           const serverName = rest;
           if (programmaticConfig) {
-            commandCtx.ui?.notify(`/mcp ${subcommand} is unavailable when config is supplied by createMcpAdapter().`, "info");
+            commandCtx.ui?.notify(`/mcp-adapter ${subcommand} is unavailable when config is supplied by createMcpAdapter().`, "info");
             break;
           }
           if (!serverName) {
-            commandCtx.ui?.notify(`Usage: /mcp ${subcommand} <server>`, "error");
+            commandCtx.ui?.notify(`Usage: /mcp-adapter ${subcommand} <server>`, "error");
             break;
           }
           if (!state.config.mcpServers[serverName]) {
@@ -1222,6 +1472,8 @@ function installMcpAdapter(pi, options) {
           break;
         }
         case "status":
+          await commands.showStatus(state, commandCtx);
+          break;
         case "":
         default:
           if (commandCtx.hasUI) {
@@ -1247,9 +1499,19 @@ function installMcpAdapter(pi, options) {
       }
     }
   });
-  registerMcpCommand("mcp");
+  registerMcpCommand("mcp-adapter");
   registerMcpCommand("dm-mcp");
   registerMcpCommand("pi-mcp");
+  if (!programmaticConfig || !piSupportsMcp(pi))
+    registerMcpCommand("mcp");
+  if (!programmaticConfig) {
+    for (const key of readPanelOpenKeys(getAgentPath("keybindings.json"))) {
+      pi.registerShortcut(key, {
+        description: "Open the MCP panel",
+        handler: () => pi.sendUserMessage("/mcp-adapter")
+      });
+    }
+  }
   pi.registerCommand("mcp-auth", {
     description: "Authenticate with an MCP server (OAuth)",
     handler: async (args, ctx) => {
@@ -1304,14 +1566,15 @@ function installMcpAdapter(pi, options) {
       }
     }
   });
-  if (earlyConfig.settings?.scriptMode !== false) {
+  if (scriptTool) {
+    const skillPointer = earlyConfig.settings?.scriptSkill === "model" ? ` Before writing a script, read ${scriptingSkillPath} for result shapes and limits.` : "";
     pi.registerTool({
       name: "mcpScript",
       label: "MCP Script",
-      description: "Run trusted JavaScript that makes multiple MCP tool calls in one request — loop, filter, chain, or fan out between calls. For a single MCP call, search, describe, status check, or auth action, use the mcp tool instead. Discover with await tools.search({ query }) — resolves to { items: [{ path, name, server, description? }], total, hasMore, nextOffset }, not an { ok, data } envelope. Inspect with await tools.describe({ path }) — resolves to the tool descriptor with inputTypeScript, or { path, error: { code, message, suggestions } }. Then call tools.call(path, args) — resolves to { ok: true, data } or { ok: false, error: { code, message } } — or use direct flat calls when the name is already known; use emit(value) for user-visible output.",
+      description: "Run sandboxed JavaScript to loop, filter, chain, or fan out across multiple MCP calls in one request. Use mcp for a single call, search, describe, status, or auth. await tools.search({ query }) returns { items: [{ path, name, server, description? }], total, hasMore, nextOffset }, not { ok, data }. await tools.describe({ path }) returns a descriptor with inputTypeScript or { path, error: { code, message, suggestions } }. tools.call(path, args) and tools.<path>(args) return { ok: true, data } or { ok: false, error: { code, message } }. data is the raw MCP result { content, structuredContent? }: use data.structuredContent when present; otherwise JSON usually needs JSON.parse(data.content[0].text). Use emit(value) for user-visible output." + skillPointer,
       promptSnippet: "Batch multiple MCP tool calls in one JavaScript request (loop, filter, chain)",
       parameters: Type.Object({
-        code: Type.String({ description: "Trusted JavaScript MCP script. Use tools.<prefixedToolName>(args) and emit(value)." }),
+        code: Type.String({ description: 'Sandboxed JavaScript MCP script. Pass tool names exactly as mcp lists them, e.g. tools.call("github_search_issues", args), and use emit(value).' }),
         timeoutMs: optionalNumber({ minimum: 1, description: "Execution timeout in milliseconds (default: 30000)" })
       }),
       renderCall: createMcpScriptToolCallRenderer(toolRenderOptions),
@@ -1371,7 +1634,7 @@ function installMcpAdapter(pi, options) {
     reportedDirectToolNamesByServer.set(serverName, reportedNames);
     return { ...result, addedToolNames };
   }
-  async function executeInstall(targetState, rawUrl, requestedName, target, cwd, signal) {
+  async function executeInstall(targetState, rawUrl, requestedName, target, cwd, ctx, signal) {
     const installOwner = currentOwner;
     signal?.throwIfAborted();
     installOwner?.throwIfInactive();
@@ -1436,6 +1699,18 @@ function installMcpAdapter(pi, options) {
         details: { mode: "install", error: "runtime_promotion_unsupported", server: serverName }
       };
     }
+    if (target === "project") {
+      const trusted = ctx.isProjectTrusted();
+      const allowed = trusted && (ctx.hasUI ? await ctx.ui.confirm(`Install project MCP server “${serverName}”?`, `Endpoint: ${normalized.url}
+
+This project server can make network requests with your user permissions.`) : targetState.config.settings?.projectServers === "allow");
+      if (!allowed) {
+        return {
+          content: [{ type: "text", text: trusted ? `Project MCP server "${serverName}" requires interactive approval or user-global settings.projectServers: "allow".` : `Project MCP server "${serverName}" is blocked because the project is not trusted.` }],
+          details: { mode: "install", error: "project_trust_required", server: serverName }
+        };
+      }
+    }
     const persistedEntry = { url: normalized.url };
     const runtimeEntry = existing ?? { ...persistedEntry, directTools: false };
     const provisional = existing === undefined;
@@ -1516,6 +1791,10 @@ function installMcpAdapter(pi, options) {
         };
       }
       targetState.provisionalInstalls?.delete(serverName);
+      if (target === "project" && targetState.blockedProjectServers !== undefined) {
+        const effective = loadMcpConfig(earlyConfigPath, cwd).mcpServers[serverName] ?? persistedEntry;
+        approveProjectServer(cwd, serverName, effective);
+      }
       try {
         (await loadForRuntime(loadCoreRuntime, installGuard)).updateMetadataCache(targetState, serverName);
         assertRuntimeGuard(installGuard);
@@ -1598,7 +1877,7 @@ ${connectText ?? ""}`.trim()
         target: Type.Optional(Type.String({ description: "Install target: 'global' (default) or 'project'" }))
       }),
       renderResult: renderMcpToolResult,
-      async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
+      async execute(toolCallId, params, signal, _onUpdate, _ctx) {
         let executeOwner = currentOwner;
         const parseArgs = (value) => {
           if (value === undefined || value === "")
@@ -1666,7 +1945,7 @@ ${connectText ?? ""}`.trim()
         const proxyGuard = captureRuntimeGuard(proxyState);
         const proxyModes = await loadForRuntime(loadProxyModes, proxyGuard);
         if (params.action === "install") {
-          return executeInstall(proxyState, params.url, params.server, params.target, _ctx.cwd, signal);
+          return executeInstall(proxyState, params.url, params.server, params.target, _ctx.cwd, _ctx, signal);
         }
         if (params.action === "ui-messages") {
           return proxyModes.executeUiMessages(proxyState);
@@ -1697,7 +1976,18 @@ ${connectText ?? ""}`.trim()
           return signal ? proxyModes.executeAuthComplete(proxyState, params.server, input, signal) : proxyModes.executeAuthComplete(proxyState, params.server, input);
         }
         if (params.tool) {
-          return proxyModes.executeCall(proxyState, params.tool, parsedArgs, params.server, getPiTools, signal);
+          const result = await proxyModes.executeCall(proxyState, params.tool, parsedArgs, params.server, getPiTools, signal, undefined, undefined, toolCallId);
+          assertRuntimeGuard(proxyGuard);
+          if (lazyDirectTools.size === 0)
+            return result;
+          const identity = result.details;
+          if (!identity || identity.error !== undefined || typeof identity.server !== "string" || typeof identity.canonicalTool !== "string")
+            return result;
+          holdLazyToolsInactive();
+          const added = activateSearchMatches([{ server: identity.server, tool: identity.canonicalTool }]);
+          if (added.length === 0)
+            return result;
+          return { ...result, details: { ...result.details ?? {}, activated: added }, addedToolNames: added };
         }
         if (params.connect) {
           return connectAndReport(proxyState, params.connect, signal, _ctx);
@@ -1743,7 +2033,7 @@ ${text}` }],
     const hasSearchModeSpecs = directSpecs.some((spec) => spec.lazy === true);
     const shouldRegisterProxyTool = config.settings?.disableProxyTool !== true || directSpecs.length === 0 || hasSearchModeSpecs || missingConfiguredDirectToolServers.length > 0 || hasEnabledServerWithoutValidMetadata(config, cache, directSpecs);
     if (shouldRegisterProxyTool) {
-      const description = buildProxyDescription(config);
+      const description = buildProxyDescription(config, scriptTool);
       if (!proxyToolRegistered || proxyToolDescription !== description) {
         finalizationRegistrations?.add("mcp");
         registerProxyTool(description);