mixdog 1.2.0 → 1.2.1

package/src/session-runtime/resource-mcp-api.mjs

@@ -1,51 +1,25 @@
-// MCP server configuration: add/save/remove/toggle plus the plugin-declared
-// servers a plugin's manifest or script contributes.
-import { join } from 'node:path';
-import { existsSync } from 'node:fs';
+// MCP server configuration: add/save/remove/toggle of the user's servers, and
+// the per-server intent (enabled flag) of servers registered plugins declare.
+// Plugin servers are derived live (mcp-glue/plugin-servers.mjs) and are never
+// written into `mcpServers`; ordinary edits refuse them.
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import {
-  normalizePluginMcpServerConfig,
-  pluginMcpServerName,
-  pluginRawMcpServers,
-  pluginMcpEnableScript,
-  pluginServerMatcher,
-  resolveContainedPluginPath,
   mergeMcpServerConfig,
   MCP_TIMEOUT_FIELD_GROUPS,
 } from '../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
+import { withAdoptedCopies, withPinnedCollisionNames, withPluginServerIntent } from './mcp-glue/plugin-servers.mjs';
+import { findRegisteredPlugin } from './resource-plugins-api.mjs';
 
 /** The `mcpServers` map of a config as a fresh object (never the live one). */
 function mcpServersOf(config) {
   return config.mcpServers && typeof config.mcpServers === 'object' ? { ...config.mcpServers } : {};
 }
 
