@memoraone/mcp 0.1.38 → 0.1.39

package/dist/cli.cjs

@@ -30,7 +30,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.38",
+      version: "0.1.39",
       type: "module",
       main: "dist/index.cjs",
       bin: {
@@ -56,6 +56,7 @@ var require_package = __commonJS({
         "@modelcontextprotocol/sdk": "^1.25.1",
         "@napi-rs/keyring": "1.3.0",
         dotenv: "^16.4.5",
+        "smol-toml": "^1.7.1",
         zod: "^4.0.0"
       },
       devDependencies: {
@@ -366,7 +367,7 @@ async function acquireLocalLock(lockName, options = {}) {
             `[memoraone-mcp] Failed to acquire lock ${lockName} after ${maxRetries} retries`
           );
         }
-        await new Promise((resolve17) => setTimeout(resolve17, retryDelayMs));
+        await new Promise((resolve21) => setTimeout(resolve21, retryDelayMs));
         continue;
       }
       throw err;
@@ -530,6 +531,24 @@ async function keyringGetPassword(repositoryBindingId, options = {}) {
     );
   }
 }
+async function keyringDeletePassword(repositoryBindingId, options = {}) {
+  const mod = await loadKeyringModule(options.loader);
+  const account = keyringAccountForBinding(repositoryBindingId);
+  try {
+    const entry = new mod.Entry(KEYRING_SERVICE, account);
+    entry.deletePassword();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/NoEntry|not found|no entry/i.test(message)) {
+      return;
+    }
+    if (err instanceof KeyringUnavailableError) throw err;
+    throw new KeyringOperationError(
+      `[memoraone-mcp] Failed to delete credentials from OS keyring for ${account}`,
+      err
+    );
+  }
+}
 
 // src/localState/installationCredentials.ts
 function parsePayload(raw, repositoryBindingId) {
@@ -618,6 +637,9 @@ async function ensureClientRedeemKey(repositoryBindingId, options = {}) {
   );
   return { payload, clientRedeemKey, created: true };
 }
+async function deleteInstallationCredentials(repositoryBindingId, options = {}) {
+  await keyringDeletePassword(repositoryBindingId, options);
+}
 function hasUsableAccessToken(payload) {
   return Boolean(payload?.accessToken && payload.accessToken.startsWith("mia_"));
 }
@@ -855,9 +877,9 @@ var MemoraOneHttpError = class extends Error {
 };
 
 // src/localState/localConnectClient.ts
