@@ -13,6 +13,9 @@ import {
 } from "../../mcp/config"
 import { Instance } from "../../project/instance"
 import { Global } from "../../global"
+import { Log } from "../../util/log"
+
+const log = Log.create({ service: "datamate" })
 
 /** Project root for config resolution — falls back to cwd when no git repo is detected. */
 function projectRoot() {
@@ -81,7 +84,9 @@ export const DatamateManagerTool = Tool.define("datamate_manager", {
     "'list-config' shows all datamate entries saved in config files (project and global). " +
     "Config files: project config is at <project-root>/altimate-code.json, " +
     "global config is at ~/.config/altimate-code/altimate-code.json. " +
-    "Datamate server names are prefixed with 'datamate-'. " +
+    "When a VS Code extension datamate entry exists (.vscode/mcp.json has 'datamate' key), " +
+    "'add' always uses the server name 'datamate' — tools are then prefixed 'datamate_'. " +
+    "In standalone mode, server names follow 'datamate-<name>' pattern. " +
     "Do NOT use glob/grep/read to find config files — use 'list-config' instead.",
   parameters: z.object({
     operation: z.enum(["list", "list-integrations", "add", "create", "edit", "delete", "status", "remove", "list-config"]),
@@ -196,6 +201,10 @@ async function handleListIntegrations() {
   }
 }
 
+// altimate_change start — server name used by the VS Code extension in .vscode/mcp.json
+const EXTENSION_DATAMATE_SERVER = "datamate"
+// altimate_change end
+
 async function handleAdd(args: { datamate_id?: string; name?: string; scope?: "project" | "global" }) {
   if (!args.datamate_id) {
     return {
@@ -205,30 +214,76 @@ async function handleAdd(args: { datamate_id?: string; name?: string; scope?: "p
     }
   }
   try {
-    // altimate_change start — detect transport from .vscode/mcp.json; fall back to cloud
-    // Reads .vscode/mcp.json in the project root to determine whether the extension
-    // registered an HTTP or stdio transport for the datamate MCP server. This lets
-    // altimate-code honour whatever the VS Code extension wrote (HTTP when the local
-    // mcp-engine is running, stdio when it is not), and falls back to the cloud MCP
-    // config when no .vscode/mcp.json entry is found.
     const datamate = await AltimateApi.getDatamate(args.datamate_id)
-    const serverName = args.name ?? `datamate-${slugify(datamate.name)}`
     const transport = await readVscodeMcpTransport(projectRoot())
+
+    // altimate_change start — single-gateway mode when extension is present
+    // If .vscode/mcp.json has a "datamate" entry (written by the VS Code extension),
+    // always use "datamate" as the server name regardless of which specific datamate
+    // the user selected. This prevents duplicate tool sets — the extension's gateway
+    // already serves all datamate tools through a single MCP connection.
+    // In standalone/CLI mode (no .vscode/mcp.json datamate entry), fall back to the
+    // original per-datamate naming with cloud URL.
+    const serverName = transport !== null
+      ? EXTENSION_DATAMATE_SERVER
+      : (args.name ?? `datamate-${slugify(datamate.name)}`)
+
     const creds = transport ? undefined : await AltimateApi.getCredentials()
     const mcpConfig =
       transport?.type === "remote"
         ? { type: "remote" as const, url: transport.url }
         : transport?.type === "local"
-          ? { type: "local" as const, command: ["datamate", "start-stdio", "--datamate", args.datamate_id] }
+          // Extension stdio: no --datamate id needed — active teammate is resolved
+          // by the extension over the ALTIMATE_EXTENSION_RPC socket at runtime.
+          ? { type: "local" as const, command: ["datamate", "start-stdio"] }
           : AltimateApi.buildMcpConfig(creds!, args.datamate_id)
-    // altimate_change end
 
-    // Always save to config first so it persists for future sessions
     const isGlobal = args.scope === "global"
     const configPath = await resolveConfigPath(isGlobal ? Global.Path.config : projectRoot(), isGlobal)
-    await addMcpToConfig(serverName, { ...mcpConfig, enabled: true }, configPath)
 
-    await MCP.add(serverName, mcpConfig)
+    if (transport !== null) {
+      // Extension mode: check if "datamate" is already wired up
+      const existingNames = await listMcpInConfig(configPath)
+      const staleEntries = existingNames.filter(
+        (n) => n !== EXTENSION_DATAMATE_SERVER && n.startsWith("datamate-"),
+      )
+      if (staleEntries.length > 0) {
+        log.info("handleAdd: stale per-datamate entries detected alongside extension gateway", {
+          staleEntries,
+        })
+      }
+
+      if (existingNames.includes(EXTENSION_DATAMATE_SERVER)) {
+        // Already in config — just ensure it is connected in this session
+        const allStatus = await MCP.status()
+        if (allStatus[EXTENSION_DATAMATE_SERVER]?.status === "connected") {
+          const mcpTools = await MCP.tools()
+          const toolCount = Object.keys(mcpTools).filter((k) =>
+            k.startsWith(EXTENSION_DATAMATE_SERVER + "_"),
+          ).length
+          const staleNote =
+            staleEntries.length > 0
+              ? `\n\nNote: stale per-datamate entries found in config: ${staleEntries.join(", ")} — use operation 'remove' to clean them up.`
+              : ""
+          return {
+            title: `Datamate '${datamate.name}': already connected via '${EXTENSION_DATAMATE_SERVER}'`,
+            metadata: { serverName: EXTENSION_DATAMATE_SERVER, datamateId: args.datamate_id, toolCount },
+            output: `Datamate tools are already available via the '${EXTENSION_DATAMATE_SERVER}' MCP server (${toolCount} tools active).${staleNote}`,
+          }
+        }
+        // In config but not connected — reconnect
+        await MCP.add(EXTENSION_DATAMATE_SERVER, mcpConfig)
+      } else {
+        // Not in config yet — write then connect
+        await addMcpToConfig(EXTENSION_DATAMATE_SERVER, { ...mcpConfig, enabled: true }, configPath)
+        await MCP.add(EXTENSION_DATAMATE_SERVER, mcpConfig)
+      }
+    } else {
+      // Standalone/CLI mode — original behaviour: per-datamate name + cloud URL
+      await addMcpToConfig(serverName, { ...mcpConfig, enabled: true }, configPath)
+      await MCP.add(serverName, mcpConfig)
+    }
+    // altimate_change end
 
     // Check connection status
     const allStatus = await MCP.status()
@@ -252,7 +307,7 @@ async function handleAdd(args: { datamate_id?: string; name?: string; scope?: "p
     return {
       title: `Datamate '${datamate.name}': connected as '${serverName}'`,
       metadata: { serverName, datamateId: args.datamate_id, toolCount, configPath },
-      output: `Connected datamate '${datamate.name}' (ID: ${args.datamate_id}) as MCP server '${serverName}'.\n\n${toolCount} tools are now available from this datamate. They will be usable in the next message.\n\nConfiguration saved to ${configPath} for future sessions.`,
+      output: `Connected datamate '${datamate.name}' (ID: ${args.datamate_id}) as MCP server '${serverName}'.\n\n${toolCount} tools are now available. They will be usable in the next message.\n\nConfiguration saved to ${configPath} for future sessions.`,
     }
   } catch (e) {
     return {