-function pluginMcpEnv(pluginDataDir, plugin, serverName) {
-  return {
-    MIXDOG_PLUGIN_ROOT: clean(plugin.root),
-    MIXDOG_PLUGIN_DATA: join(pluginDataDir, 'plugins', 'data', clean(plugin.id || plugin.name || serverName)),
-  };
-}
-
-// Manifest-declared servers replace every entry the plugin owned before; a
-// single server keeps the bare name.
-function manifestPluginMcpServers(existing, { rawServers, mcpRoot }, { plugin, serverName, env }) {
-  const keys = Object.keys(rawServers).filter((k) => {
-    const v = rawServers[k];
-    return v !== null && typeof v === 'object' && !Array.isArray(v);
-  });
-  const owned = pluginServerMatcher(serverName);
-  const nextServers = {};
-  for (const [k, v] of Object.entries(existing || {})) {
-    if (owned(k)) continue;
-    nextServers[k] = v;
-  }
-  for (const serverKey of keys) {
-    const cfg = normalizePluginMcpServerConfig(rawServers[serverKey], mcpRoot);
-    cfg.env = { ...(cfg.env || {}), ...env };
-    if (plugin.enabled === false) cfg._mixdogPluginDisabled = true;
-    nextServers[keys.length === 1 ? serverName : `${serverName}--${serverKey}`] = cfg;
-  }
-  return nextServers;
+function pluginOwnedError(name, owner) {
+  return new Error(
+    `MCP server "${name}" is provided by plugin "${owner.id}" (server "${owner.key}"); ` +
+      'enable or disable it with set_mcp_enabled, or manage the plugin instead'
+  );
 }
 
 const transportType = (type) => (type === 'streamable-http' ? 'http' : type);
@@ -80,24 +54,53 @@ function mergedServerInput(input, existing, originalName) {
 export function createMcpResourceApi({ deps, sync, decorate }) {
   const {
     getConfig,
-    cfgMod,
-    STANDALONE_DATA_DIR,
     saveConfigAndAdopt,
     normalizeMcpServerInput,
     mcpStatus,
     getMcpServerConfig,
+    connectConfiguredMcp,
     reloadFullConfig,
     awaitKeychainPrewarm,
+    pluginsStatus,
+    resolveMcpCatalog = () => ({ adoption: null, plugins: {}, entries: {} }),
+    pluginMcpServer = () => null,
+    flushSkillsSave,
   } = deps;
 
-  /** Persist a new `mcpServers` map; project overrides never survive a global edit. */
+  /** The config with any adoptable plugin server copies already adopted, so
+   *  every write also persists the adoption and never re-adds a copy. */
+  const adoptedConfig = () => withAdoptedCopies(getConfig(), resolveMcpCatalog().adoption);
+
+  /** Persist a new `mcpServers` map; project overrides never survive a global
+   *  edit. A plugin server pushed off its name by the edit keeps the collision
+   *  name it gets, so it does not flip again later. */
   const saveServers = (servers) => {
-    const nextConfig = { ...getConfig() };
+    const nextConfig = { ...adoptedConfig() };
     delete nextConfig.mcpProjectOverrides;
     saveConfigAndAdopt({ ...nextConfig, mcpServers: servers });
+    const saved = getConfig();
+    const pinned = withPinnedCollisionNames(saved, resolveMcpCatalog());
+    if (pinned !== saved) saveConfigAndAdopt(pinned);
+  };
+  const userServers = () => mcpServersOf(adoptedConfig());
+  const refusePluginServer = (name) => {
+    const owned = name ? pluginMcpServer(name) : null;
+    if (owned) throw pluginOwnedError(name, owned.owner);
+  };
+  // Peers reload config from disk on receipt: land the write before publishing.
+  const persisted = async () => {
+    await flushSkillsSave?.();
   };
 
   return {
+    /** One-time, idempotent: move server copies an earlier plugin enable wrote
+     *  into `mcpServers` to per-server plugin intent. Returns adopted names. */
+    migratePluginMcpCopies() {
+      const { adoption } = resolveMcpCatalog();
+      if (!adoption) return [];
+      saveConfigAndAdopt(withAdoptedCopies(getConfig(), adoption));
+      return adoption.removed;
+    },
     mcpStatus() {
       return decorate.mcp(mcpStatus());
     },
@@ -114,26 +117,31 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     },
     async addMcpServer(input = {}) {
       const { name, config: serverConfig } = normalizeMcpServerInput(input);
-      const servers = mcpServersOf(getConfig());
+      const servers = userServers();
       if (Object.hasOwn(servers, name)) throw new Error(`MCP server already exists: ${name}`);
+      const owned = pluginMcpServer(name);
+      if (owned) throw new Error(`MCP server already exists: ${name} (provided by plugin "${owned.owner.id}")`);
       saveServers({ ...servers, [name]: serverConfig });
       const status = await sync.reconnectMcpAndAnnounce({ only: name, enabled: serverConfig.enabled !== false });
       return { name, status };
     },
     async saveMcpServer(input = {}) {
-      const servers = mcpServersOf(getConfig());
+      const servers = userServers();
       // An explicit originalName must exist; a bare name edits a matching
-      // server and otherwise creates a new one.
+      // server and otherwise creates a new one. Plugin servers are never
+      // edited, renamed or shadowed here.
       const explicitOriginal = clean(input.originalName);
       if (explicitOriginal && !Object.hasOwn(servers, explicitOriginal)) {
+        refusePluginServer(explicitOriginal);
         throw new Error(`MCP server not configured: ${explicitOriginal}`);
       }
       const bareName = clean(input.name);
+      if (!explicitOriginal && !Object.hasOwn(servers, bareName)) refusePluginServer(bareName);
       const originalName = explicitOriginal || (Object.hasOwn(servers, bareName) ? bareName : '');
       const existing = originalName ? servers[originalName] : {};
       const normalizedInput = normalizeMcpServerInput(mergedServerInput(input, existing, originalName));
       const name = originalName && clean(input.name) === originalName ? originalName : normalizedInput.name;
-      if (name !== originalName && Object.hasOwn(servers, name)) {
+      if (name !== originalName && (Object.hasOwn(servers, name) || pluginMcpServer(name))) {
         throw new Error(`MCP server already exists: ${name}`);
       }
       if (originalName && originalName !== name) delete servers[originalName];
@@ -149,8 +157,9 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     async removeMcpServer(name) {
       const serverName = clean(name);
       if (!serverName) throw new Error('MCP server name is required');
-      const servers = mcpServersOf(getConfig());
+      const servers = userServers();
       if (!Object.hasOwn(servers, serverName)) {
+        refusePluginServer(serverName);
         throw new Error(`MCP server not configured: ${serverName}`);
       }
       delete servers[serverName];
@@ -161,9 +170,26 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
       const serverName = clean(name);
       if (!serverName) throw new Error('MCP server name is required');
       const want = enabled !== false;
+      const owned = pluginMcpServer(serverName);
+      if (owned) {
+        // Server intent only: the effective state still requires the plugin.
+        // Only a choice that differs from the declared default is stored.
+        const { owner, pluginEnabled, declaredEnabled } = owned;
+        saveConfigAndAdopt(
+          withPluginServerIntent(adoptedConfig(), owner.id, owner.key, (intent) => ({
+            ...intent,
+            enabled: want === (declaredEnabled !== false) ? undefined : want,
+          }))
+        );
+        await persisted();
+        const effective = want && pluginEnabled;
+        const status = await sync.scheduleMcpToggle(serverName, effective);
+        await sync.publish('mcp', { mcpChanges: [{ name: serverName, enabled: effective }] });
+        return status;
+      }
       const shadowRow = mcpStatus().servers.find((s) => s.name === serverName);
       if (!shadowRow) throw new Error(`MCP server not configured: ${serverName}`);
-      const servers = mcpServersOf(getConfig());
+      const servers = userServers();
       const current = servers[serverName];
       if (!current || typeof current !== 'object' || Array.isArray(current)) {
         throw new Error(`MCP server not configured: ${serverName}`);
@@ -174,38 +200,36 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
       await sync.publish('mcp', { mcpChanges: [{ name: serverName, enabled: want }] });
       return status;
     },
+    /** Kept for older callers: plugin servers appear on their own once the
+     *  plugin is registered and enabled. This clears any per-server "off"
+     *  intent of the plugin's servers and reconnects them (here and on peers);
+     *  a disabled plugin stays disabled. */
     async enablePluginMcp(plugin = {}) {
-      const root = clean(plugin.root);
-      const script = pluginMcpEnableScript(root, plugin);
-      if (!root || !script) throw new Error('plugin has no MCP script');
-      const serverName = pluginMcpServerName(plugin);
-      const nextConfig = { ...getConfig() };
-      const manifestMcp = pluginRawMcpServers(root, script);
-      const env = pluginMcpEnv(cfgMod.getPluginData?.() || STANDALONE_DATA_DIR, plugin, serverName);
-      if (manifestMcp) {
-        nextConfig.mcpServers = manifestPluginMcpServers(nextConfig.mcpServers, manifestMcp, {
-          plugin,
-          serverName,
-          env,
-        });
-      } else {
-        const scriptPath = resolveContainedPluginPath(root, script);
-        if (!scriptPath || !existsSync(scriptPath))
-          throw new Error(`plugin MCP script not found: ${join(root, script)}`);
-        nextConfig.mcpServers = {
-          ...(nextConfig.mcpServers || {}),
-          [serverName]: {
-            command: 'node',
-            args: [scriptPath],
-            cwd: root,
-            env,
-            ...(plugin.enabled === false ? { _mixdogPluginDisabled: true } : {}),
-          },
-        };
+      const registered = findRegisteredPlugin(pluginsStatus, plugin) || plugin;
+      const id = clean(registered.id || registered.name);
+      const catalog = resolveMcpCatalog();
+      const row = catalog.plugins[id];
+      if (!row) throw new Error(`plugin not registered: ${clean(plugin.id || plugin.name || plugin) || id}`);
+      if (!row.servers.length) {
+        const detail = row.errors.map((error) => error.message).join('; ');
+        throw new Error(`plugin declares no MCP servers${detail ? `: ${detail}` : ''}`);
+      }
+      let next = withAdoptedCopies(getConfig(), catalog.adoption);
+      for (const name of row.servers) {
+        const { owner, declaredEnabled } = catalog.entries[name];
+        next = withPluginServerIntent(next, id, owner.key, (intent) => ({
+          ...intent,
+          enabled: declaredEnabled === false ? true : undefined,
+        }));
       }
-      saveConfigAndAdopt(nextConfig);
-      const status = await sync.reconnectMcpAndAnnounce();
-      return { serverName, status };
+      saveConfigAndAdopt(next);
+      await persisted();
+      const mcpChanges = row.servers.map((name) => ({ name, enabled: row.enabled }));
+      let status;
+      for (const change of mcpChanges)
+        status = await connectConfiguredMcp({ only: change.name, enabled: change.enabled });
+      await sync.announce('mcp', { detail: { mcpChanges } });
+      return { serverName: row.servers[0], serverNames: row.servers, status };
     },
   };
 }

package/src/session-runtime/resource-plugins-api.mjs

@@ -1,4 +1,6 @@
-// Plugin registry edits and the MCP entries a plugin owns.
+// Plugin registry edits. A plugin's MCP servers are derived from the registry
+// (mcp-glue/plugin-servers.mjs), so each edit reconciles this runtime's MCP
+// connections and then lets peer runtimes reconcile theirs.
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import {
   addPlugin as registryAddPlugin,
@@ -6,7 +8,7 @@ import {
   setPluginEnabled as registrySetPluginEnabled,
   updatePlugin as registryUpdatePlugin,
 } from './services/plugin-admin.mjs';
-import { pluginMcpServerName, pluginServerMatcher } from '../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
+import { withAdoptedCopies, withoutPluginIntents, withPinnedCollisionNames } from './mcp-glue/plugin-servers.mjs';
 
 const pluginKey = (plugin) => clean(plugin.id || plugin.name || plugin);
 
@@ -24,22 +26,22 @@ export function createPluginsResourceApi({ deps, sync, decorate }) {
     getConfig,
     cfgMod,
     saveConfigAndAdopt,
-    connectConfiguredMcp,
-    invalidatePreSessionToolSurface,
     pluginsStatus,
+    resolveMcpCatalog = () => ({ adoption: null }),
+    flushSkillsSave,
   } = deps;
   const pluginData = () => cfgMod.getPluginData?.();
 
-  /** Rewrite the plugin's MCP entries through `rewrite`; when any existed,
-   *  persist and reconnect so the connection registry matches the config. */
-  async function rewritePluginServers(plugin, rewrite) {
-    const nextConfig = { ...getConfig() };
-    const owned = pluginServerMatcher(pluginMcpServerName(plugin));
-    const current = nextConfig.mcpServers || {};
-    if (!Object.keys(current).some(owned)) return;
-    saveConfigAndAdopt({ ...nextConfig, mcpServers: rewrite(current, owned) });
-    await connectConfiguredMcp({ reset: true });
-    invalidatePreSessionToolSurface();
+  /** Persist any adoptable copies of plugin servers while the registry still
+   *  knows their plugin (a removal must not leave them stranded), and keep any
+   *  collision name a plugin server was just given. */
+  async function adoptPluginServerCopies(transform = (config) => config) {
+    const current = getConfig();
+    const catalog = resolveMcpCatalog();
+    const next = transform(withPinnedCollisionNames(withAdoptedCopies(current, catalog.adoption), catalog));
+    if (next === current) return;
+    saveConfigAndAdopt(next);
+    await flushSkillsSave?.();
   }
 
   return {
@@ -47,49 +49,35 @@ export function createPluginsResourceApi({ deps, sync, decorate }) {
       return decorate.plugins(pluginsStatus());
     },
     async reloadPlugins() {
-      await sync.announce('plugins');
+      await sync.reconcilePluginsAndAnnounce();
       return pluginsStatus();
     },
     async addPlugin(source) {
       const plugin = registryAddPlugin(source, { dataDir: pluginData() });
-      await sync.announce('plugins');
+      await adoptPluginServerCopies();
+      await sync.reconcilePluginsAndAnnounce();
       return { plugin, status: pluginsStatus() };
     },
     async updatePlugin(plugin = {}) {
       const updated = registryUpdatePlugin(pluginKey(plugin), { dataDir: pluginData() });
-      await sync.announce('plugins');
+      await adoptPluginServerCopies();
+      await sync.reconcilePluginsAndAnnounce();
       return { plugin: updated, status: pluginsStatus() };
     },
     async setPluginEnabled(plugin = {}, enabled = true) {
-      const owner = findRegisteredPlugin(pluginsStatus, plugin) || plugin;
+      await adoptPluginServerCopies();
       const updated = registrySetPluginEnabled(pluginKey(plugin), enabled, { dataDir: pluginData() });
-      await rewritePluginServers(owner, (servers, owned) => {
-        const next = {};
-        for (const [name, value] of Object.entries(servers)) {
-          const config = value && typeof value === 'object' && !Array.isArray(value) ? { ...value } : value;
-          if (owned(name) && config && typeof config === 'object' && !Array.isArray(config)) {
-            if (enabled === false) config._mixdogPluginDisabled = true;
-            else delete config._mixdogPluginDisabled;
-          }
-          next[name] = config;
-        }
-        return next;
-      });
-      await sync.announce('plugins');
+      await sync.reconcilePluginsAndAnnounce();
       return { plugin: updated, status: pluginsStatus() };
     },
     async removePlugin(plugin = {}) {
-      // Resolve before the registry forgets the plugin and its manifest name.
-      const owner = findRegisteredPlugin(pluginsStatus, plugin) || plugin;
+      const owner = findRegisteredPlugin(pluginsStatus, plugin);
+      const ownerId = clean(owner?.id);
+      // Adopt first (the registry still knows the plugin), then drop the
+      // plugin's per-server intent together with the plugin.
+      await adoptPluginServerCopies((config) => (ownerId ? withoutPluginIntents(config, ownerId) : config));
       const removed = registryRemovePlugin(pluginKey(plugin), { dataDir: pluginData() });
-      await rewritePluginServers(owner, (servers, owned) => {
-        const next = { ...servers };
-        for (const name of Object.keys(next)) {
-          if (owned(name)) delete next[name];
-        }
-        return next;
-      });
-      await sync.announce('plugins');
+      await sync.reconcilePluginsAndAnnounce();
       return { plugin: removed, status: pluginsStatus() };
     },
   };

package/src/session-runtime/resource-scope-decorate.mjs

@@ -7,19 +7,17 @@ import {
   cwdWithinProjects,
   extensionScopeProjects,
   extensionScopesFromConfig,
-  pluginIdForMcpServer,
 } from '../runtime/agent/orchestrator/runtime-core/extension-scopes.mjs';
 
 function listOf(status, key) {
   return Array.isArray(status?.[key]) ? status[key] : [];
 }
 
-export function createScopeDecorators({ getConfig, getCurrentCwd, pluginsStatus }) {
-  function scopeInfo(kind, name, pluginId = '') {
+export function createScopeDecorators({ getConfig, getCurrentCwd }) {
+  function scopeInfo(kind, name, pluginId = '', cwd = getCurrentCwd()) {
     const scopes = extensionScopesFromConfig(getConfig());
     const scope = extensionScopeProjects(scopes, kind, name);
     const inheritedScope = pluginId ? extensionScopeProjects(scopes, 'plugins', pluginId) : null;
-    const cwd = getCurrentCwd();
     const activeHere =
       (scope ? cwdWithinProjects(cwd, scope) : true) &&
       (inheritedScope ? cwdWithinProjects(cwd, inheritedScope) : true);
@@ -27,21 +25,21 @@ export function createScopeDecorators({ getConfig, getCurrentCwd, pluginsStatus
   }
   return {
     mcp(status) {
-      const plugins = pluginsStatus()?.plugins || [];
       return {
         ...status,
         servers: listOf(status, 'servers').map((server) => ({
           ...server,
-          ...scopeInfo('mcp', server.name, pluginIdForMcpServer(server.name, plugins)),
+          ...scopeInfo('mcp', server.name, server?.owner?.kind === 'plugin' ? clean(server.owner.id) : ''),
         })),
       };
     },
-    skills(status) {
+    /** `cwd`: decide `activeHere` for that folder instead of the current one. */
+    skills(status, cwd = getCurrentCwd()) {
       return {
         ...status,
         skills: listOf(status, 'skills').map((skill) => ({
           ...skill,
-          ...scopeInfo('skills', skill.name, skill?.owner?.kind === 'plugin' ? clean(skill.owner.id) : ''),
+          ...scopeInfo('skills', skill.name, skill?.owner?.kind === 'plugin' ? clean(skill.owner.id) : '', cwd),
         })),
       };
     },

package/src/session-runtime/resource-skills-api.mjs

@@ -1,4 +1,23 @@
 // Global Skill documents and the disabled-skill list.
+import { statSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+
+/** `skillsStatus({ cwd })`: the folder to list and scope skills for, in place
+ *  of the session's own. Only an existing absolute directory; it reads the
+ *  same skill roots a session opened there would, nothing wider. */
+function statusCwd(options) {
+  if (options == null) return '';
+  const cwd = options?.cwd;
+  if (typeof cwd !== 'string' || !cwd || cwd.includes('\0') || !isAbsolute(cwd)) {
+    throw new TypeError('skillsStatus cwd must be an absolute path.');
+  }
+  const folder = resolve(cwd);
+  if (!statSync(folder, { throwIfNoEntry: false })?.isDirectory()) {
+    throw new TypeError('skillsStatus cwd is not a directory.');
+  }
+  return folder;
+}
+
 export function createSkillsResourceApi({ deps, sync, decorate }) {
   const {
     skillsStatus,
@@ -11,8 +30,10 @@ export function createSkillsResourceApi({ deps, sync, decorate }) {
     flushSkillsSave,
   } = deps;
   return {
-    skillsStatus() {
-      return decorate.skills(skillsStatus());
+    skillsStatus(options) {
+      const cwd = statusCwd(options);
+      if (!cwd) return decorate.skills(skillsStatus());
+      return decorate.skills(skillsStatus({ cwd }), cwd);
     },
     skillContent(name) {
       return skillContent(name);

package/src/session-runtime/schedule-session-run.mjs

@@ -65,7 +65,7 @@ export async function runScheduleSession(schedule, { config = null, prompt: prom
   const result = await runAutomationTurns(
     session.id,
     () => askSession(session.id, content, null, null, cwd || undefined),
-    (completions) => askSession(session.id, completions, null, null, cwd || undefined)
+    (completions, askOpts) => askSession(session.id, completions, null, null, cwd || undefined, undefined, askOpts)
   );
   return { sessionId: session.id, result: String(result?.content || '') };
 }

package/src/session-runtime/services/channel-session-router.mjs

@@ -19,7 +19,10 @@ export function createChannelSessionRouter({ getSessionService, getSessionId, lo
       service.submitSession({
         sessionId,
         prompt: content,
-        options: { source: 'channel' },
+        // A channel notification (webhook event rules carry fenced external
+        // values) is queued as a task notification, never as typed input, so
+        // nothing inside it selects a skill.
+        options: { source: 'channel', mode: 'task-notification' },
       })
     ).catch((error) => {
       log(`channel session delivery failed session=${sessionId}: ${error?.message || error}`);

package/src/session-runtime/services/hook-bus/command-handler.mjs

@@ -3,6 +3,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { MAX_BUFFER_BYTES } from './constants.mjs';
 import { handlerTimeoutS } from './handler-timeout.mjs';
 import { abortReason, throwIfAborted } from '../../../runtime/shared/abort-race.mjs';
+import { scrubRuntimeRootVars } from '../../../runtime/agent/orchestrator/tools/env-scrub.mjs';
 
 function resolvePlaceholders(str, projectDir, pluginData, pluginRoot = null) {
   if (typeof str !== 'string') return str;
@@ -88,8 +89,10 @@ function hookEnv(projectDir, pluginData, payload, pluginRoot = null) {
   const resolvedProject = projectDir || process.cwd();
   const resolvedPluginRoot = pluginRoot || resolvedProject;
   const resolvedPluginData = pluginData || resolvedProject;
+  // Hooks are user commands like model shells: the host's runtime root,
+  // identity and Electron node-mode must not reach them.
   const env = {
-    ...process.env,
+    ...scrubRuntimeRootVars({ ...process.env }),
     MIXDOG_PROJECT_DIR: resolvedProject,
     MIXDOG_PLUGIN_ROOT: resolvedPluginRoot,
     MIXDOG_PLUGIN_DATA: resolvedPluginData,

package/src/session-runtime/services/hook-bus/handlers.mjs

@@ -1,6 +1,7 @@
 import { readResponseBuffer } from '../../../runtime/shared/bounded-download.mjs';
 import { runAbortable, throwIfAborted } from '../../../runtime/shared/abort-race.mjs';
 import { assertPublicUrl, pinnedFetch } from '../../../runtime/web-search/lib/ssrf-guard.mjs';
+import { providerSafeMcpToolName } from '../../../runtime/agent/orchestrator/mcp/client-config.mjs';
 import { handlerTimeoutS } from './handler-timeout.mjs';
 export { handlerTimeoutS } from './handler-timeout.mjs';
 export { defaultShellKind, runCommandHandler } from './command-handler.mjs';
@@ -216,8 +217,9 @@ export async function runMcpToolHandler(handler, payload, eventName, mcpToolRunn
   throwIfAborted(signal);
   const timeoutMs = Math.round(handlerTimeoutS(handler, eventName) * 1000);
   let name = String(handler.tool || '').trim();
-  if (handler.server && !name.startsWith('mcp__')) {
-    name = `mcp__${String(handler.server).trim()}__${name}`;
+  if (handler.server && name && !name.startsWith('mcp__')) {
+    // The same provider-safe name the server's tool was registered under.
+    name = providerSafeMcpToolName(String(handler.server).trim(), name);
   }
   if (!name) {
     return {
@@ -241,7 +243,9 @@ export async function runMcpToolHandler(handler, payload, eventName, mcpToolRunn
         onTimeout: () => {
           try {
             controller.abort(new Error(`mcp_tool hook timed out: ${name}`));
-          } catch {}
+          } catch {
+            // Abort is best-effort; the timeout error below is what callers see.
+          }
           return new Error(`mcp_tool hook timed out: ${name}`);
         },
       }