-async function requestJson(baseUrl, method, path21, options = {}) {
+async function requestJson(baseUrl, method, path25, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
-  const url = `${baseUrl.replace(/\/+$/, "")}${path21.startsWith("/") ? path21 : `/${path21}`}`;
+  const url = `${baseUrl.replace(/\/+$/, "")}${path25.startsWith("/") ? path25 : `/${path25}`}`;
   const res = await fetchImpl(url, {
     method,
     headers: {
@@ -1266,12 +1288,20 @@ var HASH_SOCKET_FILENAME_RE = new RegExp(
   `^mcp-[0-9a-f]{${BINDING_SOCKET_HASH_LENGTH}}\\.sock$`,
   "i"
 );
-var LEGACY_SOCKET_FILENAME_RE = /^mcp-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:-([0-9a-f]{12}))?(?:-(cursor|jetbrains|copilot-vscode))?\.sock$/i;
+var LEGACY_SOCKET_FILENAME_RE = /^mcp-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:-([0-9a-f]{12}))?(?:-(cursor|jetbrains|copilot-vscode|claude-code|windsurf|opencode|codex))?\.sock$/i;
 var LEGACY_SOCKET_PROJECT_ID_RE = LEGACY_SOCKET_FILENAME_RE;
 function getMcpBaseDir() {
   return BASE_DIR;
 }
-var IDE_TYPES = ["cursor", "copilot-vscode", "jetbrains"];
+var IDE_TYPES = [
+  "cursor",
+  "copilot-vscode",
+  "jetbrains",
+  "claude-code",
+  "windsurf",
+  "opencode",
+  "codex"
+];
 var IDE_TYPE_SET = new Set(IDE_TYPES);
 function parseIdeType(value) {
   if (value === void 0 || value.trim() === "" || !IDE_TYPE_SET.has(value)) {
@@ -1283,27 +1313,32 @@ function resolveIdeTypeFromEnv(env2 = process.env) {
   return parseIdeType(env2.MEMORAONE_IDE_TYPE);
 }
 function parseIdeTypeFromCommandLine(commandLine) {
-  const match = commandLine.match(/--ide\s+(cursor|copilot-vscode|jetbrains)(?:\s|$)/);
+  const match = commandLine.match(
+    /--ide\s+(cursor|copilot-vscode|jetbrains|claude-code|windsurf|opencode|codex)(?:\s|$)/
+  );
   return match ? match[1] : void 0;
 }
-function buildDaemonSpawnArgs(scriptPath, repositoryBindingId, env2 = process.env) {
+function buildDaemonSpawnArgs(scriptPath, repositoryBindingId, env2 = process.env, ideTypeOverride) {
   const args2 = [scriptPath, "--daemon", "--binding-id", repositoryBindingId];
-  const ideType = resolveIdeTypeFromEnv(env2);
+  const ideType = ideTypeOverride ?? resolveIdeTypeFromEnv(env2);
   if (ideType) {
     args2.push("--ide", ideType);
   }
   return args2;
 }
-function resolveBindingIdeType(env2 = process.env) {
+function resolveBindingIdeType(env2 = process.env, ideTypeOverride) {
+  if (ideTypeOverride !== void 0) {
+    return ideTypeOverride;
+  }
   return resolveIdeTypeFromEnv(env2) ?? "";
 }
-function getBindingSocketFilename(binding, env2 = process.env) {
-  const ideType = resolveBindingIdeType(env2);
+function getBindingSocketFilename(binding, env2 = process.env, ideTypeOverride) {
+  const ideType = resolveBindingIdeType(env2, ideTypeOverride);
   const hash = hashBindingIdentity(binding.repositoryBindingId, binding.workspaceRoot, ideType);
   return `mcp-${hash}.sock`;
 }
-function getBindingSocketPath(binding, env2 = process.env) {
-  return path9.join(BASE_DIR, getBindingSocketFilename(binding, env2));
+function getBindingSocketPath(binding, env2 = process.env, ideTypeOverride) {
+  return path9.join(BASE_DIR, getBindingSocketFilename(binding, env2, ideTypeOverride));
 }
 function ensureBaseDir() {
   fs7.mkdirSync(BASE_DIR, { recursive: true });
@@ -1419,7 +1454,7 @@ function formatBindingMismatchError(socketPath, sidecar, expected, detail) {
   lines.push("The bridge will replace this stale daemon automatically from local binding state.");
   return lines.join("\n");
 }
-function verifyDaemonSidecarBinding(socketPath, expected, env2 = process.env) {
+function verifyDaemonSidecarBinding(socketPath, expected, env2 = process.env, ideTypeOverride) {
   const record = readBindingSidecarRecord(socketPath);
   if (!record) {
     return null;
@@ -1431,7 +1466,7 @@ function verifyDaemonSidecarBinding(socketPath, expected, env2 = process.env) {
   if (!bindingsMatch(sidecar, expected)) {
     throw new Error(formatBindingMismatchError(socketPath, sidecar, expected));
   }
-  const expectedIdeType = resolveBindingIdeType(env2);
+  const expectedIdeType = resolveBindingIdeType(env2, ideTypeOverride);
   if (record.ideType !== void 0 && record.ideType !== expectedIdeType) {
     throw new Error(
       formatBindingMismatchError(
@@ -1528,8 +1563,8 @@ var StdioLineReader = class {
     if (this.closed) {
       return null;
     }
-    return new Promise((resolve17) => {
-      this.waiters.push(resolve17);
+    return new Promise((resolve21) => {
+      this.waiters.push(resolve21);
     });
   }
   /** Re-queue lines read during an intermediate protocol step (e.g. roots/list) for the main bridge loop. */
@@ -1978,19 +2013,24 @@ function resolveIdeApiUrl(options) {
   return MEMORAONE_LOCAL_API_URL;
 }
 function buildMemoraoneCursorMcpServer(options) {
+  const ideType = options.ideType ?? "cursor";
   const env2 = {
     MEMORAONE_API_URL: resolveIdeApiUrl({
       environment: options.environment,
       apiUrl: options.apiUrl
-    }),
-    MEMORAONE_IDE_TYPE: "cursor"
+    })
   };
+  if (ideType !== "claude-code") {
+    env2.MEMORAONE_IDE_TYPE = ideType;
+  }
   if (options.workspaceRoot !== void 0) {
     env2[MEMORAONE_WORKSPACE_ROOT_ENV] = path14.resolve(options.workspaceRoot);
   }
   if (options.environment === "local") {
     if (!options.cliPath) {
-      throw new Error("[setup-ide-files] Local Cursor MCP config requires a built CLI path.");
+      throw new Error(
+        `[setup-ide-files] Local ${ideType} MCP config requires a built CLI path.`
+      );
     }
     return {
       command: "node",
@@ -1999,7 +2039,7 @@ function buildMemoraoneCursorMcpServer(options) {
     };
   }
   if (!options.npxPath) {
-    throw new Error("[setup-ide-files] Cursor MCP config requires a resolved npx path.");
+    throw new Error(`[setup-ide-files] ${ideType} MCP config requires a resolved npx path.`);
   }
   const channel = options.npmPackageChannel ?? npmPackageChannelFromEnvironment(options.environment);
   return {
@@ -2113,10 +2153,30 @@ function mergeCursorRepoMcpConfigObject(existing, writeOptions) {
     cliPath: writeOptions.cliPath,
     workspaceRoot: writeOptions.repoRoot,
     apiUrl: writeOptions.apiUrl,
-    npmPackageChannel: writeOptions.npmPackageChannel
+    npmPackageChannel: writeOptions.npmPackageChannel,
+    ideType: "cursor"
+  });
+  return { ...base, mcpServers };
+}
+function mergeClaudeCodeMcpConfigObject(existing, writeOptions) {
+  const environment = writeOptions.environment ?? "production";
+  const base = existing && typeof existing === "object" ? { ...existing } : { mcpServers: {} };
+  const mcpServers = typeof base.mcpServers === "object" && base.mcpServers !== null && !Array.isArray(base.mcpServers) ? { ...base.mcpServers } : {};
+  delete mcpServers.memoraone;
+  mcpServers.memoraone = buildMemoraoneCursorMcpServer({
+    environment,
+    npxPath: writeOptions.npxPath,
+    cliPath: writeOptions.cliPath,
+    workspaceRoot: writeOptions.repoRoot,
+    apiUrl: writeOptions.apiUrl,
+    npmPackageChannel: writeOptions.npmPackageChannel,
+    ideType: "claude-code"
   });
   return { ...base, mcpServers };
 }
+function getClaudeCodeMcpConfigPath(repoRoot) {
+  return path14.join(path14.resolve(repoRoot), ".mcp.json");
+}
 function isMemoraoneManagedApiUrl(url) {
   if (typeof url !== "string" || url.length === 0) return false;
   if (url === MEMORAONE_PROD_API_URL) return true;
@@ -2421,14 +2481,14 @@ async function filterSocketPathsByIdeForCleanup(socketPaths, projectId, ide, wor
   const resolvedRoot = workspaceRoot ? path15.resolve(workspaceRoot) : null;
   const filtered = [];
   for (const socketPath of socketPaths) {
-    const basename11 = path15.basename(socketPath);
-    if (isLegacySocketFilename(basename11)) {
-      if (isSocketFilenameForProjectAndIde(basename11, normalizedProjectId, ide)) {
+    const basename14 = path15.basename(socketPath);
+    if (isLegacySocketFilename(basename14)) {
+      if (isSocketFilenameForProjectAndIde(basename14, normalizedProjectId, ide)) {
         filtered.push(socketPath);
       }
       continue;
     }
-    if (isHashSocketFilename(basename11)) {
+    if (isHashSocketFilename(basename14)) {
       const record = readBindingSidecarRecord(socketPath);
       if (!record || record.ideType !== ide) continue;
       const sameProject = record.projectId.trim().toLowerCase() === normalizedProjectId;
@@ -2808,6 +2868,179 @@ async function cliCleanup(argv) {
   return result.exitCode;
 }
 
+// src/config.ts
+var process2 = __toESM(require("process"), 1);
+var fs12 = __toESM(require("fs"), 1);
+var path16 = __toESM(require("path"), 1);
+var dotenv = __toESM(require("dotenv"), 1);
+var import_v4 = require("zod/v4");
+
+// src/configUtils.ts
+var DEFAULT_API_URL = "http://localhost:3001";
+var DEV_API_URL = "http://localhost:3001";
+function resolveApiUrl(env2) {
+  const explicitUrl = env2.MEMORAONE_API_URL?.trim();
+  if (explicitUrl) {
+    return explicitUrl;
+  }
+  const aliasUrl = env2.MEMORA_API_URL?.trim();
+  if (aliasUrl) {
+    return aliasUrl;
+  }
+  if (env2.MEMORAONE_DEV_MODE === "1") {
+    return DEV_API_URL;
+  }
+  return DEFAULT_API_URL;
+}
+
+// src/config.ts
+var dotenvPath = path16.resolve(process2.cwd(), ".env");
+if (fs12.existsSync(dotenvPath)) {
+  try {
+    dotenv.config({ path: dotenvPath });
+  } catch (err) {
+    process2.stderr.write("[memoraone-mcp] Failed to load .env: " + String(err) + "\n");
+  }
+}
+var EnvSchema = import_v4.z.object({
+  MEMORAONE_API_URL: import_v4.z.string().url().optional(),
+  MEMORAONE_API_KEY: import_v4.z.string().min(1).optional(),
+  MEMORAONE_DEV_MODE: import_v4.z.string().min(1).optional(),
+  MEMORAONE_AGENT_NAME: import_v4.z.string().min(1).optional(),
+  MEMORAONE_AGENT_TYPE: import_v4.z.string().min(1).optional(),
+  MEMORAONE_SOURCE: import_v4.z.string().min(1).optional(),
+  MEMORAONE_IDE_TYPE: import_v4.z.enum(["cursor", "copilot-vscode", "jetbrains", "claude-code", "windsurf", "opencode", "codex"]).optional(),
+  MEMORAONE_WORKLOG: import_v4.z.string().min(1).optional(),
+  MEMORAONE_HEARTBEAT: import_v4.z.string().min(1).optional(),
+  MEMORAONE_HEARTBEAT_INTERVAL_MS: import_v4.z.string().min(1).optional()
+});
+var requiredEnvVars = [];
+var missingEnvVars = requiredEnvVars.filter((key) => {
+  const value = process2.env[key];
+  return value === void 0 || value.trim() === "";
+});
+if (missingEnvVars.length > 0) {
+  for (const key of missingEnvVars) {
+    process2.stderr.write(`Missing ${key}
+`);
+  }
+  process2.exit(1);
+}
+var parsed = EnvSchema.safeParse(process2.env);
+var resolvedApiUrl = resolveApiUrl(process2.env);
+if (!parsed.success) {
+  const formatted = parsed.error.format();
+  process2.stderr.write(
+    "[memoraone-mcp] Invalid environment variables " + JSON.stringify(formatted) + "\n"
+  );
+  throw new Error("Config validation failed");
+}
+var parseBooleanFlag2 = (value, defaultValue) => {
+  if (value === void 0) {
+    return defaultValue;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["0", "false", "no", "off"].includes(normalized)) {
+    return false;
+  }
+  return defaultValue;
+};
+var config2 = {
+  apiUrl: resolvedApiUrl.replace(/\/+$/, ""),
+  apiKey: parsed.data.MEMORAONE_API_KEY,
+  agentName: parsed.data.MEMORAONE_AGENT_NAME ?? "cursor",
+  agentType: parsed.data.MEMORAONE_AGENT_TYPE ?? "agent",
+  source: parsed.data.MEMORAONE_SOURCE ?? "cursor",
+  ideType: parsed.data.MEMORAONE_IDE_TYPE,
+  devMode: parseBooleanFlag2(parsed.data.MEMORAONE_DEV_MODE, false),
+  worklogEnabled: parseBooleanFlag2(parsed.data.MEMORAONE_WORKLOG, true),
+  heartbeatEnabled: parseBooleanFlag2(parsed.data.MEMORAONE_HEARTBEAT, true),
+  // Cadence is owned by LOCAL_MCP_HEARTBEAT_INTERVAL_MS in heartbeat.ts (1_000).
+  // Env override is accepted for forward-compat but the timer path ignores it.
+  heartbeatIntervalMs: Number.parseInt(parsed.data.MEMORAONE_HEARTBEAT_INTERVAL_MS ?? "1000", 10)
+};
+
+// src/ideType.ts
+function mapReliableClientInfoName(name) {
+  if (typeof name !== "string") {
+    return void 0;
+  }
+  const normalized = name.trim().toLowerCase();
+  if (normalized === "") {
+    return void 0;
+  }
+  if (normalized === "claude-code") {
+    return "claude-code";
+  }
+  if (normalized === "devin") {
+    return "windsurf";
+  }
+  if (normalized === "windsurf" || /^windsurf[\s_-].+$/.test(normalized)) {
+    return "windsurf";
+  }
+  return void 0;
+}
+function mapReliableHostIdentity(env2) {
+  if (env2.WINDSURF_IDE_TYPE === "windsurf") {
+    return "windsurf";
+  }
+  if (env2.ACP_BACKEND === "windsurf") {
+    return "windsurf";
+  }
+  if (env2.__CFBundleIdentifier === "com.exafunction.windsurf") {
+    return "windsurf";
+  }
+  return void 0;
+}
+function inferIdeType(params, options = {}) {
+  const env2 = options.env ?? process.env;
+  const argv = (options.argv ?? process.argv).join(" ").toLowerCase();
+  const hasExplicitConfigOption = Object.prototype.hasOwnProperty.call(options, "configIdeType");
+  const explicitHint = hasExplicitConfigOption ? options.configIdeType : resolveIdeTypeFromEnv(env2) ?? config2.ideType;
+  const fromClientInfo = mapReliableClientInfoName(params?.clientInfo?.name);
+  if (fromClientInfo) {
+    return fromClientInfo;
+  }
+  const fromHost = mapReliableHostIdentity(env2);
+  if (fromHost) {
+    return fromHost;
+  }
+  if (explicitHint) {
+    return explicitHint;
+  }
+  const clientInfoName = String(params?.clientInfo?.name ?? "").toLowerCase();
+  const clientInfoVersion = String(params?.clientInfo?.version ?? "").toLowerCase();
+  const termProgram = String(env2.TERM_PROGRAM ?? "").toLowerCase();
+  const envKeys = Object.keys(env2);
+  const hasCursorSignals = envKeys.some((key) => key.startsWith("CURSOR_")) || termProgram === "cursor" || clientInfoName.includes("cursor") || clientInfoVersion.includes("cursor") || argv.includes("cursor");
+  if (hasCursorSignals) {
+    return "cursor";
+  }
+  const hasJetBrainsSignals = envKeys.some(
+    (key) => [
+      "JETBRAINS_IDE",
+      "IDEA_INITIAL_DIRECTORY",
+      "JETBRAINS_REMOTE_RUN",
+      "INTELLIJ_ENVIRONMENT_READER"
+    ].includes(key)
+  ) || String(env2.TERMINAL_EMULATOR ?? "").toLowerCase().includes("jetbrains") || /(jetbrains|intellij|pycharm|webstorm|goland|rubymine|clion|phpstorm|rider|datagrip)/.test(
+    clientInfoName
+  ) || /(jetbrains|intellij|pycharm|webstorm|goland|rubymine|clion|phpstorm|rider|datagrip)/.test(
+    argv
+  );
+  if (hasJetBrainsSignals) {
+    return "jetbrains";
+  }
+  const hasVsCodeSignals = envKeys.some((key) => key.startsWith("VSCODE_")) || /(visual studio code|vscode|vs code|github copilot)/.test(clientInfoName) || /(visual studio code|vscode|vs code)/.test(argv);
+  if (hasVsCodeSignals) {
+    return "copilot-vscode";
+  }
+  return void 0;
+}
+
 // src/bridgeProxy.ts
 var defaultLog = (msg) => {
   process.stderr.write(`[memoraone-mcp][bridge] ${msg}
@@ -2828,9 +3061,9 @@ function summarizeJsonRpcMethod(line) {
   }
 }
 function connectWithRetry(socketPath, log, maxRetries, retryDelayMs, connect2) {
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve21, reject) => {
     const tryConnect = (attempt) => {
-      connect2(socketPath).then(resolve17).catch((err) => {
+      connect2(socketPath).then(resolve21).catch((err) => {
         if (attempt >= maxRetries) {
           reject(err);
           return;
@@ -2852,8 +3085,8 @@ async function resolveBridgeSessionBinding(params, env2 = process.env, options =
     ...bridgeOptions
   });
 }
-async function stopDaemonsForStaleBinding(stale, env2, log) {
-  const ideType = resolveBindingIdeType(env2);
+async function stopDaemonsForStaleBinding(stale, env2, log, ideTypeOverride) {
+  const ideType = resolveBindingIdeType(env2, ideTypeOverride);
   let processes;
   try {
     processes = await defaultListDaemonProcesses();
@@ -2880,9 +3113,10 @@ async function connectOrSpawnDaemonForBinding(binding, opts) {
       `refreshed stale binding ${sessionBinding.repositoryBindingId}: project=${sessionBinding.projectId}`
     );
   }
-  const socketPath = getBindingSocketPath(sessionBinding, opts.env);
+  const ideType = opts.ideType;
+  const socketPath = getBindingSocketPath(sessionBinding, opts.env, ideType);
   opts.log(
-    `target daemon socket=${socketPath} project=${sessionBinding.projectId} workspace=${sessionBinding.workspaceRoot}`
+    `target daemon socket=${socketPath} project=${sessionBinding.projectId} workspace=${sessionBinding.workspaceRoot}` + (ideType ? ` ideType=${ideType}` : "")
   );
   let socket;
   try {
@@ -2893,7 +3127,7 @@ async function connectOrSpawnDaemonForBinding(binding, opts) {
       opts.retryDelayMs,
       opts.connect
     );
-    verifyDaemonSidecarBinding(socketPath, sessionBinding, opts.env);
+    verifyDaemonSidecarBinding(socketPath, sessionBinding, opts.env, ideType);
     opts.log("reusing running daemon for session binding");
     return { socket, binding: sessionBinding, cacheRefreshed: reconciled.cacheRefreshed };
   } catch (err) {
@@ -2908,11 +3142,11 @@ async function connectOrSpawnDaemonForBinding(binding, opts) {
       opts.log("stale daemon binding detected; replacing daemon for current local binding");
       const staleSidecar = readBindingSidecar(socketPath);
       if (staleSidecar) {
-        await stopDaemonsForStaleBinding(staleSidecar, opts.env, opts.log);
+        await stopDaemonsForStaleBinding(staleSidecar, opts.env, opts.log, ideType);
       }
-      await stopDaemonsForStaleBinding(sessionBinding, opts.env, opts.log);
+      await stopDaemonsForStaleBinding(sessionBinding, opts.env, opts.log, ideType);
       if (!bindingsMatch(binding, sessionBinding)) {
-        await stopDaemonsForStaleBinding(binding, opts.env, opts.log);
+        await stopDaemonsForStaleBinding(binding, opts.env, opts.log, ideType);
       }
       removeDaemonSocketArtifacts(socketPath);
     }
@@ -2927,13 +3161,14 @@ async function connectOrSpawnDaemonForBinding(binding, opts) {
     opts.retryDelayMs,
     opts.connect
   );
-  verifyDaemonSidecarBinding(socketPath, sessionBinding, opts.env);
+  verifyDaemonSidecarBinding(socketPath, sessionBinding, opts.env, ideType);
   return { socket, binding: sessionBinding, cacheRefreshed: reconciled.cacheRefreshed };
 }
 var BridgeDaemonRouter = class {
   constructor(options) {
     this.activeSocket = null;
     this.activeBinding = null;
+    this.activeIdeType = void 0;
     this.socketLineReader = null;
     this.lastInitializeLine = null;
     this.pendingDeferredClientLines = [];
@@ -2946,19 +3181,23 @@ var BridgeDaemonRouter = class {
     this.maxRetries = options.maxRetries ?? 5;
     this.retryDelayMs = options.retryDelayMs ?? 200;
     this.lineReader = options.lineReader ?? null;
-    this.connectImpl = options.connect ?? ((socketPath) => new Promise((resolve17, reject) => {
-      const socket = net.connect(socketPath, () => resolve17(socket));
+    this.connectImpl = options.connect ?? ((socketPath) => new Promise((resolve21, reject) => {
+      const socket = net.connect(socketPath, () => resolve21(socket));
       socket.on("error", reject);
     }));
     this.spawnDaemonImpl = options.spawnDaemon ?? (async (binding) => {
+      const ideType = this.activeIdeType;
       const child = (0, import_node_child_process4.spawn)(
         process.execPath,
-        buildDaemonSpawnArgs(this.cliPath, binding.repositoryBindingId, this.env),
+        buildDaemonSpawnArgs(this.cliPath, binding.repositoryBindingId, this.env, ideType),
         {
           detached: true,
           stdio: "ignore",
           env: {
             ...this.env,
+            // Align child hint with the effective live identity for this session.
+            // Does not mutate the bridge process environment.
+            ...ideType ? { MEMORAONE_IDE_TYPE: ideType } : {},
             // Secret-free handoff only; tokens stay in the OS keyring.
             MEMORAONE_DAEMON_BINDING_B64: encodeResolvedBinding(binding)
           }
@@ -2977,6 +3216,9 @@ var BridgeDaemonRouter = class {
   getActiveBinding() {
     return this.activeBinding;
   }
+  getActiveIdeType() {
+    return this.activeIdeType;
+  }
   hasClientInitialize() {
     return this.clientInitializeSeen;
   }
@@ -2986,6 +3228,14 @@ var BridgeDaemonRouter = class {
       this.env,
       `initialize payload: ${summarizeInitializeParamsForDebug(params)}`
     );
+    const effectiveIdeType = inferIdeType(params, {
+      env: this.env,
+      configIdeType: resolveIdeTypeFromEnv(this.env)
+    });
+    this.activeIdeType = effectiveIdeType;
+    if (effectiveIdeType) {
+      this.log(`effective ideType=${effectiveIdeType} (initialize identity)`);
+    }
     const bridgeOptions = getBridgeBindingResolveOptions(this.env);
     const initializeRoots = extractWorkspaceRootsFromInitialize(params);
     let rootsListUris;
@@ -3035,6 +3285,7 @@ var BridgeDaemonRouter = class {
       this.detachSocketReader();
       this.activeSocket?.destroy();
       this.activeSocket = null;
+      this.activeIdeType = effectiveIdeType;
     }
     this.activeBinding = binding;
     await this.connectActiveDaemon();
@@ -3078,6 +3329,7 @@ var BridgeDaemonRouter = class {
     this.handshakeDeferredClientLines = [];
     this.clientInitializeSeen = false;
     this.activeBinding = null;
+    this.activeIdeType = void 0;
   }
   async connectActiveDaemon() {
     if (!this.activeBinding) {
@@ -3090,7 +3342,8 @@ var BridgeDaemonRouter = class {
       maxRetries: this.maxRetries,
       retryDelayMs: this.retryDelayMs,
       connect: this.connectImpl,
-      spawnDaemon: this.spawnDaemonImpl
+      spawnDaemon: this.spawnDaemonImpl,
+      ideType: this.activeIdeType
     });
     this.activeBinding = connected.binding;
     this.activeSocket = connected.socket;
@@ -3209,37 +3462,17 @@ async function runBridgeProxy(options) {
 }
 
 // src/setupIdeFiles.ts
-var fs13 = __toESM(require("fs/promises"), 1);
-var os6 = __toESM(require("os"), 1);
-var path17 = __toESM(require("path"), 1);
-var import_node_crypto5 = require("crypto");
+var fs17 = __toESM(require("fs/promises"), 1);
+var os7 = __toESM(require("os"), 1);
+var path21 = __toESM(require("path"), 1);
+var import_node_crypto8 = require("crypto");
 
 // src/jetbrainsMcpConfig.ts
-var fs12 = __toESM(require("fs/promises"), 1);
+var fs13 = __toESM(require("fs/promises"), 1);
 var os5 = __toESM(require("os"), 1);
-var path16 = __toESM(require("path"), 1);
+var path17 = __toESM(require("path"), 1);
 var import_node_crypto4 = require("crypto");
 var import_node_child_process5 = require("child_process");
-
-// src/configUtils.ts
-var DEFAULT_API_URL = "http://localhost:3001";
-var DEV_API_URL = "http://localhost:3001";
-function resolveApiUrl(env2) {
-  const explicitUrl = env2.MEMORAONE_API_URL?.trim();
-  if (explicitUrl) {
-    return explicitUrl;
-  }
-  const aliasUrl = env2.MEMORA_API_URL?.trim();
-  if (aliasUrl) {
-    return aliasUrl;
-  }
-  if (env2.MEMORAONE_DEV_MODE === "1") {
-    return DEV_API_URL;
-  }
-  return DEFAULT_API_URL;
-}
-
-// src/jetbrainsMcpConfig.ts
 var JETBRAINS_DEBUG_ENV_VARS = [
   "MEMORAONE_DEBUG_INIT",
   "MEMORAONE_DEBUG_MINIMAL_TOOLS",
@@ -3251,7 +3484,7 @@ function stripLeadingLineComments2(text) {
 }
 async function pathExists3(filePath) {
   try {
-    await fs12.access(filePath);
+    await fs13.access(filePath);
     return true;
   } catch {
     return false;
@@ -3262,12 +3495,12 @@ function formatJetBrainsBackupTimestamp(d = /* @__PURE__ */ new Date()) {
   return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
 }
 function getJetBrainsGlobalMcpConfigPath(homeDir) {
-  return path16.join(homeDir, ".ai", "mcp", "mcp.json");
+  return path17.join(homeDir, ".ai", "mcp", "mcp.json");
 }
 function getJetBrainsProjectMcpConfigPaths(repoRoot) {
   return [
-    { kind: "project-ai", path: path16.join(repoRoot, ".ai", "mcp", "mcp.json") },
-    { kind: "project-ij", path: path16.join(repoRoot, ".ij", "mcp", "mcp.json") }
+    { kind: "project-ai", path: path17.join(repoRoot, ".ai", "mcp", "mcp.json") },
+    { kind: "project-ij", path: path17.join(repoRoot, ".ij", "mcp", "mcp.json") }
   ];
 }
 function getKnownJetBrainsMcpConfigLocations(homeDir, repoRoot) {
@@ -3278,7 +3511,7 @@ function getKnownJetBrainsMcpConfigLocations(homeDir, repoRoot) {
 }
 async function isZeroByteConfigFile(filePath) {
   if (!await pathExists3(filePath)) return false;
-  const stat4 = await fs12.stat(filePath);
+  const stat4 = await fs13.stat(filePath);
   return stat4.size === 0;
 }
 function buildMemoraoneJetBrainsMcpServer(options) {
@@ -3289,7 +3522,7 @@ function buildMemoraoneJetBrainsMcpServer(options) {
       apiUrl: options.apiUrl ?? (environment === "local" ? DEV_API_URL : void 0)
     }),
     MEMORAONE_IDE_TYPE: "jetbrains",
-    [MEMORAONE_WORKSPACE_ROOT_ENV]: path16.resolve(options.workspaceRoot)
+    [MEMORAONE_WORKSPACE_ROOT_ENV]: path17.resolve(options.workspaceRoot)
   };
   if (environment === "local" || options.devMode) {
     env2.MEMORAONE_DEV_MODE = "1";
@@ -3311,18 +3544,18 @@ function mergeJetBrainsMcpConfigObject(existing, memoraone) {
   return { ...base, mcpServers };
 }
 async function writeJetBrainsMcpJsonAtomic(filePath, content) {
-  const dir = path16.dirname(filePath);
-  await fs12.mkdir(dir, { recursive: true });
-  const tmpPath = path16.join(
+  const dir = path17.dirname(filePath);
+  await fs13.mkdir(dir, { recursive: true });
+  const tmpPath = path17.join(
     dir,
-    `.${path16.basename(filePath)}.${process.pid}.${(0, import_node_crypto4.randomBytes)(8).toString("hex")}.tmp`
+    `.${path17.basename(filePath)}.${process.pid}.${(0, import_node_crypto4.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs12.writeFile(tmpPath, content, "utf8");
-    await fs12.rename(tmpPath, filePath);
+    await fs13.writeFile(tmpPath, content, "utf8");
+    await fs13.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs12.unlink(tmpPath);
+      await fs13.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -3363,13 +3596,13 @@ function validateJetBrainsMcpConfig(parsed2, expected) {
   }
 }
 async function readJsonConfig(filePath) {
-  const raw = await fs12.readFile(filePath, "utf8");
+  const raw = await fs13.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments2(raw));
 }
 async function backupConfigFile(filePath) {
   const backupPath = `${filePath}.bak-${formatJetBrainsBackupTimestamp()}`;
-  await fs12.copyFile(filePath, backupPath);
+  await fs13.copyFile(filePath, backupPath);
   return backupPath;
 }
 async function repairZeroByteConfigFile(filePath, dryRun) {
@@ -3380,7 +3613,7 @@ async function repairZeroByteConfigFile(filePath, dryRun) {
     return { repaired: true, backupPath: `${filePath}.bak-<timestamp>` };
   }
   const backupPath = await backupConfigFile(filePath);
-  await fs12.unlink(filePath);
+  await fs13.unlink(filePath);
   return { repaired: true, backupPath };
 }
 function configHasMemoraone(parsed2) {
@@ -3411,24 +3644,24 @@ async function removeMemoraoneFromProjectConfig(options) {
   delete mcpServers.memoraone;
   const hasOtherServers = Object.keys(mcpServers).length > 0;
   if (!hasOtherServers) {
-    await fs12.unlink(configPath);
+    await fs13.unlink(configPath);
     return { changed: true, backupPath };
   }
   const next = { ...parsed2, mcpServers };
-  await fs12.mkdir(path16.dirname(configPath), { recursive: true });
-  await fs12.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
+  await fs13.mkdir(path17.dirname(configPath), { recursive: true });
+  await fs13.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
   return { changed: true, backupPath };
 }
 async function resolveLocalCliPathAsync() {
-  const here = process.argv[1] ? path16.dirname(path16.resolve(process.argv[1])) : process.cwd();
+  const here = process.argv[1] ? path17.dirname(path17.resolve(process.argv[1])) : process.cwd();
   const candidates = [
-    path16.join(here, "cli.cjs"),
-    path16.join(here, "..", "dist", "cli.cjs"),
-    path16.join(here, "..", "..", "dist", "cli.cjs")
+    path17.join(here, "cli.cjs"),
+    path17.join(here, "..", "dist", "cli.cjs"),
+    path17.join(here, "..", "..", "dist", "cli.cjs")
   ];
   for (const candidate of candidates) {
     if (await pathExists3(candidate)) {
-      return path16.resolve(candidate);
+      return path17.resolve(candidate);
     }
   }
   return null;
@@ -3485,7 +3718,7 @@ function formatOptionalJetBrainsHandshakeUnavailableDetail(detail) {
 async function verifyJetBrainsMcpHandshake(options) {
   const timeoutMs = options.timeoutMs ?? 15e3;
   const { server } = options;
-  return new Promise((resolve17) => {
+  return new Promise((resolve21) => {
     let settled = false;
     const finish = (ok, detail, optionalUnavailable) => {
       if (settled) return;
@@ -3495,7 +3728,7 @@ async function verifyJetBrainsMcpHandshake(options) {
         child.kill();
       } catch {
       }
-      resolve17({ ok, detail, optionalUnavailable });
+      resolve21({ ok, detail, optionalUnavailable });
     };
     const child = (0, import_node_child_process5.spawn)(server.command, [...server.args], {
       env: { ...process.env, ...server.env },
@@ -3569,7 +3802,7 @@ async function verifyJetBrainsMcpHandshake(options) {
 async function setupJetBrainsMcpConfig(options) {
   const homeDir = options.homeDir ?? os5.homedir();
   const globalPath = options.globalConfigPath ?? getJetBrainsGlobalMcpConfigPath(homeDir);
-  const workspaceRoot = path16.resolve(options.repoRoot);
+  const workspaceRoot = path17.resolve(options.repoRoot);
   const repairActions = [];
   const allLocations = getKnownJetBrainsMcpConfigLocations(homeDir, options.repoRoot);
   for (const location of allLocations) {
@@ -3642,7 +3875,7 @@ async function setupJetBrainsMcpConfig(options) {
     backupPath = await backupConfigFile(globalPath);
   }
   await writeJetBrainsMcpJsonAtomic(globalPath, body);
-  const verifyRaw = await fs12.readFile(globalPath, "utf8");
+  const verifyRaw = await fs13.readFile(globalPath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments2(verifyRaw));
   validateJetBrainsMcpConfig(verifyParsed, memoraone);
   const outcome = existed ? "updated" : "created";
@@ -3710,51 +3943,1010 @@ function logJetBrainsMcpCliSummary(info, dryRun, println = console.log) {
   );
 }
 
-// src/openCursorMcpSettings.ts
-var import_node_child_process6 = require("child_process");
-var readline4 = __toESM(require("readline/promises"), 1);
-var import_node_util4 = require("util");
-
-// src/terminalPresentation.ts
-var ANSI = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  cyan: "\x1B[36m"
-};
-function isCiLikeEnv(env2 = process.env) {
-  if (env2.CI === "true" || env2.CI === "1") return true;
-  if (env2.GITHUB_ACTIONS === "true" || env2.GITHUB_ACTIONS === "1") return true;
-  if (env2.GITLAB_CI === "true" || env2.GITLAB_CI === "1") return true;
-  if (env2.CIRCLECI === "true" || env2.CIRCLECI === "1") return true;
-  if (env2.BUILDKITE === "true" || env2.BUILDKITE === "1") return true;
-  if (typeof env2.CI === "string" && env2.CI.trim() !== "" && env2.CI !== "0" && env2.CI !== "false") {
+// src/windsurfMcpConfig.ts
+var fs14 = __toESM(require("fs/promises"), 1);
+var os6 = __toESM(require("os"), 1);
+var path18 = __toESM(require("path"), 1);
+var import_node_crypto5 = require("crypto");
+function stripLeadingLineComments3(text) {
+  return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
+}
+async function pathExists4(filePath) {
+  try {
+    await fs14.access(filePath);
     return true;
+  } catch {
+    return false;
   }
-  return false;
 }
-function shouldEnableAnsiColor(opts = {}) {
-  if (typeof opts.color === "boolean") return opts.color;
-  const env2 = opts.env ?? process.env;
-  if (env2.NO_COLOR !== void 0) return false;
-  if (isCiLikeEnv(env2)) return false;
-  const tty = opts.stdoutIsTty ?? process.stdout.isTTY === true;
-  return tty;
+function getWindsurfGlobalMcpConfigPath(homeDir) {
+  return path18.join(homeDir, ".config", "devin", "mcp_config.json");
 }
-function shouldUseUnicodeSymbols(opts = {}) {
-  if (typeof opts.unicode === "boolean") return opts.unicode;
-  const env2 = opts.env ?? process.env;
-  const tty = opts.stdoutIsTty ?? process.stdout.isTTY === true;
-  if (!tty) return false;
-  if (env2.TERM === "dumb") return false;
-  if (process.platform === "win32") {
-    return Boolean(
-      env2.WT_SESSION || env2.WT_PROFILE_ID || env2.ConEmuANSI === "ON" || env2.TERM_PROGRAM === "vscode" || env2.TERM_PROGRAM === "cursor" || typeof env2.TERM === "string" && env2.TERM !== "" && env2.TERM !== "dumb"
+function getWindsurfLegacyMcpConfigPath(homeDir) {
+  return path18.join(homeDir, ".codeium", "windsurf", "mcp_config.json");
+}
+function formatWindsurfBackupTimestamp(d = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+function buildMemoraoneWindsurfMcpServer(options) {
+  const environment = options.environment ?? (options.devMode ? "local" : "production");
+  const env2 = {
+    MEMORAONE_API_URL: resolveIdeApiUrl({
+      environment,
+      apiUrl: options.apiUrl ?? (environment === "local" ? DEV_API_URL : void 0)
+    }),
+    MEMORAONE_IDE_TYPE: "windsurf",
+    [MEMORAONE_WORKSPACE_ROOT_ENV]: path18.resolve(options.workspaceRoot)
+  };
+  if (environment === "local" || options.devMode) {
+    env2.MEMORAONE_DEV_MODE = "1";
+  }
+  if ("MEMORAONE_M1_PATH" in env2 || "MEMORAONE_API_KEY" in env2) {
+    throw new Error(
+      "[setup-ide-files] Devin Desktop MCP config must not include credentials or .m1 paths"
     );
   }
-  return true;
+  return {
+    command: options.command,
+    args: options.args,
+    env: env2
+  };
+}
+function mergeWindsurfMcpConfigObject(existing, memoraone) {
+  const base = existing && typeof existing === "object" ? { ...existing } : { mcpServers: {} };
+  const mcpServers = typeof base.mcpServers === "object" && base.mcpServers !== null && !Array.isArray(base.mcpServers) ? { ...base.mcpServers } : {};
+  delete mcpServers.memoraone;
+  mcpServers.memoraone = memoraone;
+  return { ...base, mcpServers };
+}
+function stripMemoraoneFromWindsurfConfigObject(existing) {
+  const base = { ...existing };
+  if (typeof base.mcpServers !== "object" || base.mcpServers === null || Array.isArray(base.mcpServers)) {
+    return { next: base, removed: false };
+  }
+  const mcpServers = { ...base.mcpServers };
+  if (!("memoraone" in mcpServers)) {
+    return { next: base, removed: false };
+  }
+  delete mcpServers.memoraone;
+  return { next: { ...base, mcpServers }, removed: true };
+}
+async function writeWindsurfMcpJsonAtomic(filePath, content) {
+  const dir = path18.dirname(filePath);
+  await fs14.mkdir(dir, { recursive: true });
+  const tmpPath = path18.join(
+    dir,
+    `.${path18.basename(filePath)}.${process.pid}.${(0, import_node_crypto5.randomBytes)(8).toString("hex")}.tmp`
+  );
+  try {
+    await fs14.writeFile(tmpPath, content, "utf8");
+    await fs14.rename(tmpPath, filePath);
+  } catch (err) {
+    try {
+      await fs14.unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+function memoraoneServerMatches2(server, expected) {
+  if (!server || typeof server !== "object") return false;
+  const s = server;
+  if (s.command !== expected.command) return false;
+  if (!Array.isArray(s.args) || s.args.length !== expected.args.length) return false;
+  for (let i = 0; i < expected.args.length; i += 1) {
+    if (s.args[i] !== expected.args[i]) return false;
+  }
+  const env2 = s.env;
+  if (!env2 || typeof env2 !== "object") return false;
+  const e = env2;
+  for (const [key, value] of Object.entries(expected.env)) {
+    if (e[key] !== value) return false;
+  }
+  return true;
+}
+function validateWindsurfMcpConfig(parsed2, expected) {
+  if (!parsed2 || typeof parsed2 !== "object") {
+    throw new Error("[setup-ide-files] Devin Desktop MCP config must be a JSON object.");
+  }
+  const mcpServers = parsed2.mcpServers;
+  if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    throw new Error("[setup-ide-files] Devin Desktop MCP config missing mcpServers object.");
+  }
+  const memoraone = mcpServers.memoraone;
+  if (!memoraoneServerMatches2(memoraone, expected)) {
+    throw new Error(
+      "[setup-ide-files] Devin Desktop MCP config mcpServers.memoraone is missing or invalid."
+    );
+  }
+}
+async function readJsonConfig2(filePath) {
+  const raw = await fs14.readFile(filePath, "utf8");
+  if (raw.trim() === "") return null;
+  return JSON.parse(stripLeadingLineComments3(raw));
+}
+async function backupConfigFile2(filePath) {
+  const backupPath = `${filePath}.bak-${formatWindsurfBackupTimestamp()}`;
+  await fs14.copyFile(filePath, backupPath);
+  return backupPath;
+}
+function extractMemoraone(existing) {
+  if (!existing || typeof existing.mcpServers !== "object" || existing.mcpServers === null || Array.isArray(existing.mcpServers)) {
+    return void 0;
+  }
+  return existing.mcpServers.memoraone;
+}
+async function buildWindsurfMemoraoneServer(options) {
+  const environment = options.environment ?? (options.devMode ? "local" : "production");
+  if (environment === "local" || options.devMode) {
+    let cliPath = options.cliPathOverride;
+    if (cliPath === void 0) {
+      cliPath = await resolveLocalCliPathAsync();
+    }
+    if (!cliPath) {
+      throw new Error(
+        "[setup-ide-files] Dev mode requires a built CLI at packages/mcp/dist/cli.cjs. Run pnpm build first."
+      );
+    }
+    return buildMemoraoneWindsurfMcpServer({
+      command: process.execPath,
+      args: [cliPath],
+      workspaceRoot: options.workspaceRoot,
+      environment: "local",
+      devMode: true,
+      apiUrl: options.apiUrl
+    });
+  }
+  let npxPath = options.npxPathOverride;
+  if (npxPath === void 0) {
+    npxPath = await resolveNpxPath();
+  }
+  if (!npxPath) {
+    throw new Error(
+      "[setup-ide-files] Could not resolve a working npx executable. Install Node.js/npm or ensure npx is on PATH before configuring Devin Desktop MCP."
+    );
+  }
+  const channel = options.npmPackageChannel ?? npmPackageChannelFromEnvironment(environment);
+  return buildMemoraoneWindsurfMcpServer({
+    command: npxPath,
+    args: ["-y", memoraoneNpmPackageSpec(channel)],
+    workspaceRoot: options.workspaceRoot,
+    environment,
+    devMode: false,
+    apiUrl: options.apiUrl
+  });
+}
+async function setupWindsurfMcpConfig(options) {
+  const homeDir = options.homeDir ?? os6.homedir();
+  const activePath = options.globalConfigPath ?? getWindsurfGlobalMcpConfigPath(homeDir);
+  const legacyPath = options.legacyConfigPath ?? getWindsurfLegacyMcpConfigPath(homeDir);
+  const samePath = path18.resolve(activePath) === path18.resolve(legacyPath);
+  const workspaceRoot = path18.resolve(options.repoRoot);
+  const memoraone = await buildWindsurfMemoraoneServer({
+    workspaceRoot,
+    devMode: options.devMode,
+    environment: options.environment,
+    npmPackageChannel: options.npmPackageChannel,
+    apiUrl: options.apiUrl,
+    npxPathOverride: options.npxPathOverride,
+    cliPathOverride: options.cliPathOverride
+  });
+  const activeExisted = await pathExists4(activePath);
+  let activeExisting = null;
+  if (activeExisted) {
+    try {
+      activeExisting = await readJsonConfig2(activePath);
+    } catch {
+      throw new Error(
+        `[setup-ide-files] Invalid JSON in shared Devin Desktop MCP config (file preserved, not modified): ${activePath}. Fix or remove the file, then re-run setup-ide-files.`
+      );
+    }
+  }
+  let legacyExisting = null;
+  let legacyMalformed = false;
+  const legacyExisted = !samePath && await pathExists4(legacyPath);
+  if (legacyExisted) {
+    try {
+      legacyExisting = await readJsonConfig2(legacyPath);
+    } catch {
+      legacyMalformed = true;
+    }
+  }
+  if (!activeExisted && legacyMalformed) {
+    throw new Error(
+      `[setup-ide-files] Invalid JSON in legacy Windsurf MCP config (file preserved, not modified): ${legacyPath}. Fix or remove the file, then re-run setup-ide-files. Active Devin Desktop path was not written: ${activePath}.`
+    );
+  }
+  const mergeBase = activeExisted ? activeExisting : legacyExisting;
+  const merged = mergeWindsurfMcpConfigObject(mergeBase, memoraone);
+  const body = JSON.stringify(merged, null, 2) + "\n";
+  const activeMemoraone = extractMemoraone(activeExisting);
+  const activeAlreadyCorrect = activeExisted && memoraoneServerMatches2(activeMemoraone, memoraone);
+  let legacyNeedsCleanup = false;
+  if (legacyExisted && !legacyMalformed && legacyExisting) {
+    const legacyMemoraone = extractMemoraone(legacyExisting);
+    legacyNeedsCleanup = legacyMemoraone !== void 0;
+  }
+  if (activeAlreadyCorrect && !legacyNeedsCleanup) {
+    return {
+      outcome: "skipped",
+      memoraone,
+      activeConfigPath: activePath,
+      legacyConfigPath: legacyPath,
+      legacyCleanup: legacyExisted ? legacyMalformed ? "malformed" : "unchanged" : "absent",
+      warning: legacyMalformed ? `[setup-ide-files] Legacy Windsurf MCP config has invalid JSON and was left unchanged: ${legacyPath}` : void 0
+    };
+  }
+  if (options.dryRun) {
+    let legacyCleanup2 = "absent";
+    if (legacyExisted) {
+      if (legacyMalformed) legacyCleanup2 = "malformed";
+      else if (legacyNeedsCleanup) legacyCleanup2 = "skipped-dry-run";
+      else legacyCleanup2 = "unchanged";
+    }
+    return {
+      outcome: activeExisted ? "updated" : "created",
+      memoraone,
+      activeConfigPath: activePath,
+      legacyConfigPath: legacyPath,
+      legacyCleanup: legacyCleanup2,
+      warning: legacyMalformed ? `[setup-ide-files] Legacy Windsurf MCP config has invalid JSON and was left unchanged: ${legacyPath}` : void 0
+    };
+  }
+  let backupPath;
+  if (activeExisted && !activeAlreadyCorrect) {
+    backupPath = await backupConfigFile2(activePath);
+  }
+  if (!activeAlreadyCorrect) {
+    await writeWindsurfMcpJsonAtomic(activePath, body);
+    const verifyRaw = await fs14.readFile(activePath, "utf8");
+    const verifyParsed = JSON.parse(stripLeadingLineComments3(verifyRaw));
+    validateWindsurfMcpConfig(verifyParsed, memoraone);
+  }
+  let legacyCleanup = "absent";
+  let warning;
+  if (legacyExisted) {
+    if (legacyMalformed) {
+      legacyCleanup = "malformed";
+      warning = `[setup-ide-files] Legacy Windsurf MCP config has invalid JSON and was left unchanged: ${legacyPath}. Devin Desktop active config was written; fix or remove the legacy file to avoid ambiguity.`;
+    } else if (legacyNeedsCleanup && legacyExisting) {
+      await backupConfigFile2(legacyPath);
+      const { next, removed } = stripMemoraoneFromWindsurfConfigObject(legacyExisting);
+      if (removed) {
+        const legacyBody = JSON.stringify(next, null, 2) + "\n";
+        await writeWindsurfMcpJsonAtomic(legacyPath, legacyBody);
+        legacyCleanup = "removed-memoraone";
+      } else {
+        legacyCleanup = "unchanged";
+      }
+    } else {
+      legacyCleanup = "unchanged";
+    }
+  }
+  return {
+    outcome: activeExisted ? "updated" : "created",
+    backupPath,
+    memoraone,
+    activeConfigPath: activePath,
+    legacyConfigPath: legacyPath,
+    legacyCleanup,
+    warning
+  };
+}
+function logWindsurfMcpCliSummary(info, dryRun, println = console.log) {
+  const prefix = dryRun ? "would be " : "";
+  if (info.outcome === "created") {
+    println(
+      `[setup-ide-files] Devin Desktop global MCP config ${prefix}created: ${info.activeConfigPath}`
+    );
+  } else if (info.outcome === "updated") {
+    println(
+      `[setup-ide-files] Devin Desktop global MCP config ${prefix}updated: ${info.activeConfigPath}`
+    );
+  } else {
+    println(
+      `[setup-ide-files] Devin Desktop global MCP config unchanged: ${info.activeConfigPath}`
+    );
+  }
+  if (info.backupPath) {
+    println(`[setup-ide-files] Devin Desktop global MCP config backup: ${info.backupPath}`);
+  }
+  if (info.legacyConfigPath) {
+    println(`[setup-ide-files] Legacy Windsurf MCP config path: ${info.legacyConfigPath}`);
+  }
+  if (info.legacyCleanup === "removed-memoraone") {
+    println(
+      `[setup-ide-files] Removed mcpServers.memoraone from legacy Windsurf MCP config: ${info.legacyConfigPath}`
+    );
+  } else if (info.legacyCleanup === "skipped-dry-run") {
+    println(
+      `[setup-ide-files] Legacy Windsurf mcpServers.memoraone would be removed: ${info.legacyConfigPath}`
+    );
+  }
+  if (info.warning) {
+    println(info.warning);
+  }
+  if (info.npxPath) {
+    println(`[setup-ide-files] Resolved npx: ${info.npxPath}`);
+  }
+  println(`[setup-ide-files] Final active Devin Desktop MCP config: ${info.activeConfigPath}`);
+  println(
+    "[setup-ide-files] Refresh MCP servers in Devin Desktop settings, or restart Devin Desktop, for MCP changes to take effect."
+  );
+}
+
+// src/opencodeMcpConfig.ts
+var fs15 = __toESM(require("fs/promises"), 1);
+var path19 = __toESM(require("path"), 1);
+var import_node_crypto6 = require("crypto");
+var OPENCODE_CONFIG_SCHEMA_URL = "https://opencode.ai/config.json";
+var OpenCodeMcpJsonParseError = class extends Error {
+  constructor(configPath) {
+    super(
+      `[setup-ide-files] Invalid JSON in shared OpenCode MCP config (file preserved, not modified): ${configPath}. Fix or remove the file, then re-run setup-ide-files.`
+    );
+    this.name = "OpenCodeMcpJsonParseError";
+    this.configPath = configPath;
+  }
+};
+var OpenCodeJsoncOnlyError = class extends Error {
+  constructor(configPath) {
+    super(
+      `[setup-ide-files] Project OpenCode config is JSONC-only (file preserved, not modified): ${configPath}. Automatic setup manages opencode.json only and cannot safely preserve JSONC comments. Add or convert to opencode.json, then re-run setup-ide-files.`
+    );
+    this.name = "OpenCodeJsoncOnlyError";
+    this.configPath = configPath;
+  }
+};
+async function pathExists5(filePath) {
+  try {
+    await fs15.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getOpenCodeProjectMcpConfigPath(repoRoot) {
+  return path19.join(path19.resolve(repoRoot), "opencode.json");
+}
+function getOpenCodeProjectJsoncConfigPath(repoRoot) {
+  return path19.join(path19.resolve(repoRoot), "opencode.jsonc");
+}
+function buildMemoraoneOpenCodeMcpServer(options) {
+  const environment = options.environment ?? (options.devMode ? "local" : "production");
+  const env2 = {
+    MEMORAONE_API_URL: resolveIdeApiUrl({
+      environment,
+      apiUrl: options.apiUrl ?? (environment === "local" ? DEV_API_URL : void 0)
+    }),
+    MEMORAONE_IDE_TYPE: "opencode",
+    [MEMORAONE_WORKSPACE_ROOT_ENV]: path19.resolve(options.workspaceRoot)
+  };
+  if (environment === "local" || options.devMode) {
+    env2.MEMORAONE_DEV_MODE = "1";
+  }
+  if ("MEMORAONE_M1_PATH" in env2 || "MEMORAONE_API_KEY" in env2) {
+    throw new Error("[setup-ide-files] OpenCode MCP config must not include credentials or .m1 paths");
+  }
+  return {
+    type: "local",
+    command: [options.command, ...options.args],
+    environment: env2,
+    enabled: true
+  };
+}
+function mergeOpenCodeMcpConfigObject(existing, memoraone) {
+  const base = existing && typeof existing === "object" ? { ...existing } : { $schema: OPENCODE_CONFIG_SCHEMA_URL };
+  const mcp = typeof base.mcp === "object" && base.mcp !== null && !Array.isArray(base.mcp) ? { ...base.mcp } : {};
+  delete mcp.memoraone;
+  if (typeof mcp.servers === "object" && mcp.servers !== null && !Array.isArray(mcp.servers)) {
+    const servers = { ...mcp.servers };
+    delete servers.memoraone;
+    if (Object.keys(servers).length === 0) {
+      delete mcp.servers;
+    } else {
+      mcp.servers = servers;
+    }
+  }
+  mcp.memoraone = memoraone;
+  return { ...base, mcp };
+}
+async function writeOpenCodeMcpJsonAtomic(filePath, content) {
+  const dir = path19.dirname(filePath);
+  await fs15.mkdir(dir, { recursive: true });
+  const tmpPath = path19.join(
+    dir,
+    `.${path19.basename(filePath)}.${process.pid}.${(0, import_node_crypto6.randomBytes)(8).toString("hex")}.tmp`
+  );
+  try {
+    await fs15.writeFile(tmpPath, content, "utf8");
+    await fs15.rename(tmpPath, filePath);
+  } catch (err) {
+    try {
+      await fs15.unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+function memoraoneServerMatches3(server, expected) {
+  if (!server || typeof server !== "object") return false;
+  const s = server;
+  if (s.type !== "local") return false;
+  if (s.enabled !== true) return false;
+  if (!Array.isArray(s.command) || s.command.length !== expected.command.length) return false;
+  for (let i = 0; i < expected.command.length; i += 1) {
+    if (s.command[i] !== expected.command[i]) return false;
+  }
+  const environment = s.environment;
+  if (!environment || typeof environment !== "object") return false;
+  const e = environment;
+  for (const [key, value] of Object.entries(expected.environment)) {
+    if (e[key] !== value) return false;
+  }
+  return true;
+}
+function validateOpenCodeMcpConfig(parsed2, expected) {
+  if (!parsed2 || typeof parsed2 !== "object") {
+    throw new Error("[setup-ide-files] OpenCode MCP config must be a JSON object.");
+  }
+  const mcp = parsed2.mcp;
+  if (!mcp || typeof mcp !== "object" || Array.isArray(mcp)) {
+    throw new Error("[setup-ide-files] OpenCode MCP config missing mcp object.");
+  }
+  const memoraone = mcp.memoraone;
+  if (!memoraoneServerMatches3(memoraone, expected)) {
+    throw new Error(
+      "[setup-ide-files] OpenCode MCP config mcp.memoraone is missing or invalid."
+    );
+  }
+}
+async function readJsonConfig3(filePath) {
+  const raw = await fs15.readFile(filePath, "utf8");
+  if (raw.trim() === "") return null;
+  return JSON.parse(raw);
+}
+async function buildOpenCodeMemoraoneServer(options) {
+  const environment = options.environment ?? (options.devMode ? "local" : "production");
+  if (environment === "local" || options.devMode) {
+    let cliPath = options.cliPathOverride;
+    if (cliPath === void 0) {
+      cliPath = await resolveLocalCliPathAsync();
+    }
+    if (!cliPath) {
+      throw new Error(
+        "[setup-ide-files] Dev mode requires a built CLI at packages/mcp/dist/cli.cjs. Run pnpm build first."
+      );
+    }
+    return buildMemoraoneOpenCodeMcpServer({
+      command: process.execPath,
+      args: [cliPath],
+      workspaceRoot: options.workspaceRoot,
+      environment: "local",
+      devMode: true,
+      apiUrl: options.apiUrl
+    });
+  }
+  let npxPath = options.npxPathOverride;
+  if (npxPath === void 0) {
+    npxPath = await resolveNpxPath();
+  }
+  if (!npxPath) {
+    throw new Error(
+      "[setup-ide-files] Could not resolve a working npx executable. Install Node.js/npm or ensure npx is on PATH before configuring OpenCode MCP."
+    );
+  }
+  const channel = options.npmPackageChannel ?? npmPackageChannelFromEnvironment(environment);
+  return buildMemoraoneOpenCodeMcpServer({
+    command: npxPath,
+    args: ["-y", memoraoneNpmPackageSpec(channel)],
+    workspaceRoot: options.workspaceRoot,
+    environment,
+    devMode: false,
+    apiUrl: options.apiUrl
+  });
+}
+async function setupOpenCodeMcpConfig(options) {
+  const projectPath = options.projectConfigPath ?? getOpenCodeProjectMcpConfigPath(options.repoRoot);
+  const jsoncPath = getOpenCodeProjectJsoncConfigPath(options.repoRoot);
+  const workspaceRoot = path19.resolve(options.repoRoot);
+  const memoraone = await buildOpenCodeMemoraoneServer({
+    workspaceRoot,
+    devMode: options.devMode,
+    environment: options.environment,
+    npmPackageChannel: options.npmPackageChannel,
+    apiUrl: options.apiUrl,
+    npxPathOverride: options.npxPathOverride,
+    cliPathOverride: options.cliPathOverride
+  });
+  const jsonExists = await pathExists5(projectPath);
+  const jsoncExists = await pathExists5(jsoncPath);
+  if (!jsonExists && jsoncExists) {
+    throw new OpenCodeJsoncOnlyError(jsoncPath);
+  }
+  let existing = null;
+  if (jsonExists) {
+    try {
+      existing = await readJsonConfig3(projectPath);
+    } catch {
+      throw new OpenCodeMcpJsonParseError(projectPath);
+    }
+    if (existing !== null && (typeof existing !== "object" || Array.isArray(existing))) {
+      throw new OpenCodeMcpJsonParseError(projectPath);
+    }
+  }
+  const merged = mergeOpenCodeMcpConfigObject(existing, memoraone);
+  const body = JSON.stringify(merged, null, 2) + "\n";
+  if (jsonExists && existing) {
+    const currentMemoraone = existing.mcp && typeof existing.mcp === "object" && !Array.isArray(existing.mcp) ? existing.mcp.memoraone : void 0;
+    if (memoraoneServerMatches3(currentMemoraone, memoraone)) {
+      return { outcome: "skipped", memoraone };
+    }
+  }
+  if (options.dryRun) {
+    return { outcome: jsonExists ? "updated" : "created", memoraone };
+  }
+  await writeOpenCodeMcpJsonAtomic(projectPath, body);
+  const verifyRaw = await fs15.readFile(projectPath, "utf8");
+  const verifyParsed = JSON.parse(verifyRaw);
+  validateOpenCodeMcpConfig(verifyParsed, memoraone);
+  return {
+    outcome: jsonExists ? "updated" : "created",
+    memoraone
+  };
+}
+function logOpenCodeMcpCliSummary(info, dryRun, println = console.log) {
+  const prefix = dryRun ? "would be " : "";
+  if (info.outcome === "created") {
+    println(`[setup-ide-files] OpenCode project MCP config ${prefix}created: ${info.activeConfigPath}`);
+  } else if (info.outcome === "updated") {
+    println(`[setup-ide-files] OpenCode project MCP config ${prefix}updated: ${info.activeConfigPath}`);
+  } else {
+    println(`[setup-ide-files] OpenCode project MCP config unchanged: ${info.activeConfigPath}`);
+  }
+  if (info.npxPath) {
+    println(`[setup-ide-files] Resolved npx: ${info.npxPath}`);
+  }
+  println(`[setup-ide-files] Final active OpenCode MCP config: ${info.activeConfigPath}`);
+  println(
+    "[setup-ide-files] Fully quit OpenCode and reopen this repo for MCP changes to take effect."
+  );
+}
+
+// src/codexMcpConfig.ts
+var fs16 = __toESM(require("fs/promises"), 1);
+var path20 = __toESM(require("path"), 1);
+var import_node_crypto7 = require("crypto");
+var import_smol_toml = require("smol-toml");
+var CODEX_MCP_SERVER_NAME = "memoraone";
+var CODEX_OWNED_TABLE_PREFIX = `mcp_servers.${CODEX_MCP_SERVER_NAME}`;
+var CodexMcpTomlParseError = class extends Error {
+  constructor(configPath) {
+    super(
+      `[setup-ide-files] Invalid TOML in shared Codex MCP config (file preserved, not modified): ${configPath}. Fix or remove the file, then re-run setup-ide-files.`
+    );
+    this.name = "CodexMcpTomlParseError";
+    this.configPath = configPath;
+  }
+};
+async function pathExists6(filePath) {
+  try {
+    await fs16.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getCodexProjectMcpConfigPath(repoRoot) {
+  return path20.join(path20.resolve(repoRoot), ".codex", "config.toml");
+}
+function escapeTomlBasicString(value) {
+  return '"' + value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r") + '"';
+}
+function formatMemoraoneCodexTomlTables(memoraone) {
+  const args2 = memoraone.args.map(escapeTomlBasicString).join(", ");
+  const envLines = Object.entries(memoraone.env).map(([key, value]) => `${key} = ${escapeTomlBasicString(value)}`).join("\n");
+  return `[mcp_servers.${CODEX_MCP_SERVER_NAME}]
+command = ${escapeTomlBasicString(memoraone.command)}
+args = [${args2}]
+
+[mcp_servers.${CODEX_MCP_SERVER_NAME}.env]
+${envLines}
+`;
+}
+function buildMemoraoneCodexMcpServer(options) {
+  const environment = options.environment ?? (options.devMode ? "local" : "production");
+  const env2 = {
+    MEMORAONE_API_URL: resolveIdeApiUrl({
+      environment,
+      apiUrl: options.apiUrl ?? (environment === "local" ? DEV_API_URL : void 0)
+    }),
+    MEMORAONE_IDE_TYPE: "codex",
+    [MEMORAONE_WORKSPACE_ROOT_ENV]: path20.resolve(options.workspaceRoot)
+  };
+  if (environment === "local" || options.devMode) {
+    env2.MEMORAONE_DEV_MODE = "1";
+  }
+  if ("MEMORAONE_M1_PATH" in env2 || "MEMORAONE_API_KEY" in env2) {
+    throw new Error("[setup-ide-files] Codex MCP config must not include credentials or .m1 paths");
+  }
+  return {
+    command: options.command,
+    args: [...options.args],
+    env: env2
+  };
+}
+function normalizeTomlTablePath(headerInner) {
+  return headerInner.split(".").map((part) => {
+    const trimmed = part.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+      return trimmed.slice(1, -1);
+    }
+    return trimmed;
+  }).join(".");
+}
+function isMemoraoneOwnedCodexTablePath(headerInner) {
+  const normalized = normalizeTomlTablePath(headerInner);
+  return normalized === CODEX_OWNED_TABLE_PREFIX || normalized.startsWith(`${CODEX_OWNED_TABLE_PREFIX}.`);
+}
+var TABLE_HEADER_RE = /^\s*\[\[?([^\]]+)\]\]?\s*(?:#.*)?$/;
+function splitTomlTableSegments(source) {
+  const lines = source.split(/(?<=\n)/);
+  const segments = [];
+  let current = { tablePath: null, arrayOfTables: false, start: 0, end: 0 };
+  let offset = 0;
+  for (const line of lines) {
+    const match = line.match(TABLE_HEADER_RE);
+    if (match) {
+      current.end = offset;
+      if (current.end > current.start || current.tablePath !== null) {
+        segments.push(current);
+      }
+      const arrayOfTables = /^\s*\[\[/.test(line);
+      current = {
+        tablePath: match[1].trim(),
+        arrayOfTables,
+        start: offset,
+        end: offset + line.length
+      };
+    } else {
+      current.end = offset + line.length;
+    }
+    offset += line.length;
+  }
+  current.end = source.length;
+  if (current.end > current.start || current.tablePath !== null) {
+    segments.push(current);
+  }
+  return segments;
+}
+function stripMemoraoneAssignmentsFromMcpServersBody(body) {
+  const lines = body.split(/(?<=\n)/);
+  const kept = [];
+  let skippingMultiline = false;
+  let multilineTerminator = null;
+  for (const line of lines) {
+    if (skippingMultiline) {
+      if (multilineTerminator && line.includes(multilineTerminator)) {
+        skippingMultiline = false;
+        multilineTerminator = null;
+      }
+      continue;
+    }
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      kept.push(line);
+      continue;
+    }
+    const assignMatch = trimmed.match(
+      /^(?:memoraone|"memoraone"|'memoraone')(?:\.[A-Za-z0-9_\-"']+)*\s*=\s*(.*)$/
+    );
+    if (!assignMatch) {
+      kept.push(line);
+      continue;
+    }
+    const rhs = assignMatch[1] ?? "";
+    if (rhs.startsWith('"""')) {
+      if (!rhs.slice(3).includes('"""')) {
+        skippingMultiline = true;
+        multilineTerminator = '"""';
+      }
+      continue;
+    }
+    if (rhs.startsWith("'''")) {
+      if (!rhs.slice(3).includes("'''")) {
+        skippingMultiline = true;
+        multilineTerminator = "'''";
+      }
+      continue;
+    }
+  }
+  return kept.join("");
+}
+function removeMemoraoneOwnedCodexToml(source) {
+  const segments = splitTomlTableSegments(source);
+  let removed = false;
+  const parts = [];
+  for (const segment of segments) {
+    if (segment.tablePath && isMemoraoneOwnedCodexTablePath(segment.tablePath)) {
+      removed = true;
+      continue;
+    }
+    const chunk = source.slice(segment.start, segment.end);
+    if (segment.tablePath && normalizeTomlTablePath(segment.tablePath) === "mcp_servers" && !segment.arrayOfTables) {
+      const headerEnd = chunk.indexOf("\n");
+      if (headerEnd === -1) {
+        parts.push(chunk);
+        continue;
+      }
+      const header = chunk.slice(0, headerEnd + 1);
+      const body = chunk.slice(headerEnd + 1);
+      const stripped = stripMemoraoneAssignmentsFromMcpServersBody(body);
+      if (stripped !== body) removed = true;
+      const hasKeys = stripped.split(/\r?\n/).some((line) => {
+        const t = line.trim();
+        return t.length > 0 && !t.startsWith("#");
+      });
+      if (!hasKeys && removed && body !== stripped) {
+        const otherServersRemain = segments.some(
+          (s) => s.tablePath != null && normalizeTomlTablePath(s.tablePath).startsWith("mcp_servers.") && !isMemoraoneOwnedCodexTablePath(s.tablePath)
+        );
+        if (!otherServersRemain) {
+          const hasComments = stripped.split(/\r?\n/).some((line) => line.trim().startsWith("#"));
+          if (hasComments) {
+            parts.push(header + stripped);
+          }
+          continue;
+        }
+      }
+      parts.push(header + stripped);
+      continue;
+    }
+    parts.push(chunk);
+  }
+  let remainder = parts.join("");
+  remainder = remainder.replace(/\n{3,}$/g, "\n\n");
+  if (remainder.length > 0 && !remainder.endsWith("\n")) {
+    remainder += "\n";
+  }
+  return { remainder, removed };
+}
+function mergeCodexMcpConfigToml(existingSource, memoraone) {
+  const ownedBlock = formatMemoraoneCodexTomlTables(memoraone);
+  if (existingSource === null || existingSource.trim() === "") {
+    return ownedBlock;
+  }
+  const { remainder } = removeMemoraoneOwnedCodexToml(existingSource);
+  if (remainder.trim() === "") {
+    return ownedBlock;
+  }
+  const sep2 = remainder.endsWith("\n\n") ? "" : remainder.endsWith("\n") ? "\n" : "\n\n";
+  return remainder + sep2 + ownedBlock;
+}
+function asStringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
+}
+function extractMemoraoneFromCodexParsed(parsed2) {
+  const root = asStringRecord(parsed2);
+  if (!root) return null;
+  const mcpServers = asStringRecord(root.mcp_servers);
+  if (!mcpServers) return null;
+  const memoraone = asStringRecord(mcpServers[CODEX_MCP_SERVER_NAME]);
+  if (!memoraone) return null;
+  if (typeof memoraone.command !== "string") return null;
+  if (!Array.isArray(memoraone.args) || !memoraone.args.every((a) => typeof a === "string")) {
+    return null;
+  }
+  const env2 = asStringRecord(memoraone.env);
+  if (!env2) return null;
+  if (typeof env2.MEMORAONE_API_URL !== "string") return null;
+  if (env2.MEMORAONE_IDE_TYPE !== "codex") return null;
+  if (typeof env2[MEMORAONE_WORKSPACE_ROOT_ENV] !== "string") return null;
+  const out = {
+    command: memoraone.command,
+    args: memoraone.args,
+    env: {
+      MEMORAONE_API_URL: env2.MEMORAONE_API_URL,
+      MEMORAONE_IDE_TYPE: "codex",
+      [MEMORAONE_WORKSPACE_ROOT_ENV]: env2[MEMORAONE_WORKSPACE_ROOT_ENV]
+    }
+  };
+  if (typeof env2.MEMORAONE_DEV_MODE === "string") {
+    out.env.MEMORAONE_DEV_MODE = env2.MEMORAONE_DEV_MODE;
+  }
+  return out;
+}
+function memoraoneServerMatches4(actual, expected) {
+  if (!actual) return false;
+  if (actual.command !== expected.command) return false;
+  if (actual.args.length !== expected.args.length) return false;
+  for (let i = 0; i < expected.args.length; i += 1) {
+    if (actual.args[i] !== expected.args[i]) return false;
+  }
+  for (const [key, value] of Object.entries(expected.env)) {
+    if (actual.env[key] !== value) return false;
+  }
+  for (const key of Object.keys(actual.env)) {
+    if (!(key in expected.env)) return false;
+  }
+  return true;
+}
+function validateCodexMcpConfig(parsed2, expected) {
+  const actual = extractMemoraoneFromCodexParsed(parsed2);
+  if (!memoraoneServerMatches4(actual, expected)) {
+    throw new Error(
+      "[setup-ide-files] Codex MCP config mcp_servers.memoraone is missing or invalid."
+    );
+  }
+}
+function parseCodexTomlOrThrow(source, configPath) {
+  try {
+    return (0, import_smol_toml.parse)(source);
+  } catch (err) {
+    if (err instanceof import_smol_toml.TomlError || err instanceof Error && err.name === "TomlError") {
+      throw new CodexMcpTomlParseError(configPath);
+    }
+    throw new CodexMcpTomlParseError(configPath);
+  }
+}
+async function writeCodexTomlAtomic(filePath, content) {
+  const dir = path20.dirname(filePath);
+  await fs16.mkdir(dir, { recursive: true });
+  const tmpPath = path20.join(
+    dir,
+    `.${path20.basename(filePath)}.${process.pid}.${(0, import_node_crypto7.randomBytes)(8).toString("hex")}.tmp`
+  );
+  try {
+    await fs16.writeFile(tmpPath, content, "utf8");
+    await fs16.rename(tmpPath, filePath);
+  } catch (err) {
+    try {
+      await fs16.unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function buildCodexMemoraoneServer(options) {
+  const environment = options.environment ?? (options.devMode ? "local" : "production");
+  if (environment === "local" || options.devMode) {
+    let cliPath = options.cliPathOverride;
+    if (cliPath === void 0) {
+      cliPath = await resolveLocalCliPathAsync();
+    }
+    if (!cliPath) {
+      throw new Error(
+        "[setup-ide-files] Dev mode requires a built CLI at packages/mcp/dist/cli.cjs. Run pnpm build first."
+      );
+    }
+    return buildMemoraoneCodexMcpServer({
+      command: process.execPath,
+      args: [cliPath],
+      workspaceRoot: options.workspaceRoot,
+      environment: "local",
+      devMode: true,
+      apiUrl: options.apiUrl
+    });
+  }
+  let npxPath = options.npxPathOverride;
+  if (npxPath === void 0) {
+    npxPath = await resolveNpxPath();
+  }
+  if (!npxPath) {
+    throw new Error(
+      "[setup-ide-files] Could not resolve a working npx executable. Install Node.js/npm or ensure npx is on PATH before configuring Codex MCP."
+    );
+  }
+  const channel = options.npmPackageChannel ?? npmPackageChannelFromEnvironment(environment);
+  return buildMemoraoneCodexMcpServer({
+    command: npxPath,
+    args: ["-y", memoraoneNpmPackageSpec(channel)],
+    workspaceRoot: options.workspaceRoot,
+    environment,
+    devMode: false,
+    apiUrl: options.apiUrl
+  });
+}
+async function setupCodexMcpConfig(options) {
+  const projectPath = options.projectConfigPath ?? getCodexProjectMcpConfigPath(options.repoRoot);
+  const workspaceRoot = path20.resolve(options.repoRoot);
+  const memoraone = await buildCodexMemoraoneServer({
+    workspaceRoot,
+    devMode: options.devMode,
+    environment: options.environment,
+    npmPackageChannel: options.npmPackageChannel,
+    apiUrl: options.apiUrl,
+    npxPathOverride: options.npxPathOverride,
+    cliPathOverride: options.cliPathOverride
+  });
+  const exists = await pathExists6(projectPath);
+  let existingRaw = null;
+  if (exists) {
+    existingRaw = await fs16.readFile(projectPath, "utf8");
+    const parsed2 = parseCodexTomlOrThrow(existingRaw, projectPath);
+    const current = extractMemoraoneFromCodexParsed(parsed2);
+    if (memoraoneServerMatches4(current, memoraone)) {
+      return { outcome: "skipped", memoraone };
+    }
+  }
+  const next = mergeCodexMcpConfigToml(existingRaw, memoraone);
+  if (options.dryRun) {
+    return { outcome: exists ? "updated" : "created", memoraone };
+  }
+  await writeCodexTomlAtomic(projectPath, next);
+  const verifyRaw = await fs16.readFile(projectPath, "utf8");
+  const verifyParsed = parseCodexTomlOrThrow(verifyRaw, projectPath);
+  validateCodexMcpConfig(verifyParsed, memoraone);
+  return {
+    outcome: exists ? "updated" : "created",
+    memoraone
+  };
+}
+function logCodexMcpCliSummary(info, dryRun, println = console.log) {
+  const prefix = dryRun ? "would be " : "";
+  if (info.outcome === "created") {
+    println(`[setup-ide-files] Codex project MCP config ${prefix}created: ${info.activeConfigPath}`);
+  } else if (info.outcome === "updated") {
+    println(`[setup-ide-files] Codex project MCP config ${prefix}updated: ${info.activeConfigPath}`);
+  } else {
+    println(`[setup-ide-files] Codex project MCP config unchanged: ${info.activeConfigPath}`);
+  }
+  if (info.npxPath) {
+    println(`[setup-ide-files] Resolved npx: ${info.npxPath}`);
+  }
+  println(`[setup-ide-files] Final active Codex MCP config: ${info.activeConfigPath}`);
+  println(
+    "[setup-ide-files] Trust this project in Codex if prompted, then restart Codex."
+  );
+}
+
+// src/openCursorMcpSettings.ts
+var import_node_child_process6 = require("child_process");
+var readline4 = __toESM(require("readline/promises"), 1);
+var import_node_util4 = require("util");
+
+// src/terminalPresentation.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m"
+};
+function isCiLikeEnv(env2 = process.env) {
+  if (env2.CI === "true" || env2.CI === "1") return true;
+  if (env2.GITHUB_ACTIONS === "true" || env2.GITHUB_ACTIONS === "1") return true;
+  if (env2.GITLAB_CI === "true" || env2.GITLAB_CI === "1") return true;
+  if (env2.CIRCLECI === "true" || env2.CIRCLECI === "1") return true;
+  if (env2.BUILDKITE === "true" || env2.BUILDKITE === "1") return true;
+  if (typeof env2.CI === "string" && env2.CI.trim() !== "" && env2.CI !== "0" && env2.CI !== "false") {
+    return true;
+  }
+  return false;
+}
+function shouldEnableAnsiColor(opts = {}) {
+  if (typeof opts.color === "boolean") return opts.color;
+  const env2 = opts.env ?? process.env;
+  if (env2.NO_COLOR !== void 0) return false;
+  if (isCiLikeEnv(env2)) return false;
+  const tty = opts.stdoutIsTty ?? process.stdout.isTTY === true;
+  return tty;
+}
+function shouldUseUnicodeSymbols(opts = {}) {
+  if (typeof opts.unicode === "boolean") return opts.unicode;
+  const env2 = opts.env ?? process.env;
+  const tty = opts.stdoutIsTty ?? process.stdout.isTTY === true;
+  if (!tty) return false;
+  if (env2.TERM === "dumb") return false;
+  if (process.platform === "win32") {
+    return Boolean(
+      env2.WT_SESSION || env2.WT_PROFILE_ID || env2.ConEmuANSI === "ON" || env2.TERM_PROGRAM === "vscode" || env2.TERM_PROGRAM === "cursor" || typeof env2.TERM === "string" && env2.TERM !== "" && env2.TERM !== "dumb"
+    );
+  }
+  return true;
 }
 function paint(enabled, code, text) {
   if (!enabled || text === "") return text;
@@ -3902,6 +5094,10 @@ async function runOpenCursorMcpSettingsFlow(deps = {}) {
 }
 
 // src/setupSuccessOutput.ts
+var CLAUDE_CODE_APPROVAL_FOLLOW_UP = "Approve the MemoraOne MCP server in Claude Code if prompted.";
+var WINDSURF_REFRESH_FOLLOW_UP = "Refresh MCP servers in Devin Desktop settings, or restart Devin Desktop.";
+var OPENCODE_RESTART_FOLLOW_UP = "Fully quit OpenCode and reopen this repo for MCP changes to take effect.";
+var CODEX_TRUST_FOLLOW_UP = "Trust this project in Codex if prompted, then restart Codex.";
 var RESTART_LINE = "Restart your IDEs to finish setup.";
 function formatSetupSuccessLines(opts = {}) {
   const tp = opts.presentation ?? createTerminalPresentation(opts.presentationOptions ?? { color: false, unicode: true });
@@ -3919,13 +5115,39 @@ function formatSetupSuccessLines(opts = {}) {
   if (targets.jetbrains) {
     lines.push(tp.checkLine("JetBrains configured"));
   }
-  const hasIde = Boolean(targets.cursor || targets.vscode || targets.jetbrains);
+  if (targets.claudeCode) {
+    lines.push(tp.checkLine("Claude Code configured"));
+  }
+  if (targets.windsurf) {
+    lines.push(tp.checkLine("Devin Desktop configured"));
+  }
+  if (targets.opencode) {
+    lines.push(tp.checkLine("OpenCode configured"));
+  }
+  if (targets.codex) {
+    lines.push(tp.checkLine("Codex configured"));
+  }
+  const hasIde = Boolean(
+    targets.cursor || targets.vscode || targets.jetbrains || targets.claudeCode || targets.windsurf || targets.opencode || targets.codex
+  );
   lines.push("");
   lines.push(tp.checkLine("MemoraOne is ready"));
   if (hasIde) {
     lines.push("");
     lines.push(RESTART_LINE);
   }
+  if (targets.claudeCode) {
+    lines.push(CLAUDE_CODE_APPROVAL_FOLLOW_UP);
+  }
+  if (targets.windsurf) {
+    lines.push(WINDSURF_REFRESH_FOLLOW_UP);
+  }
+  if (targets.opencode) {
+    lines.push(OPENCODE_RESTART_FOLLOW_UP);
+  }
+  if (targets.codex) {
+    lines.push(CODEX_TRUST_FOLLOW_UP);
+  }
   return lines;
 }
 function printSetupSuccess(opts, println = console.log) {
@@ -3942,13 +5164,14 @@ function buildMemoraoneMcpServer(ideType, options = {}) {
     MEMORAONE_API_URL: resolveIdeApiUrl({ environment, apiUrl: options.apiUrl }),
     MEMORAONE_IDE_TYPE: ideType
   };
+  const includeWorkspaceRoot = options.workspaceRoot !== void 0 && (environment === "local" || ideType === "cursor" || ideType === "claude-code");
+  if (includeWorkspaceRoot) {
+    env2[MEMORAONE_WORKSPACE_ROOT_ENV] = path21.resolve(options.workspaceRoot);
+  }
   if (environment === "local") {
     if (!options.cliPath) {
       throw new Error("[setup-ide-files] Local VS Code MCP config requires a built CLI path.");
     }
-    if (options.workspaceRoot !== void 0) {
-      env2[MEMORAONE_WORKSPACE_ROOT_ENV] = path17.resolve(options.workspaceRoot);
-    }
     return {
       command: "node",
       args: [options.cliPath],
@@ -3963,15 +5186,15 @@ function buildMemoraoneMcpServer(ideType, options = {}) {
   };
 }
 function assertUnderRepoRoot(repoRoot, absPath) {
-  const normRoot = path17.resolve(repoRoot) + path17.sep;
-  const normPath = path17.resolve(absPath);
-  if (normPath !== path17.resolve(repoRoot) && !normPath.startsWith(normRoot)) {
+  const normRoot = path21.resolve(repoRoot) + path21.sep;
+  const normPath = path21.resolve(absPath);
+  if (normPath !== path21.resolve(repoRoot) && !normPath.startsWith(normRoot)) {
     throw new Error(`[setup-ide-files] Refusing to write outside repo root: ${absPath}`);
   }
 }
-async function pathExists4(filePath) {
+async function pathExists7(filePath) {
   try {
-    await fs13.access(filePath);
+    await fs17.access(filePath);
     return true;
   } catch {
     return false;
@@ -3981,21 +5204,21 @@ async function ensureGitignoreMemoraone(_repoRoot, _opts) {
   return "skipped";
 }
 async function findRepoRoot(startDir) {
-  let current = path17.resolve(startDir);
-  const root = path17.parse(current).root;
+  let current = path21.resolve(startDir);
+  const root = path21.parse(current).root;
   while (true) {
-    const gitPath = path17.join(current, ".git");
-    const m1Path = path17.join(current, "memoraone.m1");
-    if (await pathExists4(gitPath) || await pathExists4(m1Path)) {
+    const gitPath = path21.join(current, ".git");
+    const m1Path = path21.join(current, "memoraone.m1");
+    if (await pathExists7(gitPath) || await pathExists7(m1Path)) {
       return current;
     }
     if (current === root) {
       return null;
     }
-    current = path17.dirname(current);
+    current = path21.dirname(current);
   }
 }
-function stripLeadingLineComments3(text) {
+function stripLeadingLineComments4(text) {
   return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
 }
 function cursorRuleBody() {
@@ -4047,18 +5270,18 @@ function buildVscodeMcpJsonBody(existing, options = {}) {
   return mcpJsonHeader() + JSON.stringify(merged, null, 2) + "\n";
 }
 async function writeSharedMcpJsonAtomic(filePath, content) {
-  const dir = path17.dirname(filePath);
-  await fs13.mkdir(dir, { recursive: true });
-  const tmpPath = path17.join(
+  const dir = path21.dirname(filePath);
+  await fs17.mkdir(dir, { recursive: true });
+  const tmpPath = path21.join(
     dir,
-    `.${path17.basename(filePath)}.${process.pid}.${(0, import_node_crypto5.randomBytes)(8).toString("hex")}.tmp`
+    `.${path21.basename(filePath)}.${process.pid}.${(0, import_node_crypto8.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs13.writeFile(tmpPath, content, "utf8");
-    await fs13.rename(tmpPath, filePath);
+    await fs17.writeFile(tmpPath, content, "utf8");
+    await fs17.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs13.unlink(tmpPath);
+      await fs17.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -4077,43 +5300,79 @@ function buildCursorMcpJsonBody(existing, writeOptions) {
   const merged = mergeCursorRepoMcpConfigObject(existing, writeOptions);
   return mcpJsonHeader() + JSON.stringify(merged, null, 2) + "\n";
 }
+function buildClaudeCodeMcpJsonBody(existing, writeOptions) {
+  const merged = mergeClaudeCodeMcpConfigObject(existing, writeOptions);
+  return JSON.stringify(merged, null, 2) + "\n";
+}
+async function writeClaudeCodeMcpJson(repoRoot, buildBody, opts) {
+  const abs = getClaudeCodeMcpConfigPath(repoRoot);
+  assertUnderRepoRoot(repoRoot, abs);
+  let raw = "";
+  let existed = false;
+  try {
+    raw = await fs17.readFile(abs, "utf8");
+    existed = true;
+  } catch (err) {
+    if (err?.code !== "ENOENT") throw err;
+  }
+  if (!existed) {
+    const body = buildBody(null);
+    if (opts.dryRun) return "created";
+    await writeSharedMcpJsonAtomic(abs, body);
+    return "created";
+  }
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(stripLeadingLineComments4(raw));
+  } catch {
+    throw new SharedMcpJsonParseError(abs);
+  }
+  if (!parsed2 || typeof parsed2 !== "object" || Array.isArray(parsed2)) {
+    throw new SharedMcpJsonParseError(abs);
+  }
+  const next = buildBody(parsed2);
+  if (next === raw) return "skipped";
+  if (opts.dryRun) return "updated";
+  await writeSharedMcpJsonAtomic(abs, next);
+  return "updated";
+}
 async function writeManagedMarkdown(repoRoot, relPath, fullContent, opts) {
-  const abs = path17.join(repoRoot, relPath);
+  const abs = path21.join(repoRoot, relPath);
   assertUnderRepoRoot(repoRoot, abs);
   let prior = "";
   let existed = false;
   try {
-    prior = await fs13.readFile(abs, "utf8");
+    prior = await fs17.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
   if (!existed) {
     if (opts.dryRun) return "created";
-    await fs13.mkdir(path17.dirname(abs), { recursive: true });
-    await fs13.writeFile(abs, fullContent, "utf8");
+    await fs17.mkdir(path21.dirname(abs), { recursive: true });
+    await fs17.writeFile(abs, fullContent, "utf8");
     return "created";
   }
   if (prior.includes(MANAGED_MARKER)) {
     if (prior === fullContent) return "skipped";
     if (opts.dryRun) return "updated";
-    await fs13.mkdir(path17.dirname(abs), { recursive: true });
-    await fs13.writeFile(abs, fullContent, "utf8");
+    await fs17.mkdir(path21.dirname(abs), { recursive: true });
+    await fs17.writeFile(abs, fullContent, "utf8");
     return "updated";
   }
   if (!opts.force) return "skipped-untracked";
   if (opts.dryRun) return "updated";
-  await fs13.mkdir(path17.dirname(abs), { recursive: true });
-  await fs13.writeFile(abs, fullContent, "utf8");
+  await fs17.mkdir(path21.dirname(abs), { recursive: true });
+  await fs17.writeFile(abs, fullContent, "utf8");
   return "updated";
 }
 async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
-  const abs = path17.join(repoRoot, relPath);
+  const abs = path21.join(repoRoot, relPath);
   assertUnderRepoRoot(repoRoot, abs);
   let raw = "";
   let existed = false;
   try {
-    raw = await fs13.readFile(abs, "utf8");
+    raw = await fs17.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
@@ -4128,7 +5387,7 @@ async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
   if (!managed && !opts.force) return "skipped-untracked";
   let parsed2;
   try {
-    parsed2 = JSON.parse(stripLeadingLineComments3(raw));
+    parsed2 = JSON.parse(stripLeadingLineComments4(raw));
   } catch {
     throw new SharedMcpJsonParseError(abs);
   }
@@ -4145,6 +5404,10 @@ function parseSetupIdeFlags(argv) {
   let cursor = false;
   let vscode = false;
   let jetbrains = false;
+  let claudeCode = false;
+  let windsurf = false;
+  let opencode = false;
+  let codex = false;
   let all = false;
   let force = false;
   let dryRun = false;
@@ -4164,6 +5427,10 @@ function parseSetupIdeFlags(argv) {
     if (a === "--cursor") cursor = true;
     else if (a === "--vscode") vscode = true;
     else if (a === "--jetbrains") jetbrains = true;
+    else if (a === "--claude-code") claudeCode = true;
+    else if (a === "--windsurf") windsurf = true;
+    else if (a === "--opencode") opencode = true;
+    else if (a === "--codex") codex = true;
     else if (a === "--all") all = true;
     else if (a === "--force") force = true;
     else if (a === "--dry-run") dryRun = true;
@@ -4204,12 +5471,20 @@ function parseSetupIdeFlags(argv) {
       }
     } else if (a.startsWith("-")) unknown.push(a);
   }
-  const specific = cursor || vscode || jetbrains;
+  const specific = cursor || vscode || jetbrains || claudeCode || windsurf || opencode || codex;
   let targets;
   if (all || !specific) {
-    targets = { cursor: true, vscode: true, jetbrains: true };
+    targets = {
+      cursor: true,
+      vscode: true,
+      jetbrains: true,
+      claudeCode: true,
+      windsurf: true,
+      opencode: true,
+      codex: true
+    };
   } else {
-    targets = { cursor, vscode, jetbrains };
+    targets = { cursor, vscode, jetbrains, claudeCode, windsurf, opencode, codex };
   }
   if (!flagError && local && staging) {
     flagError = "[setup-ide-files] --local and --staging are mutually exclusive.";
@@ -4253,6 +5528,15 @@ function logSetupIdeFilesVerboseSuccess(opts, println = console.log) {
   if (targets.jetbrains && result.jetbrainsMcp) {
     logJetBrainsMcpCliSummary(result.jetbrainsMcp, dryRun, println);
   }
+  if (targets.windsurf && result.windsurfMcp) {
+    logWindsurfMcpCliSummary(result.windsurfMcp, dryRun, println);
+  }
+  if (targets.opencode && result.opencodeMcp) {
+    logOpenCodeMcpCliSummary(result.opencodeMcp, dryRun, println);
+  }
+  if (targets.codex && result.codexMcp) {
+    logCodexMcpCliSummary(result.codexMcp, dryRun, println);
+  }
   summarizeOutcomes(result.outcomes, println);
   if (dryRun) {
     println("[setup-ide-files] Dry run: no files written.");
@@ -4313,10 +5597,14 @@ function ideTypesFromSetupTargets(targets) {
   if (targets.cursor) ides.push("cursor");
   if (targets.vscode) ides.push("copilot-vscode");
   if (targets.jetbrains) ides.push("jetbrains");
+  if (targets.claudeCode) ides.push("claude-code");
+  if (targets.windsurf) ides.push("windsurf");
+  if (targets.opencode) ides.push("opencode");
+  if (targets.codex) ides.push("codex");
   return ides;
 }
 function setupTargetsAllIdes(targets) {
-  return targets.cursor && targets.vscode && targets.jetbrains;
+  return targets.cursor && targets.vscode && targets.jetbrains && targets.claudeCode && targets.windsurf && targets.opencode && targets.codex;
 }
 function aggregateCleanupResults(results) {
   const killedPids = /* @__PURE__ */ new Set();
@@ -4436,8 +5724,18 @@ function restartIdeInstruction(targets) {
   if (targets.cursor) names.push("Cursor");
   if (targets.vscode) names.push("VS Code");
   if (targets.jetbrains) names.push("JetBrains IDE");
+  if (targets.claudeCode) names.push("Claude Code");
+  if (targets.windsurf) names.push("Devin Desktop");
+  if (targets.opencode) names.push("OpenCode");
+  if (targets.codex) names.push("Codex");
   if (names.length === 0) return "Fully quit your IDE and reopen this repo for MCP changes to take effect.";
   if (names.length === 1) {
+    if (targets.windsurf) {
+      return "Refresh MCP servers in Devin Desktop settings, or restart Devin Desktop, for MCP changes to take effect.";
+    }
+    if (targets.codex) {
+      return "Trust this project in Codex if prompted, then restart Codex.";
+    }
     return `Fully quit ${names[0]} and reopen this repo for MCP changes to take effect.`;
   }
   const last = names.pop();
@@ -4447,7 +5745,10 @@ async function runSetupIdeFiles(o) {
   const outcomes = {};
   let cursorMcp;
   let jetbrainsMcp;
-  const repoRoot = o.workspaceRoot !== void 0 && o.workspaceRoot !== "" ? path17.resolve(o.workspaceRoot) : await findRepoRoot(o.cwd);
+  let windsurfMcp;
+  let opencodeMcp;
+  let codexMcp;
+  const repoRoot = o.workspaceRoot !== void 0 && o.workspaceRoot !== "" ? path21.resolve(o.workspaceRoot) : await findRepoRoot(o.cwd);
   if (!repoRoot) {
     return {
       exitCode: 1,
@@ -4669,12 +5970,203 @@ description: MemoraOne MCP \u2014 IDE agent instructions
       { force: o.force, dryRun: o.dryRun }
     );
     try {
-      const homeDir = o.jetbrainsHomeDir ?? os6.homedir();
+      const homeDir = o.jetbrainsHomeDir ?? os7.homedir();
       const activePath = o.jetbrainsGlobalMcpConfigPath ?? getJetBrainsGlobalMcpConfigPath(homeDir);
       const jetbrainsSetup = await setupJetBrainsMcpConfig({
         homeDir,
         repoRoot,
-        globalConfigPath: activePath,
+        globalConfigPath: activePath,
+        dryRun: o.dryRun,
+        // Local dogfood: --dev / local environment → node + built CLI.
+        // Published staging/production: npx + channel-specific package spec.
+        devMode: localOrDev,
+        environment: localOrDev ? "local" : cursorEnvironment,
+        npmPackageChannel,
+        apiUrl: resolvedApiUrl2,
+        repair: o.repair ?? false,
+        verify: o.verifyHandshake ?? !o.dryRun,
+        npxPathOverride: o.npxPathOverride,
+        cliPathOverride: o.cliPathOverride
+      });
+      jetbrainsMcp = {
+        activeConfigPath: activePath,
+        outcome: jetbrainsSetup.outcome,
+        npxPath: jetbrainsSetup.memoraone?.command,
+        backupPath: jetbrainsSetup.backupPath,
+        repairActions: jetbrainsSetup.repairActions,
+        verifyOk: jetbrainsSetup.verifyOk,
+        verifyDetail: jetbrainsSetup.verifyDetail
+      };
+      outcomes[`jetbrains-global:${activePath}`] = jetbrainsSetup.outcome;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        exitCode: 1,
+        repoRoot,
+        outcomes,
+        cursorMcp,
+        error: message
+      };
+    }
+  }
+  if (o.targets.claudeCode) {
+    let npxPath = null;
+    let cliPath;
+    if (cursorEnvironment === "local") {
+      let resolvedCliPath = o.cursorLocalCliPathOverride;
+      if (resolvedCliPath === void 0) {
+        resolvedCliPath = o.cliPathOverride;
+      }
+      if (resolvedCliPath === void 0) {
+        resolvedCliPath = await resolveBuiltCliPathAsync();
+      }
+      if (!resolvedCliPath) {
+        return {
+          exitCode: 1,
+          repoRoot,
+          outcomes,
+          cursorMcp,
+          jetbrainsMcp,
+          daemonCleanup,
+          error: "[setup-ide-files] Local mode requires a built CLI at packages/mcp/dist/cli.cjs. Run pnpm build first."
+        };
+      }
+      cliPath = resolvedCliPath;
+    } else {
+      if (o.npxPathOverride !== void 0) {
+        npxPath = o.npxPathOverride;
+      } else {
+        npxPath = await resolveNpxPath();
+      }
+      if (!npxPath) {
+        return {
+          exitCode: 1,
+          repoRoot,
+          outcomes,
+          cursorMcp,
+          jetbrainsMcp,
+          daemonCleanup,
+          error: "[setup-ide-files] Could not resolve a working npx executable. Install Node.js/npm or ensure npx is on PATH before configuring Claude Code MCP."
+        };
+      }
+    }
+    const claudeWriteOptions = {
+      environment: cursorEnvironment,
+      npxPath: npxPath ?? void 0,
+      cliPath,
+      repoRoot,
+      apiUrl: resolvedApiUrl2,
+      npmPackageChannel
+    };
+    try {
+      outcomes[".mcp.json"] = await writeClaudeCodeMcpJson(
+        repoRoot,
+        (existing) => buildClaudeCodeMcpJsonBody(existing, claudeWriteOptions),
+        { dryRun: o.dryRun }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        exitCode: 1,
+        repoRoot,
+        outcomes,
+        cursorMcp,
+        jetbrainsMcp,
+        windsurfMcp,
+        daemonCleanup,
+        error: message
+      };
+    }
+  }
+  if (o.targets.windsurf) {
+    try {
+      const homeDir = o.windsurfHomeDir ?? os7.homedir();
+      const activePath = o.windsurfGlobalMcpConfigPath ?? getWindsurfGlobalMcpConfigPath(homeDir);
+      const legacyPath = o.windsurfLegacyMcpConfigPath ?? getWindsurfLegacyMcpConfigPath(homeDir);
+      const windsurfSetup = await setupWindsurfMcpConfig({
+        homeDir,
+        repoRoot,
+        globalConfigPath: activePath,
+        legacyConfigPath: legacyPath,
+        dryRun: o.dryRun,
+        // Local dogfood: --dev / local environment → node + built CLI.
+        // Published staging/production: npx + channel-specific package spec.
+        devMode: localOrDev,
+        environment: localOrDev ? "local" : cursorEnvironment,
+        npmPackageChannel,
+        apiUrl: resolvedApiUrl2,
+        npxPathOverride: o.npxPathOverride,
+        cliPathOverride: o.cliPathOverride ?? o.cursorLocalCliPathOverride
+      });
+      windsurfMcp = {
+        activeConfigPath: windsurfSetup.activeConfigPath,
+        outcome: windsurfSetup.outcome,
+        npxPath: windsurfSetup.memoraone?.command,
+        backupPath: windsurfSetup.backupPath,
+        legacyConfigPath: windsurfSetup.legacyConfigPath,
+        legacyCleanup: windsurfSetup.legacyCleanup,
+        warning: windsurfSetup.warning
+      };
+      outcomes[`windsurf-global:${activePath}`] = windsurfSetup.outcome;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        exitCode: 1,
+        repoRoot,
+        outcomes,
+        cursorMcp,
+        jetbrainsMcp,
+        windsurfMcp,
+        opencodeMcp,
+        daemonCleanup,
+        error: message
+      };
+    }
+  }
+  if (o.targets.opencode) {
+    try {
+      const activePath = o.opencodeProjectMcpConfigPath ?? getOpenCodeProjectMcpConfigPath(repoRoot);
+      const opencodeSetup = await setupOpenCodeMcpConfig({
+        repoRoot,
+        projectConfigPath: activePath,
+        dryRun: o.dryRun,
+        // Local dogfood: --dev / local environment → node + built CLI.
+        // Published staging/production: npx + channel-specific package spec.
+        devMode: localOrDev,
+        environment: localOrDev ? "local" : cursorEnvironment,
+        npmPackageChannel,
+        apiUrl: resolvedApiUrl2,
+        npxPathOverride: o.npxPathOverride,
+        cliPathOverride: o.cliPathOverride ?? o.cursorLocalCliPathOverride
+      });
+      opencodeMcp = {
+        activeConfigPath: activePath,
+        outcome: opencodeSetup.outcome,
+        npxPath: opencodeSetup.memoraone?.command[0]
+      };
+      outcomes["opencode.json"] = opencodeSetup.outcome;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        exitCode: 1,
+        repoRoot,
+        outcomes,
+        cursorMcp,
+        jetbrainsMcp,
+        windsurfMcp,
+        opencodeMcp,
+        codexMcp,
+        daemonCleanup,
+        error: message
+      };
+    }
+  }
+  if (o.targets.codex) {
+    try {
+      const activePath = o.codexProjectMcpConfigPath ?? getCodexProjectMcpConfigPath(repoRoot);
+      const codexSetup = await setupCodexMcpConfig({
+        repoRoot,
+        projectConfigPath: activePath,
         dryRun: o.dryRun,
         // Local dogfood: --dev / local environment → node + built CLI.
         // Published staging/production: npx + channel-specific package spec.
@@ -4682,21 +6174,15 @@ description: MemoraOne MCP \u2014 IDE agent instructions
         environment: localOrDev ? "local" : cursorEnvironment,
         npmPackageChannel,
         apiUrl: resolvedApiUrl2,
-        repair: o.repair ?? false,
-        verify: o.verifyHandshake ?? !o.dryRun,
         npxPathOverride: o.npxPathOverride,
-        cliPathOverride: o.cliPathOverride
+        cliPathOverride: o.cliPathOverride ?? o.cursorLocalCliPathOverride
       });
-      jetbrainsMcp = {
+      codexMcp = {
         activeConfigPath: activePath,
-        outcome: jetbrainsSetup.outcome,
-        npxPath: jetbrainsSetup.memoraone?.command,
-        backupPath: jetbrainsSetup.backupPath,
-        repairActions: jetbrainsSetup.repairActions,
-        verifyOk: jetbrainsSetup.verifyOk,
-        verifyDetail: jetbrainsSetup.verifyDetail
+        outcome: codexSetup.outcome,
+        npxPath: codexSetup.memoraone?.command
       };
-      outcomes[`jetbrains-global:${activePath}`] = jetbrainsSetup.outcome;
+      outcomes[".codex/config.toml"] = codexSetup.outcome;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       return {
@@ -4704,11 +6190,26 @@ description: MemoraOne MCP \u2014 IDE agent instructions
         repoRoot,
         outcomes,
         cursorMcp,
+        jetbrainsMcp,
+        windsurfMcp,
+        opencodeMcp,
+        codexMcp,
+        daemonCleanup,
         error: message
       };
     }
   }
-  return { exitCode: 0, repoRoot, outcomes, cursorMcp, jetbrainsMcp, daemonCleanup };
+  return {
+    exitCode: 0,
+    repoRoot,
+    outcomes,
+    cursorMcp,
+    jetbrainsMcp,
+    windsurfMcp,
+    opencodeMcp,
+    codexMcp,
+    daemonCleanup
+  };
 }
 async function cliSetupIdeFiles(argv, options = {}) {
   const {
@@ -4818,85 +6319,13 @@ async function cliSetupIdeFiles(argv, options = {}) {
 }
 
 // src/localState/connectCommand.ts
-var path20 = __toESM(require("path"), 1);
-var os7 = __toESM(require("os"), 1);
-
-// src/config.ts
-var process2 = __toESM(require("process"), 1);
-var fs14 = __toESM(require("fs"), 1);
-var path18 = __toESM(require("path"), 1);
-var dotenv = __toESM(require("dotenv"), 1);
-var import_v4 = require("zod/v4");
-var dotenvPath = path18.resolve(process2.cwd(), ".env");
-if (fs14.existsSync(dotenvPath)) {
-  try {
-    dotenv.config({ path: dotenvPath });
-  } catch (err) {
-    process2.stderr.write("[memoraone-mcp] Failed to load .env: " + String(err) + "\n");
-  }
-}
-var EnvSchema = import_v4.z.object({
-  MEMORAONE_API_URL: import_v4.z.string().url().optional(),
-  MEMORAONE_API_KEY: import_v4.z.string().min(1).optional(),
-  MEMORAONE_DEV_MODE: import_v4.z.string().min(1).optional(),
-  MEMORAONE_AGENT_NAME: import_v4.z.string().min(1).optional(),
-  MEMORAONE_AGENT_TYPE: import_v4.z.string().min(1).optional(),
-  MEMORAONE_SOURCE: import_v4.z.string().min(1).optional(),
-  MEMORAONE_IDE_TYPE: import_v4.z.enum(["cursor", "copilot-vscode", "jetbrains"]).optional(),
-  MEMORAONE_WORKLOG: import_v4.z.string().min(1).optional(),
-  MEMORAONE_HEARTBEAT: import_v4.z.string().min(1).optional(),
-  MEMORAONE_HEARTBEAT_INTERVAL_MS: import_v4.z.string().min(1).optional()
-});
-var requiredEnvVars = [];
-var missingEnvVars = requiredEnvVars.filter((key) => {
-  const value = process2.env[key];
-  return value === void 0 || value.trim() === "";
-});
-if (missingEnvVars.length > 0) {
-  for (const key of missingEnvVars) {
-    process2.stderr.write(`Missing ${key}
-`);
-  }
-  process2.exit(1);
-}
-var parsed = EnvSchema.safeParse(process2.env);
-var resolvedApiUrl = resolveApiUrl(process2.env);
-if (!parsed.success) {
-  const formatted = parsed.error.format();
-  process2.stderr.write(
-    "[memoraone-mcp] Invalid environment variables " + JSON.stringify(formatted) + "\n"
-  );
-  throw new Error("Config validation failed");
-}
-var parseBooleanFlag2 = (value, defaultValue) => {
-  if (value === void 0) {
-    return defaultValue;
-  }
-  const normalized = value.trim().toLowerCase();
-  if (["1", "true", "yes", "on"].includes(normalized)) {
-    return true;
-  }
-  if (["0", "false", "no", "off"].includes(normalized)) {
-    return false;
-  }
-  return defaultValue;
-};
-var config2 = {
-  apiUrl: resolvedApiUrl.replace(/\/+$/, ""),
-  apiKey: parsed.data.MEMORAONE_API_KEY,
-  agentName: parsed.data.MEMORAONE_AGENT_NAME ?? "cursor",
-  agentType: parsed.data.MEMORAONE_AGENT_TYPE ?? "agent",
-  source: parsed.data.MEMORAONE_SOURCE ?? "cursor",
-  ideType: parsed.data.MEMORAONE_IDE_TYPE,
-  devMode: parseBooleanFlag2(parsed.data.MEMORAONE_DEV_MODE, false),
-  worklogEnabled: parseBooleanFlag2(parsed.data.MEMORAONE_WORKLOG, true),
-  heartbeatEnabled: parseBooleanFlag2(parsed.data.MEMORAONE_HEARTBEAT, true),
-  heartbeatIntervalMs: Number.parseInt(parsed.data.MEMORAONE_HEARTBEAT_INTERVAL_MS ?? "30000", 10)
-};
+var fs20 = __toESM(require("fs/promises"), 1);
+var path24 = __toESM(require("path"), 1);
+var os8 = __toESM(require("os"), 1);
 
 // src/repoFingerprint.ts
-var fs15 = __toESM(require("fs"), 1);
-var path19 = __toESM(require("path"), 1);
+var fs18 = __toESM(require("fs"), 1);
+var path22 = __toESM(require("path"), 1);
 var crypto2 = __toESM(require("crypto"), 1);
 var parseBooleanFlag3 = (value) => {
   if (!value) {
@@ -4926,16 +6355,16 @@ var sha256 = (value) => {
 };
 var resolveGitDir = (gitPath) => {
   try {
-    const stat4 = fs15.statSync(gitPath);
+    const stat4 = fs18.statSync(gitPath);
     if (stat4.isDirectory()) {
       return gitPath;
     }
     if (stat4.isFile()) {
-      const content = fs15.readFileSync(gitPath, "utf8");
+      const content = fs18.readFileSync(gitPath, "utf8");
       const match = content.match(/^gitdir:\s*(.+)$/m);
       if (match) {
         const gitDir = match[1].trim();
-        return path19.resolve(path19.dirname(gitPath), gitDir);
+        return path22.resolve(path22.dirname(gitPath), gitDir);
       }
     }
   } catch {
@@ -4944,16 +6373,16 @@ var resolveGitDir = (gitPath) => {
   return null;
 };
 var findGitRoot = (start) => {
-  let current = path19.resolve(start);
+  let current = path22.resolve(start);
   while (true) {
-    const gitPath = path19.join(current, ".git");
-    if (fs15.existsSync(gitPath)) {
+    const gitPath = path22.join(current, ".git");
+    if (fs18.existsSync(gitPath)) {
       const gitDir = resolveGitDir(gitPath);
       if (gitDir) {
         return { gitRoot: current, gitDir };
       }
     }
-    const parent = path19.dirname(current);
+    const parent = path22.dirname(current);
     if (parent === current) {
       break;
     }
@@ -4962,9 +6391,9 @@ var findGitRoot = (start) => {
   return null;
 };
 var readOriginRemote = (gitDir) => {
-  const configPath = path19.join(gitDir, "config");
+  const configPath = path22.join(gitDir, "config");
   try {
-    const content = fs15.readFileSync(configPath, "utf8");
+    const content = fs18.readFileSync(configPath, "utf8");
     const lines = content.split(/\r?\n/);
     let inOrigin = false;
     for (const line of lines) {
@@ -4988,7 +6417,7 @@ var readOriginRemote = (gitDir) => {
 function resolveRepoFingerprint(cwd2) {
   const found = findGitRoot(cwd2);
   if (!found) {
-    const fallbackPath = path19.resolve(cwd2);
+    const fallbackPath = path22.resolve(cwd2);
     const fingerprint2 = sha256(fallbackPath);
     debugLog(`repo fingerprint=${fingerprint2} source=path-fallback`);
     return {
@@ -5010,7 +6439,7 @@ function resolveRepoFingerprint(cwd2) {
       source: "git-remote"
     };
   }
-  const fingerprint = sha256(path19.resolve(gitRoot));
+  const fingerprint = sha256(path22.resolve(gitRoot));
   debugLog(`repo fingerprint=${fingerprint} source=path-fallback`);
   return {
     fingerprint,
@@ -5019,6 +6448,188 @@ function resolveRepoFingerprint(cwd2) {
   };
 }
 
+// src/localState/replaceRootLocalState.ts
+var fs19 = __toESM(require("fs/promises"), 1);
+var path23 = __toESM(require("path"), 1);
+var WORKSPACE_MAP_FILENAME = "workspaces.json";
+var FINGERPRINT_REGEX = /^[0-9a-f]{64}$/i;
+function canonicalizeWorkspaceRoot(workspaceRoot) {
+  return path23.resolve(workspaceRoot);
+}
+function getWorkspaceMapPathForHome(homeDir) {
+  return path23.join(getMemoraoneStateDir(homeDir), WORKSPACE_MAP_FILENAME);
+}
+async function loadWorkspaceMapFile(homeDir) {
+  const filePath = getWorkspaceMapPathForHome(homeDir);
+  const raw = await readJsonFile(filePath);
+  if (raw == null) return {};
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`[memoraone-mcp] Corrupt ${WORKSPACE_MAP_FILENAME}`);
+  }
+  return { ...raw };
+}
+async function saveWorkspaceMapFile(map, homeDir) {
+  await writeJsonAtomic(getWorkspaceMapPathForHome(homeDir), map);
+}
+function rootsMatch(a, b) {
+  return path23.resolve(a) === path23.resolve(b);
+}
+async function collectRootAssociatedBindingIds(workspaceRoot, options = {}) {
+  const canonicalRoot = canonicalizeWorkspaceRoot(workspaceRoot);
+  const identity = await captureRootFilesystemIdentity(canonicalRoot, options.identityDeps);
+  const identityKey = filesystemIdentityKey(identity);
+  const bindingIds = /* @__PURE__ */ new Set();
+  const index = await loadPathIndex(options.homeDir);
+  const byPathId = index.byPath[canonicalRoot];
+  if (byPathId) bindingIds.add(byPathId);
+  const byIdentityId = index.byIdentity[identityKey];
+  if (byIdentityId) bindingIds.add(byIdentityId);
+  for (const [p, id] of Object.entries(index.byPath)) {
+    if (rootsMatch(p, canonicalRoot)) {
+      bindingIds.add(id);
+    }
+  }
+  const records = await listBindingRecords(options.homeDir);
+  for (const record of records) {
+    if (rootsMatch(record.workspaceRoot, canonicalRoot)) {
+      bindingIds.add(record.repositoryBindingId);
+      continue;
+    }
+    if (identitiesMatch(record.filesystemIdentity, identity)) {
+      bindingIds.add(record.repositoryBindingId);
+    }
+  }
+  return { canonicalRoot, identity, bindingIds };
+}
+async function snapshotAndRemoveRootLocalState(workspaceRoot, options = {}) {
+  const { canonicalRoot, identity, bindingIds } = await collectRootAssociatedBindingIds(
+    workspaceRoot,
+    options
+  );
+  const identityKey = filesystemIdentityKey(identity);
+  const bindingRecords = [];
+  const credentials = [];
+  for (const id of bindingIds) {
+    const record = await readBindingRecord(id, options.homeDir);
+    if (record) bindingRecords.push(record);
+    try {
+      const creds = await readInstallationCredentials(id, options.credentialOptions);
+      if (creds) credentials.push(creds);
+    } catch {
+    }
+  }
+  const fingerprints = /* @__PURE__ */ new Set();
+  for (const fp of options.extraFingerprints ?? []) {
+    if (FINGERPRINT_REGEX.test(fp)) fingerprints.add(fp.toLowerCase());
+  }
+  for (const record of bindingRecords) {
+    if (FINGERPRINT_REGEX.test(record.rootFingerprint)) {
+      fingerprints.add(record.rootFingerprint.toLowerCase());
+    }
+  }
+  const removedPathEntries = {};
+  const removedIdentityEntries = {};
+  await withLocalLock(
+    "path-index",
+    async () => {
+      const index = await loadPathIndex(options.homeDir);
+      for (const [p, id] of Object.entries(index.byPath)) {
+        if (bindingIds.has(id) || rootsMatch(p, canonicalRoot)) {
+          removedPathEntries[p] = id;
+          delete index.byPath[p];
+        }
+      }
+      for (const [key, id] of Object.entries(index.byIdentity)) {
+        if (bindingIds.has(id) || key === identityKey) {
+          removedIdentityEntries[key] = id;
+          delete index.byIdentity[key];
+        }
+      }
+      await savePathIndex(index, options.homeDir);
+    },
+    { homeDir: options.homeDir }
+  );
+  const removedWorkspaceMapEntries = {};
+  if (fingerprints.size > 0) {
+    const map = await loadWorkspaceMapFile(options.homeDir);
+    let changed = false;
+    for (const fp of fingerprints) {
+      const key = Object.keys(map).find((k) => k.toLowerCase() === fp) ?? fp;
+      if (key in map) {
+        removedWorkspaceMapEntries[key] = map[key];
+        delete map[key];
+        changed = true;
+      }
+    }
+    if (changed) {
+      await saveWorkspaceMapFile(map, options.homeDir);
+    }
+  }
+  for (const id of bindingIds) {
+    try {
+      await deleteInstallationCredentials(id, options.credentialOptions);
+    } catch {
+    }
+    try {
+      await fs19.unlink(getBindingFilePath(id, options.homeDir));
+    } catch (err) {
+      if (err?.code !== "ENOENT") throw err;
+    }
+  }
+  return {
+    canonicalRoot,
+    identity,
+    bindingIds: [...bindingIds],
+    bindingRecords,
+    removedPathEntries,
+    removedIdentityEntries,
+    removedWorkspaceMapEntries,
+    credentials
+  };
+}
+async function restoreRootLocalState(snapshot, options = {}) {
+  for (const id of options.discardBindingIds ?? []) {
+    try {
+      await deleteInstallationCredentials(id, options.credentialOptions);
+    } catch {
+    }
+    try {
+      await fs19.unlink(getBindingFilePath(id, options.homeDir));
+    } catch (err) {
+      if (err?.code !== "ENOENT") throw err;
+    }
+  }
+  for (const record of snapshot.bindingRecords) {
+    await writeBindingRecord(record, options.homeDir);
+  }
+  await withLocalLock(
+    "path-index",
+    async () => {
+      const index = await loadPathIndex(options.homeDir);
+      for (const id of options.discardBindingIds ?? []) {
+        for (const [p, mappedId] of Object.entries(index.byPath)) {
+          if (mappedId === id) delete index.byPath[p];
+        }
+        for (const [key, mappedId] of Object.entries(index.byIdentity)) {
+          if (mappedId === id) delete index.byIdentity[key];
+        }
+      }
+      Object.assign(index.byPath, snapshot.removedPathEntries);
+      Object.assign(index.byIdentity, snapshot.removedIdentityEntries);
+      await savePathIndex(index, options.homeDir);
+    },
+    { homeDir: options.homeDir }
+  );
+  if (Object.keys(snapshot.removedWorkspaceMapEntries).length > 0) {
+    const map = await loadWorkspaceMapFile(options.homeDir);
+    Object.assign(map, snapshot.removedWorkspaceMapEntries);
+    await saveWorkspaceMapFile(map, options.homeDir);
+  }
+  for (const creds of snapshot.credentials) {
+    await writeInstallationCredentials(creds, options.credentialOptions);
+  }
+}
+
 // src/localState/connectCommand.ts
 function normalizeConnectCode(code) {
   const trimmed = code.trim();
@@ -5036,12 +6647,29 @@ function normalizeGitRemote(remoteUrl) {
   normalized = normalized.replace(/\/+$/, "");
   return normalized.toLowerCase() || null;
 }
+async function detectLegacyM1Warning2(workspaceRoot) {
+  const candidate = path24.join(path24.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
+  try {
+    await fs20.access(candidate);
+    return candidate;
+  } catch {
+    return void 0;
+  }
+}
+async function rollbackFailedConnect(options) {
+  await restoreRootLocalState(options.snapshot, {
+    homeDir: options.homeDir,
+    credentialOptions: options.credentialOptions,
+    discardBindingIds: [options.discardBindingId]
+  });
+}
 async function runConnectCommand(options) {
   const code = normalizeConnectCode(options.code);
-  const cwd2 = path20.resolve(options.cwd ?? process.cwd());
+  const cwd2 = path24.resolve(options.cwd ?? process.cwd());
   const apiUrl = (options.apiUrl ?? config2.apiUrl).replace(/\/+$/, "");
-  const homeDir = options.homeDir ?? os7.homedir();
+  const homeDir = options.homeDir ?? os8.homedir();
   const environment = "local";
+  const verifyLocalBinding = options.verifyLocalBinding ?? resolveLocalBinding;
   const executionMode = await resolvePackageExecutionMode({
     executionMode: options.executionMode,
     // Only honor an explicit caller cliPath; never auto-resolve before mode detection
@@ -5062,157 +6690,222 @@ async function runConnectCommand(options) {
     }
     resolvedMode = { kind: "local", cliPath };
   }
-  const ensured = await ensureRepositoryBindingForRoot(cwd2, {
-    homeDir,
-    identityDeps: options.identityDeps,
-    createIfMissing: true
-  });
-  if (ensured.legacyM1WarningPath) {
+  const fingerprint = resolveRepoFingerprint(cwd2);
+  const legacyM1WarningPath = await detectLegacyM1Warning2(cwd2);
+  if (legacyM1WarningPath) {
     process.stderr.write(
-      `[memoraone-mcp] warning: ignoring legacy ${path20.basename(ensured.legacyM1WarningPath)} at ${ensured.legacyM1WarningPath} (credentials and binding are package-managed)
+      `[memoraone-mcp] warning: ignoring legacy ${path24.basename(legacyM1WarningPath)} at ${legacyM1WarningPath} (credentials and binding are package-managed)
 `
     );
   }
-  const fingerprint = resolveRepoFingerprint(cwd2);
-  const displayName = cwd2;
-  const normalizedGitRemote = normalizeGitRemote(fingerprint.remoteUrl);
-  const { clientRedeemKey } = await ensureClientRedeemKey(
-    ensured.repositoryBindingId,
-    options.credentialOptions
-  );
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const pendingRecord = {
-    v: 1,
-    repositoryBindingId: ensured.repositoryBindingId,
-    workspaceRoot: cwd2,
-    filesystemIdentity: ensured.identity,
-    rootFingerprint: fingerprint.fingerprint,
-    displayName,
-    environment,
-    apiUrl,
-    normalizedGitRemote,
-    status: "pending",
-    createdAt: now,
-    updatedAt: now,
-    packageVersion: options.packageVersion ?? null,
-    ideType: options.ideType ?? null
-  };
-  await writeBindingRecord(pendingRecord, homeDir);
-  await upsertPathIndexEntry({
-    repositoryBindingId: ensured.repositoryBindingId,
-    workspaceRoot: cwd2,
-    identity: ensured.identity,
+  const snapshot = await snapshotAndRemoveRootLocalState(cwd2, {
     homeDir,
-    previousPath: ensured.renamedFrom
+    identityDeps: options.identityDeps,
+    credentialOptions: options.credentialOptions,
+    extraFingerprints: [fingerprint.fingerprint]
   });
-  const redeemed = await redeemLocalConnectCode(
-    apiUrl,
-    {
-      code,
-      client_redeem_key: clientRedeemKey,
-      repository_binding_id: ensured.repositoryBindingId,
-      root_fingerprint: fingerprint.fingerprint,
-      display_name: displayName,
+  const identity = await captureRootFilesystemIdentity(cwd2, options.identityDeps);
+  const repositoryBindingId = generateRepositoryBindingId();
+  const createdBinding = true;
+  const displayName = cwd2;
+  const normalizedGitRemote = normalizeGitRemote(fingerprint.remoteUrl);
+  try {
+    const { clientRedeemKey } = await ensureClientRedeemKey(
+      repositoryBindingId,
+      options.credentialOptions
+    );
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const pendingRecord = {
+      v: 1,
+      repositoryBindingId,
+      workspaceRoot: cwd2,
+      filesystemIdentity: identity,
+      rootFingerprint: fingerprint.fingerprint,
+      displayName,
       environment,
-      normalized_git_remote: normalizedGitRemote,
-      platform: ensured.identity.platform,
-      package_version: options.packageVersion ?? null,
-      ide_type: options.ideType ?? null
-    },
-    { fetchImpl: options.fetchImpl }
-  );
-  await updateInstallationCredentials(
-    ensured.repositoryBindingId,
-    {
-      accessToken: redeemed.access_token,
-      refreshToken: redeemed.refresh_token,
-      accessTokenExpiresAt: redeemed.access_token_expires_at ?? void 0,
-      refreshTokenExpiresAt: redeemed.refresh_token_expires_at ?? void 0,
+      apiUrl,
+      normalizedGitRemote,
+      status: "pending",
+      createdAt: now,
+      updatedAt: now,
+      packageVersion: options.packageVersion ?? null,
+      ideType: options.ideType ?? null
+    };
+    await writeBindingRecord(pendingRecord, homeDir);
+    await upsertPathIndexEntry({
+      repositoryBindingId,
+      workspaceRoot: cwd2,
+      identity,
+      homeDir
+    });
+    const redeemed = await redeemLocalConnectCode(
+      apiUrl,
+      {
+        code,
+        client_redeem_key: clientRedeemKey,
+        repository_binding_id: repositoryBindingId,
+        root_fingerprint: fingerprint.fingerprint,
+        display_name: displayName,
+        environment,
+        normalized_git_remote: normalizedGitRemote,
+        platform: identity.platform,
+        package_version: options.packageVersion ?? null,
+        ide_type: options.ideType ?? null
+      },
+      { fetchImpl: options.fetchImpl }
+    );
+    await updateInstallationCredentials(
+      repositoryBindingId,
+      {
+        accessToken: redeemed.access_token,
+        refreshToken: redeemed.refresh_token,
+        accessTokenExpiresAt: redeemed.access_token_expires_at ?? void 0,
+        refreshTokenExpiresAt: redeemed.refresh_token_expires_at ?? void 0,
+        installationPublicId: redeemed.installation_public_id,
+        projectId: redeemed.project_id
+      },
+      { ...options.credentialOptions, clearKeys: ["clientRedeemKey"] }
+    );
+    const connectedRecord = {
+      ...pendingRecord,
       installationPublicId: redeemed.installation_public_id,
-      projectId: redeemed.project_id
-    },
-    { ...options.credentialOptions, clearKeys: ["clientRedeemKey"] }
-  );
-  const connectedRecord = {
-    ...pendingRecord,
-    installationPublicId: redeemed.installation_public_id,
-    projectId: redeemed.project_id,
-    status: "connected",
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  await writeBindingRecord(connectedRecord, homeDir);
-  const baseSuccess = `Connected repository binding ${ensured.repositoryBindingId}` + (redeemed.recovered ? " (recovered)" : "") + ` to project ${redeemed.project_id}.`;
-  if (options.configureIdes !== false) {
-    const targets = { cursor: true, vscode: true, jetbrains: true };
-    const setup = options.setupIdeFiles ?? runSetupIdeFiles;
-    const modeSetup = setupOptionsFromPackageExecutionMode(resolvedMode);
-    let setupResult;
+      projectId: redeemed.project_id,
+      status: "connected",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeBindingRecord(connectedRecord, homeDir);
+    let verified;
     try {
-      setupResult = await setup({
-        cwd: cwd2,
-        // Use the exact bound workspace root — do not rediscover via .git / .m1.
-        workspaceRoot: cwd2,
-        targets,
-        force: true,
-        dryRun: false,
-        noGitignore: true,
-        skipDaemonCleanup: true,
+      verified = await verifyLocalBinding(cwd2, {
         homeDir,
-        // Propagate the redeemed binding API URL (backend only — not execution mode).
-        apiUrl,
-        ...modeSetup,
-        ...options.setupIdeOptions
+        identityDeps: options.identityDeps,
+        credentialOptions: options.credentialOptions
       });
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      setupResult = {
+      const detail = err instanceof Error ? err.message : String(err);
+      await rollbackFailedConnect({
+        snapshot,
+        discardBindingId: repositoryBindingId,
+        homeDir,
+        credentialOptions: options.credentialOptions
+      });
+      return {
         exitCode: 1,
-        repoRoot: cwd2,
-        outcomes: {},
-        error: message
+        repositoryBindingId,
+        createdBinding,
+        legacyM1WarningPath,
+        executionMode: resolvedMode,
+        verificationError: detail,
+        message: `Connect wrote binding ${repositoryBindingId} but runtime binding lookup failed for ${cwd2}: ${detail}. Previous root-specific local state was restored. IDE contracts were not updated. Check ~/.memoraone/path-index.json and ~/.memoraone/bindings/.`
       };
     }
-    if (setupResult.exitCode !== 0) {
-      const detail = setupResult.error ?? "unknown IDE setup error";
-      const repair = formatIdeSetupRepairHint(cwd2, resolvedMode);
+    if (verified.repositoryBindingId !== repositoryBindingId) {
+      const detail = `expected repository_binding_id ${repositoryBindingId}, lookup returned ${verified.repositoryBindingId}`;
+      await rollbackFailedConnect({
+        snapshot,
+        discardBindingId: repositoryBindingId,
+        homeDir,
+        credentialOptions: options.credentialOptions
+      });
       return {
         exitCode: 1,
-        repositoryBindingId: ensured.repositoryBindingId,
+        repositoryBindingId,
+        createdBinding,
+        legacyM1WarningPath,
+        executionMode: resolvedMode,
+        verificationError: detail,
+        message: `Connect verification failed for ${cwd2}: ${detail}. Previous root-specific local state was restored. IDE contracts were not updated.`
+      };
+    }
+    const baseSuccess = `Connected repository binding ${repositoryBindingId}` + (redeemed.recovered ? " (recovered)" : "") + ` to project ${redeemed.project_id}.`;
+    if (options.configureIdes !== false) {
+      const targets = {
+        cursor: true,
+        vscode: true,
+        jetbrains: true,
+        claudeCode: true,
+        windsurf: true,
+        opencode: true,
+        codex: true
+      };
+      const setup = options.setupIdeFiles ?? runSetupIdeFiles;
+      const modeSetup = setupOptionsFromPackageExecutionMode(resolvedMode);
+      let setupResult;
+      try {
+        setupResult = await setup({
+          cwd: cwd2,
+          // Use the exact bound workspace root — do not rediscover via .git / .m1.
+          workspaceRoot: cwd2,
+          targets,
+          force: true,
+          dryRun: false,
+          noGitignore: true,
+          skipDaemonCleanup: true,
+          homeDir,
+          // Propagate the redeemed binding API URL (backend only — not execution mode).
+          apiUrl,
+          ...modeSetup,
+          ...options.setupIdeOptions
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        setupResult = {
+          exitCode: 1,
+          repoRoot: cwd2,
+          outcomes: {},
+          error: message
+        };
+      }
+      if (setupResult.exitCode !== 0) {
+        const detail = setupResult.error ?? "unknown IDE setup error";
+        const repair = formatIdeSetupRepairHint(cwd2, resolvedMode);
+        return {
+          exitCode: 1,
+          repositoryBindingId,
+          projectId: redeemed.project_id,
+          installationPublicId: redeemed.installation_public_id,
+          recovered: redeemed.recovered,
+          createdBinding,
+          legacyM1WarningPath,
+          ideSetupError: detail,
+          executionMode: resolvedMode,
+          message: `Repository connection exists for binding ${repositoryBindingId} (project ${redeemed.project_id}), but IDE configuration failed: ${detail}. Credentials and binding were kept. ${repair}`
+        };
+      }
+      return {
+        exitCode: 0,
+        repositoryBindingId,
         projectId: redeemed.project_id,
         installationPublicId: redeemed.installation_public_id,
         recovered: redeemed.recovered,
-        createdBinding: ensured.created,
-        legacyM1WarningPath: ensured.legacyM1WarningPath,
-        ideSetupError: detail,
+        createdBinding,
+        legacyM1WarningPath,
         executionMode: resolvedMode,
-        message: `Repository connection exists for binding ${ensured.repositoryBindingId} (project ${redeemed.project_id}), but IDE configuration failed: ${detail}. Credentials and binding were kept. ${repair}`
+        configuredTargets: targets,
+        setupResult,
+        message: baseSuccess
       };
     }
     return {
       exitCode: 0,
-      repositoryBindingId: ensured.repositoryBindingId,
+      repositoryBindingId,
       projectId: redeemed.project_id,
       installationPublicId: redeemed.installation_public_id,
       recovered: redeemed.recovered,
-      createdBinding: ensured.created,
-      legacyM1WarningPath: ensured.legacyM1WarningPath,
+      createdBinding,
+      legacyM1WarningPath,
       executionMode: resolvedMode,
-      configuredTargets: targets,
-      setupResult,
       message: baseSuccess
     };
+  } catch (err) {
+    await rollbackFailedConnect({
+      snapshot,
+      discardBindingId: repositoryBindingId,
+      homeDir,
+      credentialOptions: options.credentialOptions
+    });
+    throw err;
   }
-  return {
-    exitCode: 0,
-    repositoryBindingId: ensured.repositoryBindingId,
-    projectId: redeemed.project_id,
-    installationPublicId: redeemed.installation_public_id,
-    recovered: redeemed.recovered,
-    createdBinding: ensured.created,
-    legacyM1WarningPath: ensured.legacyM1WarningPath,
-    executionMode: resolvedMode,
-    message: baseSuccess
-  };
 }
 function parseConnectArgv(argv) {
   let code;
@@ -5336,7 +7029,7 @@ if (args.includes("--version") || args.includes("-v")) {
 }
 if (args.includes("--help") || args.includes("-h")) {
   console.log(
-    "Usage: memoraone-mcp [--version] [--help]\n       memoraone-mcp connect <code> [--api-url <url>] [--verbose]\n       memoraone-mcp [--daemon --binding-id <mrb_\u2026> [--ide cursor|copilot-vscode|jetbrains]]\n       memoraone-mcp setup-ide-files [--all|--cursor|--vscode|--jetbrains] [--force] [--dry-run] [--no-gitignore] [--cleanup] [--dev] [--repair] [--workspace-root <path>] [--api-url <url>] [--verbose]\n         Cursor API environment (with --cursor or --all): --local (node + built cli.cjs + local API) | --staging (npx + staging API)\n         --workspace-root: configure an explicit bound workspace (skips .git discovery; for fileless Local MCP repair)\n         --api-url: developer-only local/dev API endpoint (defaults from binding or http://localhost:3001; never Studio :3000)\n         --verbose: show developer diagnostics (paths, backups, daemon cleanup, handshake)\n       memoraone-mcp cleanup [--project-id <uuid>] [--ide cursor|copilot-vscode|jetbrains] [--dry-run] [--all-projects] [--yes]"
+    "Usage: memoraone-mcp [--version] [--help]\n       memoraone-mcp connect <code> [--api-url <url>] [--verbose]\n       memoraone-mcp [--daemon --binding-id <mrb_\u2026> [--ide cursor|copilot-vscode|jetbrains|claude-code|windsurf|opencode|codex]]\n       memoraone-mcp setup-ide-files [--all|--cursor|--vscode|--jetbrains|--claude-code|--windsurf|--opencode|--codex] [--force] [--dry-run] [--no-gitignore] [--cleanup] [--dev] [--repair] [--workspace-root <path>] [--api-url <url>] [--verbose]\n         Cursor API environment (with --cursor or --all): --local (node + built cli.cjs + local API) | --staging (npx + staging API)\n         --workspace-root: configure an explicit bound workspace (skips .git discovery; for fileless Local MCP repair)\n         --api-url: developer-only local/dev API endpoint (defaults from binding or http://localhost:3001; never Studio :3000)\n         --verbose: show developer diagnostics (paths, backups, daemon cleanup, handshake)\n       memoraone-mcp cleanup [--project-id <uuid>] [--ide cursor|copilot-vscode|jetbrains|claude-code|windsurf|opencode|codex] [--dry-run] [--all-projects] [--yes]"
   );
   process.exit(0);
 }