@memoraone/mcp 0.1.36 → 0.1.37

package/dist/cli.cjs

@@ -30,7 +30,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.36",
+      version: "0.1.37",
       type: "module",
       main: "dist/index.cjs",
       bin: {
@@ -366,7 +366,7 @@ async function acquireLocalLock(lockName, options = {}) {
             `[memoraone-mcp] Failed to acquire lock ${lockName} after ${maxRetries} retries`
           );
         }
-        await new Promise((resolve16) => setTimeout(resolve16, retryDelayMs));
+        await new Promise((resolve17) => setTimeout(resolve17, retryDelayMs));
         continue;
       }
       throw err;
@@ -855,9 +855,9 @@ var MemoraOneHttpError = class extends Error {
 };
 
 // src/localState/localConnectClient.ts
-async function requestJson(baseUrl, method, path20, options = {}) {
+async function requestJson(baseUrl, method, path21, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
-  const url = `${baseUrl.replace(/\/+$/, "")}${path20.startsWith("/") ? path20 : `/${path20}`}`;
+  const url = `${baseUrl.replace(/\/+$/, "")}${path21.startsWith("/") ? path21 : `/${path21}`}`;
   const res = await fetchImpl(url, {
     method,
     headers: {
@@ -1528,8 +1528,8 @@ var StdioLineReader = class {
     if (this.closed) {
       return null;
     }
-    return new Promise((resolve16) => {
-      this.waiters.push(resolve16);
+    return new Promise((resolve17) => {
+      this.waiters.push(resolve17);
     });
   }
   /** Re-queue lines read during an intermediate protocol step (e.g. roots/list) for the main bridge loop. */
@@ -1602,17 +1602,17 @@ async function requestClientRootsListUris(options) {
 }
 
 // src/cleanup.ts
-var fs10 = __toESM(require("fs/promises"), 1);
-var path13 = __toESM(require("path"), 1);
+var fs11 = __toESM(require("fs/promises"), 1);
+var path15 = __toESM(require("path"), 1);
 var readline2 = __toESM(require("readline/promises"), 1);
 var import_node_child_process3 = require("child_process");
 var import_node_util3 = require("util");
 var import_node_process = require("process");
 
 // src/cursorGlobalMcpConfig.ts
-var fs9 = __toESM(require("fs/promises"), 1);
+var fs10 = __toESM(require("fs/promises"), 1);
 var os4 = __toESM(require("os"), 1);
-var path12 = __toESM(require("path"), 1);
+var path14 = __toESM(require("path"), 1);
 var import_node_child_process2 = require("child_process");
 var import_node_util2 = require("util");
 
@@ -1787,19 +1787,194 @@ async function resolveBindingFromInitializeParams(params, options = {}) {
   });
 }
 
+// src/packageExecutionMode.ts
+var path13 = __toESM(require("path"), 1);
+
+// src/resolveBuiltCliPath.ts
+var fs9 = __toESM(require("fs/promises"), 1);
+var path12 = __toESM(require("path"), 1);
+var MONOREPO_CLI_REL = path12.join("packages", "mcp", "dist", "cli.cjs");
+async function pathExists(filePath) {
+  try {
+    await fs9.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findMonorepoCliFrom(startDir) {
+  let current = path12.resolve(startDir);
+  const root = path12.parse(current).root;
+  while (true) {
+    const candidate = path12.join(current, MONOREPO_CLI_REL);
+    if (await pathExists(candidate)) {
+      return path12.resolve(candidate);
+    }
+    if (current === root) break;
+    current = path12.dirname(current);
+  }
+  return null;
+}
+async function resolveFromRunningScript() {
+  if (!process.argv[1]) return null;
+  const script = path12.resolve(process.argv[1]);
+  const base = path12.basename(script);
+  if ((base === "cli.cjs" || base === "cli.ts" || base === "memoraone-mcp.cjs") && await pathExists(script)) {
+    return script;
+  }
+  const here = path12.dirname(script);
+  const candidates = [
+    path12.join(here, "cli.cjs"),
+    path12.join(here, "..", "dist", "cli.cjs"),
+    path12.join(here, "..", "..", "dist", "cli.cjs")
+  ];
+  for (const candidate of candidates) {
+    if (await pathExists(candidate)) {
+      return path12.resolve(candidate);
+    }
+  }
+  return null;
+}
+async function resolveBuiltCliPathAsync(options) {
+  const preferRunning = options?.preferRunningScript !== false;
+  if (preferRunning) {
+    const fromRunning = await resolveFromRunningScript();
+    if (fromRunning) return fromRunning;
+  }
+  const searchDirs = [];
+  if (options?.searchFrom !== void 0) {
+    const dirs = Array.isArray(options.searchFrom) ? options.searchFrom : [options.searchFrom];
+    searchDirs.push(...dirs);
+  }
+  searchDirs.push(process.cwd());
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of searchDirs) {
+    const key = path12.resolve(dir);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const found = await findMonorepoCliFrom(key);
+    if (found) return found;
+  }
+  if (!preferRunning) {
+    return resolveFromRunningScript();
+  }
+  return null;
+}
+
+// src/packageExecutionMode.ts
+var PROD_API_URL = "https://api.memoraone.com";
+var STAGING_API_URL = "https://memora-api-staging-phbtrzocjq-uk.a.run.app";
+var STAGING_API_URL_PREFIX = "https://memora-api-staging-";
+function normalizeApiUrl(url) {
+  return url.trim().replace(/\/+$/, "");
+}
+function memoraoneNpmPackageSpec(channel) {
+  return channel === "staging" ? "@memoraone/mcp@staging" : "@memoraone/mcp@latest";
+}
+function isMemoraoneNpmPackageSpec(value) {
+  return value === "@memoraone/mcp@staging" || value === "@memoraone/mcp@latest";
+}
+function npmPackageChannelFromEnvironment(environment) {
+  return environment === "staging" ? "staging" : "latest";
+}
+function cursorEnvironmentFromPackageExecutionMode(mode) {
+  if (mode.kind === "local") return "local";
+  return mode.channel === "staging" ? "staging" : "production";
+}
+function npmPackageChannelFromApiUrl(apiUrl) {
+  if (!apiUrl) return "latest";
+  const normalized = normalizeApiUrl(apiUrl);
+  if (normalized === STAGING_API_URL || normalized.startsWith(STAGING_API_URL_PREFIX)) {
+    return "staging";
+  }
+  if (normalized === PROD_API_URL) return "latest";
+  return "latest";
+}
+function looksLikeLocalMonorepoCliPath(scriptPath) {
+  const normalized = scriptPath.replace(/\\/g, "/");
+  if (normalized.includes("/node_modules/@memoraone/mcp/")) return false;
+  if (normalized.includes("/.npm/_npx/")) return false;
+  if (normalized.includes("/_npx/")) return false;
+  const base = path13.basename(normalized);
+  if (base === "cli.ts" || base === "cli.cjs" || base === "memoraone-mcp.cjs") {
+    if (normalized.includes("/packages/mcp/dist/") || normalized.includes("/packages/mcp/dist-bin/") || normalized.includes("/packages/mcp/src/")) {
+      return true;
+    }
+  }
+  return false;
+}
+function looksLikePublishedPackagePath(scriptPath) {
+  const normalized = scriptPath.replace(/\\/g, "/");
+  return normalized.includes("/node_modules/@memoraone/mcp/") || normalized.includes("/.npm/_npx/") || /\/_npx\//.test(normalized);
+}
+function channelFromEnv(env2) {
+  const explicit = env2.MEMORAONE_NPM_CHANNEL?.trim().toLowerCase() || env2.npm_config_tag?.trim().toLowerCase();
+  if (explicit === "staging") return "staging";
+  if (explicit === "latest") return "latest";
+  return void 0;
+}
+async function resolvePackageExecutionMode(options = {}) {
+  if (options.executionMode) return options.executionMode;
+  const env2 = options.env ?? process.env;
+  const scriptPath = options.scriptPath !== void 0 ? options.scriptPath : process.argv[1] ? path13.resolve(process.argv[1]) : null;
+  if (scriptPath && looksLikePublishedPackagePath(scriptPath)) {
+    const channel2 = channelFromEnv(env2) ?? npmPackageChannelFromApiUrl(options.apiUrl);
+    return { kind: "published", channel: channel2 };
+  }
+  if (scriptPath && looksLikeLocalMonorepoCliPath(scriptPath)) {
+    return { kind: "local", cliPath: scriptPath };
+  }
+  if (options.cliPath) {
+    return { kind: "local", cliPath: path13.resolve(options.cliPath) };
+  }
+  const resolveCli = options.resolveBuiltCliPath ?? resolveBuiltCliPathAsync;
+  const builtCli = await resolveCli();
+  if (builtCli && looksLikeLocalMonorepoCliPath(builtCli) && !(scriptPath && looksLikePublishedPackagePath(scriptPath))) {
+    return { kind: "local", cliPath: builtCli };
+  }
+  const channel = channelFromEnv(env2) ?? npmPackageChannelFromApiUrl(options.apiUrl);
+  return { kind: "published", channel };
+}
+function setupOptionsFromPackageExecutionMode(mode) {
+  if (mode.kind === "local") {
+    return {
+      cursorEnvironment: "local",
+      devMode: true,
+      npmPackageChannel: "latest",
+      cursorLocalCliPathOverride: mode.cliPath,
+      cliPathOverride: mode.cliPath
+    };
+  }
+  return {
+    cursorEnvironment: cursorEnvironmentFromPackageExecutionMode(mode),
+    devMode: false,
+    npmPackageChannel: mode.channel,
+    cursorLocalCliPathOverride: null,
+    cliPathOverride: null
+  };
+}
+function formatIdeSetupRepairHint(workspaceRoot, mode) {
+  if (mode.kind === "local") {
+    return `Repair with (no new connect code): node ${mode.cliPath} setup-ide-files --all --local --dev --force --workspace-root ${workspaceRoot}`;
+  }
+  const spec = memoraoneNpmPackageSpec(mode.channel);
+  const stagingFlag = mode.channel === "staging" ? " --staging" : "";
+  return `Repair with (no new connect code): npx -y ${spec} setup-ide-files --all${stagingFlag} --force --workspace-root ${workspaceRoot}`;
+}
+
 // src/cursorGlobalMcpConfig.ts
 var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
 var MEMORAONE_PROD_API_URL = "https://api.memoraone.com";
 var MEMORAONE_LOCAL_API_URL = "http://localhost:3001";
 var MEMORAONE_STAGING_API_URL = "https://memora-api-staging-phbtrzocjq-uk.a.run.app";
 var MEMORAONE_STAGING_API_URL_PREFIX = "https://memora-api-staging-";
-function normalizeApiUrl(url) {
+function normalizeApiUrl2(url) {
   return url.trim().replace(/\/+$/, "");
 }
 function resolveIdeApiUrl(options) {
+  if (options.apiUrl) return normalizeApiUrl2(options.apiUrl);
   if (options.environment === "staging") return MEMORAONE_STAGING_API_URL;
   if (options.environment === "production") return MEMORAONE_PROD_API_URL;
-  if (options.apiUrl) return normalizeApiUrl(options.apiUrl);
   return MEMORAONE_LOCAL_API_URL;
 }
 function buildMemoraoneCursorMcpServer(options) {
@@ -1811,7 +1986,7 @@ function buildMemoraoneCursorMcpServer(options) {
     MEMORAONE_IDE_TYPE: "cursor"
   };
   if (options.workspaceRoot !== void 0) {
-    env2[MEMORAONE_WORKSPACE_ROOT_ENV] = path12.resolve(options.workspaceRoot);
+    env2[MEMORAONE_WORKSPACE_ROOT_ENV] = path14.resolve(options.workspaceRoot);
   }
   if (options.environment === "local") {
     if (!options.cliPath) {
@@ -1826,15 +2001,16 @@ function buildMemoraoneCursorMcpServer(options) {
   if (!options.npxPath) {
     throw new Error("[setup-ide-files] Cursor MCP config requires a resolved npx path.");
   }
+  const channel = options.npmPackageChannel ?? npmPackageChannelFromEnvironment(options.environment);
   return {
     command: options.npxPath,
-    args: ["-y", "@memoraone/mcp@latest"],
+    args: ["-y", memoraoneNpmPackageSpec(channel)],
     env: env2
   };
 }
-async function pathExists(filePath) {
+async function pathExists2(filePath) {
   try {
-    await fs9.access(filePath);
+    await fs10.access(filePath);
     return true;
   } catch {
     return false;
@@ -1844,17 +2020,17 @@ function stripLeadingLineComments(text) {
   return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
 }
 function getKnownCursorGlobalMcpConfigCandidates(homeDir) {
-  return [path12.join(homeDir, ".cursor", "mcp.json")];
+  return [path14.join(homeDir, ".cursor", "mcp.json")];
 }
 async function detectCursorGlobalMcpConfig(options) {
   if (options?.explicitPath) {
-    return { ok: true, path: options.explicitPath, detectedExisting: await pathExists(options.explicitPath) };
+    return { ok: true, path: options.explicitPath, detectedExisting: await pathExists2(options.explicitPath) };
   }
   const homeDir = options?.homeDir ?? os4.homedir();
   const candidates = getKnownCursorGlobalMcpConfigCandidates(homeDir);
   const existing = [];
   for (const candidate of candidates) {
-    if (await pathExists(candidate)) existing.push(candidate);
+    if (await pathExists2(candidate)) existing.push(candidate);
   }
   if (existing.length > 1) {
     return {
@@ -1882,10 +2058,10 @@ function formatBackupTimestamp(d = /* @__PURE__ */ new Date()) {
 }
 async function isWorkingNpx(npxPath) {
   try {
-    if (!await pathExists(npxPath)) return false;
+    if (!await pathExists2(npxPath)) return false;
     if (process.platform !== "win32") {
       try {
-        await fs9.access(npxPath, fs9.constants.X_OK);
+        await fs10.access(npxPath, fs10.constants.X_OK);
       } catch {
         return false;
       }
@@ -1907,7 +2083,7 @@ async function resolveNpxPath() {
   const pathSep = process.platform === "win32" ? ";" : ":";
   for (const dir of (process.env.PATH ?? "").split(pathSep)) {
     if (!dir) continue;
-    candidates.push(path12.join(dir, npxName));
+    candidates.push(path14.join(dir, npxName));
   }
   try {
     const lookupCmd = process.platform === "win32" ? "where" : "which";
@@ -1918,7 +2094,7 @@ async function resolveNpxPath() {
   }
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of candidates) {
-    const abs = path12.isAbsolute(candidate) ? candidate : path12.resolve(candidate);
+    const abs = path14.isAbsolute(candidate) ? candidate : path14.resolve(candidate);
     const key = process.platform === "win32" ? abs.toLowerCase() : abs;
     if (seen.has(key)) continue;
     seen.add(key);
@@ -1930,12 +2106,14 @@ function mergeCursorRepoMcpConfigObject(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
+    apiUrl: writeOptions.apiUrl,
+    npmPackageChannel: writeOptions.npmPackageChannel
   });
   return { ...base, mcpServers };
 }
@@ -1949,7 +2127,7 @@ function isManagedMemoraoneCursorServer(server) {
   if (!server || typeof server !== "object") return false;
   const s = server;
   if (!Array.isArray(s.args) || s.args.length !== 2) return false;
-  if (s.args[0] !== "-y" || s.args[1] !== "@memoraone/mcp@latest") return false;
+  if (s.args[0] !== "-y" || !isMemoraoneNpmPackageSpec(s.args[1])) return false;
   const env2 = s.env;
   if (!env2 || typeof env2 !== "object") return false;
   return memoraoneEnvMatchesManagedCleanupShape(env2);
@@ -1964,11 +2142,11 @@ function memoraoneEnvMatchesManagedCleanupShape(env2) {
   return env2.MEMORAONE_IDE_TYPE === "cursor" && isMemoraoneManagedApiUrl(env2.MEMORAONE_API_URL);
 }
 function getCursorRepoMcpConfigPath(repoRoot) {
-  return path12.join(repoRoot, ".cursor", "mcp.json");
+  return path14.join(repoRoot, ".cursor", "mcp.json");
 }
 async function readCursorMcpConfigObject(configPath) {
   try {
-    const raw = await fs9.readFile(configPath, "utf8");
+    const raw = await fs10.readFile(configPath, "utf8");
     return JSON.parse(stripLeadingLineComments(raw));
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
@@ -1986,21 +2164,21 @@ async function removeMemoraoneFromCursorGlobalConfig(options) {
     return { changed: true, backupPath: `${configPath}.backup-<timestamp>` };
   }
   const backupPath = `${configPath}.backup-${formatBackupTimestamp()}`;
-  await fs9.copyFile(configPath, backupPath);
+  await fs10.copyFile(configPath, backupPath);
   const mcpServers = typeof parsed2.mcpServers === "object" && parsed2.mcpServers !== null && !Array.isArray(parsed2.mcpServers) ? { ...parsed2.mcpServers } : {};
   delete mcpServers.memoraone;
   const hasOtherServers = Object.keys(mcpServers).length > 0;
   if (!hasOtherServers) {
-    await fs9.unlink(configPath);
+    await fs10.unlink(configPath);
     return { changed: true, backupPath };
   }
   const next = { ...parsed2, mcpServers };
-  await fs9.mkdir(path12.dirname(configPath), { recursive: true });
-  await fs9.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
+  await fs10.mkdir(path14.dirname(configPath), { recursive: true });
+  await fs10.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
   return { changed: true, backupPath };
 }
 async function auditCursorMcpConfig(options) {
-  const repoRoot = path12.resolve(options?.repoRoot ?? process.cwd());
+  const repoRoot = path14.resolve(options?.repoRoot ?? process.cwd());
   const repoConfigPath = getCursorRepoMcpConfigPath(repoRoot);
   const globalDetection = await detectCursorGlobalMcpConfig({
     homeDir: options?.homeDir,
@@ -2177,7 +2355,7 @@ async function defaultListSocketPaths(projectId) {
   const baseDir = getMcpBaseDir();
   let entries;
   try {
-    entries = await fs10.readdir(baseDir);
+    entries = await fs11.readdir(baseDir);
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
     if (code === "ENOENT") {
@@ -2190,7 +2368,7 @@ async function defaultListSocketPaths(projectId) {
     if (!name.endsWith(".sock") || !isMemoraoneSocketFilename(name)) {
       continue;
     }
-    const socketPath = path13.join(baseDir, name);
+    const socketPath = path15.join(baseDir, name);
     if (projectId === null) {
       paths.push(socketPath);
       continue;
@@ -2210,11 +2388,11 @@ async function defaultListSocketPaths(projectId) {
   return paths.sort();
 }
 async function defaultListSocketPathsForWorkspaceRoot(workspaceRoot) {
-  const resolvedRoot = path13.resolve(workspaceRoot);
+  const resolvedRoot = path15.resolve(workspaceRoot);
   const baseDir = getMcpBaseDir();
   let entries;
   try {
-    entries = await fs10.readdir(baseDir);
+    entries = await fs11.readdir(baseDir);
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
     if (code === "ENOENT") {
@@ -2227,10 +2405,10 @@ async function defaultListSocketPathsForWorkspaceRoot(workspaceRoot) {
     if (!name.endsWith(".sock") || !isHashSocketFilename(name)) {
       continue;
     }
-    const socketPath = path13.join(baseDir, name);
+    const socketPath = path15.join(baseDir, name);
     const record = readBindingSidecarRecord(socketPath);
     if (!record?.workspaceRoot) continue;
-    if (path13.resolve(record.workspaceRoot) === resolvedRoot) {
+    if (path15.resolve(record.workspaceRoot) === resolvedRoot) {
       paths.push(socketPath);
     }
   }
@@ -2239,21 +2417,21 @@ async function defaultListSocketPathsForWorkspaceRoot(workspaceRoot) {
 async function filterSocketPathsByIdeForCleanup(socketPaths, projectId, ide, workspaceRoot) {
   if (ide === void 0) return socketPaths;
   const normalizedProjectId = projectId.trim().toLowerCase();
-  const resolvedRoot = workspaceRoot ? path13.resolve(workspaceRoot) : null;
+  const resolvedRoot = workspaceRoot ? path15.resolve(workspaceRoot) : null;
   const filtered = [];
   for (const socketPath of socketPaths) {
-    const basename8 = path13.basename(socketPath);
-    if (isLegacySocketFilename(basename8)) {
-      if (isSocketFilenameForProjectAndIde(basename8, normalizedProjectId, ide)) {
+    const basename11 = path15.basename(socketPath);
+    if (isLegacySocketFilename(basename11)) {
+      if (isSocketFilenameForProjectAndIde(basename11, normalizedProjectId, ide)) {
         filtered.push(socketPath);
       }
       continue;
     }
-    if (isHashSocketFilename(basename8)) {
+    if (isHashSocketFilename(basename11)) {
       const record = readBindingSidecarRecord(socketPath);
       if (!record || record.ideType !== ide) continue;
       const sameProject = record.projectId.trim().toLowerCase() === normalizedProjectId;
-      const sameWorkspace = resolvedRoot !== null && path13.resolve(record.workspaceRoot) === resolvedRoot;
+      const sameWorkspace = resolvedRoot !== null && path15.resolve(record.workspaceRoot) === resolvedRoot;
       if (sameProject || sameWorkspace) {
         filtered.push(socketPath);
       }
@@ -2265,9 +2443,9 @@ async function defaultKillProcess(pid) {
   process.kill(pid, "SIGTERM");
 }
 async function defaultRemoveSocket(socketPath) {
-  await fs10.unlink(socketPath);
+  await fs11.unlink(socketPath);
   try {
-    await fs10.unlink(bindingSidecarPath(socketPath));
+    await fs11.unlink(bindingSidecarPath(socketPath));
   } catch {
   }
 }
@@ -2285,7 +2463,7 @@ async function defaultConfirm(message) {
 }
 async function resolveCleanupTarget(cwd2) {
   try {
-    const binding = await resolveAuthoritativeBinding([path13.resolve(cwd2)]);
+    const binding = await resolveAuthoritativeBinding([path15.resolve(cwd2)]);
     return {
       workspaceRoot: binding.workspaceRoot,
       repositoryBindingId: binding.repositoryBindingId,
@@ -2463,7 +2641,7 @@ async function runCleanup(opts) {
       projectIds.add(proc.projectId);
     }
     for (const socketPath of socketPaths) {
-      const id = extractProjectIdFromSocketFilename(path13.basename(socketPath));
+      const id = extractProjectIdFromSocketFilename(path15.basename(socketPath));
       if (id) {
         projectIds.add(id);
         continue;
@@ -2649,9 +2827,9 @@ function summarizeJsonRpcMethod(line) {
   }
 }
 function connectWithRetry(socketPath, log, maxRetries, retryDelayMs, connect2) {
-  return new Promise((resolve16, reject) => {
+  return new Promise((resolve17, reject) => {
     const tryConnect = (attempt) => {
-      connect2(socketPath).then(resolve16).catch((err) => {
+      connect2(socketPath).then(resolve17).catch((err) => {
         if (attempt >= maxRetries) {
           reject(err);
           return;
@@ -2767,8 +2945,8 @@ 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((resolve16, reject) => {
-      const socket = net.connect(socketPath, () => resolve16(socket));
+    this.connectImpl = options.connect ?? ((socketPath) => new Promise((resolve17, reject) => {
+      const socket = net.connect(socketPath, () => resolve17(socket));
       socket.on("error", reject);
     }));
     this.spawnDaemonImpl = options.spawnDaemon ?? (async (binding) => {
@@ -3032,12 +3210,14 @@ async function runBridgeProxy(options) {
 // src/setupIdeFiles.ts
 var fs13 = __toESM(require("fs/promises"), 1);
 var os6 = __toESM(require("os"), 1);
-var path16 = __toESM(require("path"), 1);
+var path17 = __toESM(require("path"), 1);
+var import_node_crypto5 = require("crypto");
 
 // src/jetbrainsMcpConfig.ts
-var fs11 = __toESM(require("fs/promises"), 1);
+var fs12 = __toESM(require("fs/promises"), 1);
 var os5 = __toESM(require("os"), 1);
-var path14 = __toESM(require("path"), 1);
+var path16 = __toESM(require("path"), 1);
+var import_node_crypto4 = require("crypto");
 var import_node_child_process5 = require("child_process");
 
 // src/configUtils.ts
@@ -3059,7 +3239,6 @@ function resolveApiUrl(env2) {
 }
 
 // src/jetbrainsMcpConfig.ts
-var PROD_API_URL = "https://api.memoraone.com";
 var JETBRAINS_DEBUG_ENV_VARS = [
   "MEMORAONE_DEBUG_INIT",
   "MEMORAONE_DEBUG_MINIMAL_TOOLS",
@@ -3069,9 +3248,9 @@ var JETBRAINS_DEBUG_ENV_VARS = [
 function stripLeadingLineComments2(text) {
   return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
 }
-async function pathExists2(filePath) {
+async function pathExists3(filePath) {
   try {
-    await fs11.access(filePath);
+    await fs12.access(filePath);
     return true;
   } catch {
     return false;
@@ -3082,12 +3261,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 path14.join(homeDir, ".ai", "mcp", "mcp.json");
+  return path16.join(homeDir, ".ai", "mcp", "mcp.json");
 }
 function getJetBrainsProjectMcpConfigPaths(repoRoot) {
   return [
-    { kind: "project-ai", path: path14.join(repoRoot, ".ai", "mcp", "mcp.json") },
-    { kind: "project-ij", path: path14.join(repoRoot, ".ij", "mcp", "mcp.json") }
+    { kind: "project-ai", path: path16.join(repoRoot, ".ai", "mcp", "mcp.json") },
+    { kind: "project-ij", path: path16.join(repoRoot, ".ij", "mcp", "mcp.json") }
   ];
 }
 function getKnownJetBrainsMcpConfigLocations(homeDir, repoRoot) {
@@ -3097,17 +3276,21 @@ function getKnownJetBrainsMcpConfigLocations(homeDir, repoRoot) {
   ];
 }
 async function isZeroByteConfigFile(filePath) {
-  if (!await pathExists2(filePath)) return false;
-  const stat4 = await fs11.stat(filePath);
+  if (!await pathExists3(filePath)) return false;
+  const stat4 = await fs12.stat(filePath);
   return stat4.size === 0;
 }
 function buildMemoraoneJetBrainsMcpServer(options) {
+  const environment = options.environment ?? (options.devMode ? "local" : "production");
   const env2 = {
-    MEMORAONE_API_URL: options.devMode ? options.apiUrl ? normalizeApiUrl(options.apiUrl) : DEV_API_URL : PROD_API_URL,
+    MEMORAONE_API_URL: resolveIdeApiUrl({
+      environment,
+      apiUrl: options.apiUrl ?? (environment === "local" ? DEV_API_URL : void 0)
+    }),
     MEMORAONE_IDE_TYPE: "jetbrains",
-    [MEMORAONE_WORKSPACE_ROOT_ENV]: path14.resolve(options.workspaceRoot)
+    [MEMORAONE_WORKSPACE_ROOT_ENV]: path16.resolve(options.workspaceRoot)
   };
-  if (options.devMode) {
+  if (environment === "local" || options.devMode) {
     env2.MEMORAONE_DEV_MODE = "1";
   }
   if ("MEMORAONE_M1_PATH" in env2 || "MEMORAONE_API_KEY" in env2) {
@@ -3122,9 +3305,28 @@ function buildMemoraoneJetBrainsMcpServer(options) {
 function mergeJetBrainsMcpConfigObject(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 };
 }
+async function writeJetBrainsMcpJsonAtomic(filePath, content) {
+  const dir = path16.dirname(filePath);
+  await fs12.mkdir(dir, { recursive: true });
+  const tmpPath = path16.join(
+    dir,
+    `.${path16.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);
+  } catch (err) {
+    try {
+      await fs12.unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
 function memoraoneServerMatches(server, expected) {
   if (!server || typeof server !== "object") return false;
   const s = server;
@@ -3160,13 +3362,13 @@ function validateJetBrainsMcpConfig(parsed2, expected) {
   }
 }
 async function readJsonConfig(filePath) {
-  const raw = await fs11.readFile(filePath, "utf8");
+  const raw = await fs12.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments2(raw));
 }
 async function backupConfigFile(filePath) {
   const backupPath = `${filePath}.bak-${formatJetBrainsBackupTimestamp()}`;
-  await fs11.copyFile(filePath, backupPath);
+  await fs12.copyFile(filePath, backupPath);
   return backupPath;
 }
 async function repairZeroByteConfigFile(filePath, dryRun) {
@@ -3177,7 +3379,7 @@ async function repairZeroByteConfigFile(filePath, dryRun) {
     return { repaired: true, backupPath: `${filePath}.bak-<timestamp>` };
   }
   const backupPath = await backupConfigFile(filePath);
-  await fs11.unlink(filePath);
+  await fs12.unlink(filePath);
   return { repaired: true, backupPath };
 }
 function configHasMemoraone(parsed2) {
@@ -3188,7 +3390,7 @@ function configHasMemoraone(parsed2) {
 }
 async function removeMemoraoneFromProjectConfig(options) {
   const { configPath, dryRun } = options;
-  if (!await pathExists2(configPath)) {
+  if (!await pathExists3(configPath)) {
     return { changed: false };
   }
   let parsed2 = null;
@@ -3208,30 +3410,31 @@ async function removeMemoraoneFromProjectConfig(options) {
   delete mcpServers.memoraone;
   const hasOtherServers = Object.keys(mcpServers).length > 0;
   if (!hasOtherServers) {
-    await fs11.unlink(configPath);
+    await fs12.unlink(configPath);
     return { changed: true, backupPath };
   }
   const next = { ...parsed2, mcpServers };
-  await fs11.mkdir(path14.dirname(configPath), { recursive: true });
-  await fs11.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
+  await fs12.mkdir(path16.dirname(configPath), { recursive: true });
+  await fs12.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
   return { changed: true, backupPath };
 }
 async function resolveLocalCliPathAsync() {
-  const here = process.argv[1] ? path14.dirname(path14.resolve(process.argv[1])) : process.cwd();
+  const here = process.argv[1] ? path16.dirname(path16.resolve(process.argv[1])) : process.cwd();
   const candidates = [
-    path14.join(here, "cli.cjs"),
-    path14.join(here, "..", "dist", "cli.cjs"),
-    path14.join(here, "..", "..", "dist", "cli.cjs")
+    path16.join(here, "cli.cjs"),
+    path16.join(here, "..", "dist", "cli.cjs"),
+    path16.join(here, "..", "..", "dist", "cli.cjs")
   ];
   for (const candidate of candidates) {
-    if (await pathExists2(candidate)) {
-      return path14.resolve(candidate);
+    if (await pathExists3(candidate)) {
+      return path16.resolve(candidate);
     }
   }
   return null;
 }
 async function buildJetBrainsMemoraoneServer(options) {
-  if (options.devMode) {
+  const environment = options.environment ?? (options.devMode ? "local" : "production");
+  if (environment === "local" || options.devMode) {
     let cliPath = options.cliPathOverride;
     if (cliPath === void 0) {
       cliPath = await resolveLocalCliPathAsync();
@@ -3245,6 +3448,7 @@ async function buildJetBrainsMemoraoneServer(options) {
       command: process.execPath,
       args: [cliPath],
       workspaceRoot: options.workspaceRoot,
+      environment: "local",
       devMode: true,
       apiUrl: options.apiUrl
     });
@@ -3258,17 +3462,20 @@ async function buildJetBrainsMemoraoneServer(options) {
       "[setup-ide-files] Could not resolve a working npx executable. Install Node.js/npm or ensure npx is on PATH before configuring JetBrains MCP."
     );
   }
+  const channel = options.npmPackageChannel ?? npmPackageChannelFromEnvironment(environment);
   return buildMemoraoneJetBrainsMcpServer({
     command: npxPath,
-    args: ["-y", "@memoraone/mcp@latest"],
+    args: ["-y", memoraoneNpmPackageSpec(channel)],
     workspaceRoot: options.workspaceRoot,
-    devMode: false
+    environment,
+    devMode: false,
+    apiUrl: options.apiUrl
   });
 }
 async function verifyJetBrainsMcpHandshake(options) {
   const timeoutMs = options.timeoutMs ?? 15e3;
   const { server } = options;
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     let settled = false;
     const finish = (ok, detail) => {
       if (settled) return;
@@ -3278,7 +3485,7 @@ async function verifyJetBrainsMcpHandshake(options) {
         child.kill();
       } catch {
       }
-      resolve16({ ok, detail });
+      resolve17({ ok, detail });
     };
     const child = (0, import_node_child_process5.spawn)(server.command, [...server.args], {
       env: { ...process.env, ...server.env },
@@ -3347,11 +3554,11 @@ async function verifyJetBrainsMcpHandshake(options) {
 async function setupJetBrainsMcpConfig(options) {
   const homeDir = options.homeDir ?? os5.homedir();
   const globalPath = options.globalConfigPath ?? getJetBrainsGlobalMcpConfigPath(homeDir);
-  const workspaceRoot = path14.resolve(options.repoRoot);
+  const workspaceRoot = path16.resolve(options.repoRoot);
   const repairActions = [];
   const allLocations = getKnownJetBrainsMcpConfigLocations(homeDir, options.repoRoot);
   for (const location of allLocations) {
-    if (await pathExists2(location.path)) {
+    if (await pathExists3(location.path)) {
       repairActions.push({ type: "found-config", location });
     }
   }
@@ -3368,6 +3575,8 @@ async function setupJetBrainsMcpConfig(options) {
   const memoraone = await buildJetBrainsMemoraoneServer({
     workspaceRoot,
     devMode: options.devMode,
+    environment: options.environment,
+    npmPackageChannel: options.npmPackageChannel,
     apiUrl: options.apiUrl,
     npxPathOverride: options.npxPathOverride,
     cliPathOverride: options.cliPathOverride
@@ -3388,24 +3597,15 @@ async function setupJetBrainsMcpConfig(options) {
       repairActions.push({ type: "removed-project-memoraone", path: location.path });
     }
   }
-  const existed = await pathExists2(globalPath);
+  const existed = await pathExists3(globalPath);
   let existing = null;
   if (existed) {
     try {
       existing = await readJsonConfig(globalPath);
     } catch {
-      if (options.dryRun) {
-        existing = null;
-      } else {
-        const backupPath2 = await backupConfigFile(globalPath);
-        repairActions.push({
-          type: "repaired-zero-byte",
-          path: globalPath,
-          backupPath: backupPath2
-        });
-        await fs11.unlink(globalPath);
-        existing = null;
-      }
+      throw new Error(
+        `[setup-ide-files] Invalid JSON in shared JetBrains MCP config (file preserved, not modified): ${globalPath}. Fix or remove the file, then re-run setup-ide-files.`
+      );
     }
   }
   const merged = mergeJetBrainsMcpConfigObject(existing, memoraone);
@@ -3426,9 +3626,8 @@ async function setupJetBrainsMcpConfig(options) {
   if (existed) {
     backupPath = await backupConfigFile(globalPath);
   }
-  await fs11.mkdir(path14.dirname(globalPath), { recursive: true });
-  await fs11.writeFile(globalPath, body, "utf8");
-  const verifyRaw = await fs11.readFile(globalPath, "utf8");
+  await writeJetBrainsMcpJsonAtomic(globalPath, body);
+  const verifyRaw = await fs12.readFile(globalPath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments2(verifyRaw));
   validateJetBrainsMcpConfig(verifyParsed, memoraone);
   const outcome = existed ? "updated" : "created";
@@ -3483,77 +3682,6 @@ function logJetBrainsMcpCliSummary(info, dryRun) {
   );
 }
 
-// src/resolveBuiltCliPath.ts
-var fs12 = __toESM(require("fs/promises"), 1);
-var path15 = __toESM(require("path"), 1);
-var MONOREPO_CLI_REL = path15.join("packages", "mcp", "dist", "cli.cjs");
-async function pathExists3(filePath) {
-  try {
-    await fs12.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function findMonorepoCliFrom(startDir) {
-  let current = path15.resolve(startDir);
-  const root = path15.parse(current).root;
-  while (true) {
-    const candidate = path15.join(current, MONOREPO_CLI_REL);
-    if (await pathExists3(candidate)) {
-      return path15.resolve(candidate);
-    }
-    if (current === root) break;
-    current = path15.dirname(current);
-  }
-  return null;
-}
-async function resolveFromRunningScript() {
-  if (!process.argv[1]) return null;
-  const script = path15.resolve(process.argv[1]);
-  const base = path15.basename(script);
-  if ((base === "cli.cjs" || base === "cli.ts" || base === "memoraone-mcp.cjs") && await pathExists3(script)) {
-    return script;
-  }
-  const here = path15.dirname(script);
-  const candidates = [
-    path15.join(here, "cli.cjs"),
-    path15.join(here, "..", "dist", "cli.cjs"),
-    path15.join(here, "..", "..", "dist", "cli.cjs")
-  ];
-  for (const candidate of candidates) {
-    if (await pathExists3(candidate)) {
-      return path15.resolve(candidate);
-    }
-  }
-  return null;
-}
-async function resolveBuiltCliPathAsync(options) {
-  const preferRunning = options?.preferRunningScript !== false;
-  if (preferRunning) {
-    const fromRunning = await resolveFromRunningScript();
-    if (fromRunning) return fromRunning;
-  }
-  const searchDirs = [];
-  if (options?.searchFrom !== void 0) {
-    const dirs = Array.isArray(options.searchFrom) ? options.searchFrom : [options.searchFrom];
-    searchDirs.push(...dirs);
-  }
-  searchDirs.push(process.cwd());
-  const seen = /* @__PURE__ */ new Set();
-  for (const dir of searchDirs) {
-    const key = path15.resolve(dir);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    const found = await findMonorepoCliFrom(key);
-    if (found) return found;
-  }
-  if (!preferRunning) {
-    return resolveFromRunningScript();
-  }
-  return null;
-}
-
 // src/openCursorMcpSettings.ts
 var import_node_child_process6 = require("child_process");
 var readline4 = __toESM(require("readline/promises"), 1);
@@ -3795,7 +3923,7 @@ function buildMemoraoneMcpServer(ideType, options = {}) {
       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] = path16.resolve(options.workspaceRoot);
+      env2[MEMORAONE_WORKSPACE_ROOT_ENV] = path17.resolve(options.workspaceRoot);
     }
     return {
       command: "node",
@@ -3803,16 +3931,17 @@ function buildMemoraoneMcpServer(ideType, options = {}) {
       env: env2
     };
   }
+  const channel = options.npmPackageChannel ?? npmPackageChannelFromEnvironment(environment);
   return {
     command: options.command ?? "npx",
-    args: ["-y", "@memoraone/mcp@latest"],
+    args: ["-y", memoraoneNpmPackageSpec(channel)],
     env: env2
   };
 }
 function assertUnderRepoRoot(repoRoot, absPath) {
-  const normRoot = path16.resolve(repoRoot) + path16.sep;
-  const normPath = path16.resolve(absPath);
-  if (normPath !== path16.resolve(repoRoot) && !normPath.startsWith(normRoot)) {
+  const normRoot = path17.resolve(repoRoot) + path17.sep;
+  const normPath = path17.resolve(absPath);
+  if (normPath !== path17.resolve(repoRoot) && !normPath.startsWith(normRoot)) {
     throw new Error(`[setup-ide-files] Refusing to write outside repo root: ${absPath}`);
   }
 }
@@ -3828,18 +3957,18 @@ async function ensureGitignoreMemoraone(_repoRoot, _opts) {
   return "skipped";
 }
 async function findRepoRoot(startDir) {
-  let current = path16.resolve(startDir);
-  const root = path16.parse(current).root;
+  let current = path17.resolve(startDir);
+  const root = path17.parse(current).root;
   while (true) {
-    const gitPath = path16.join(current, ".git");
-    const m1Path = path16.join(current, "memoraone.m1");
+    const gitPath = path17.join(current, ".git");
+    const m1Path = path17.join(current, "memoraone.m1");
     if (await pathExists4(gitPath) || await pathExists4(m1Path)) {
       return current;
     }
     if (current === root) {
       return null;
     }
-    current = path16.dirname(current);
+    current = path17.dirname(current);
   }
 }
 function stripLeadingLineComments3(text) {
@@ -3888,16 +4017,44 @@ function mcpJsonHeader() {
 function buildVscodeMcpJsonBody(existing, options = {}) {
   const base = existing && typeof existing === "object" ? { ...existing } : { servers: {} };
   const servers = typeof base.servers === "object" && base.servers !== null && !Array.isArray(base.servers) ? { ...base.servers } : {};
+  delete servers.memoraone;
   servers.memoraone = buildMemoraoneMcpServer("copilot-vscode", options);
   const merged = { ...base, servers };
   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(
+    dir,
+    `.${path17.basename(filePath)}.${process.pid}.${(0, import_node_crypto5.randomBytes)(8).toString("hex")}.tmp`
+  );
+  try {
+    await fs13.writeFile(tmpPath, content, "utf8");
+    await fs13.rename(tmpPath, filePath);
+  } catch (err) {
+    try {
+      await fs13.unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+var SharedMcpJsonParseError = class extends Error {
+  constructor(configPath) {
+    super(
+      `[setup-ide-files] Invalid JSON in shared MCP config (file preserved, not modified): ${configPath}. Fix or remove the file, then re-run setup-ide-files.`
+    );
+    this.name = "SharedMcpJsonParseError";
+    this.configPath = configPath;
+  }
+};
 function buildCursorMcpJsonBody(existing, writeOptions) {
   const merged = mergeCursorRepoMcpConfigObject(existing, writeOptions);
   return mcpJsonHeader() + JSON.stringify(merged, null, 2) + "\n";
 }
 async function writeManagedMarkdown(repoRoot, relPath, fullContent, opts) {
-  const abs = path16.join(repoRoot, relPath);
+  const abs = path17.join(repoRoot, relPath);
   assertUnderRepoRoot(repoRoot, abs);
   let prior = "";
   let existed = false;
@@ -3909,25 +4066,25 @@ async function writeManagedMarkdown(repoRoot, relPath, fullContent, opts) {
   }
   if (!existed) {
     if (opts.dryRun) return "created";
-    await fs13.mkdir(path16.dirname(abs), { recursive: true });
+    await fs13.mkdir(path17.dirname(abs), { recursive: true });
     await fs13.writeFile(abs, fullContent, "utf8");
     return "created";
   }
   if (prior.includes(MANAGED_MARKER)) {
     if (prior === fullContent) return "skipped";
     if (opts.dryRun) return "updated";
-    await fs13.mkdir(path16.dirname(abs), { recursive: true });
+    await fs13.mkdir(path17.dirname(abs), { recursive: true });
     await fs13.writeFile(abs, fullContent, "utf8");
     return "updated";
   }
   if (!opts.force) return "skipped-untracked";
   if (opts.dryRun) return "updated";
-  await fs13.mkdir(path16.dirname(abs), { recursive: true });
+  await fs13.mkdir(path17.dirname(abs), { recursive: true });
   await fs13.writeFile(abs, fullContent, "utf8");
   return "updated";
 }
 async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
-  const abs = path16.join(repoRoot, relPath);
+  const abs = path17.join(repoRoot, relPath);
   assertUnderRepoRoot(repoRoot, abs);
   let raw = "";
   let existed = false;
@@ -3940,24 +4097,24 @@ async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
   if (!existed) {
     const body = buildBody(null);
     if (opts.dryRun) return "created";
-    await fs13.mkdir(path16.dirname(abs), { recursive: true });
-    await fs13.writeFile(abs, body, "utf8");
+    await writeSharedMcpJsonAtomic(abs, body);
     return "created";
   }
   const managed = raw.includes(MANAGED_MARKER);
   if (!managed && !opts.force) return "skipped-untracked";
-  let parsed2 = null;
+  let parsed2;
   try {
     parsed2 = JSON.parse(stripLeadingLineComments3(raw));
   } catch {
-    parsed2 = null;
+    throw new SharedMcpJsonParseError(abs);
+  }
+  if (!parsed2 || typeof parsed2 !== "object" || Array.isArray(parsed2)) {
+    throw new SharedMcpJsonParseError(abs);
   }
-  if (!parsed2 && !opts.force) return "skipped-untracked";
   const next = buildBody(parsed2);
   if (managed && next === raw) return "skipped";
   if (opts.dryRun) return "updated";
-  await fs13.mkdir(path16.dirname(abs), { recursive: true });
-  await fs13.writeFile(abs, next, "utf8");
+  await writeSharedMcpJsonAtomic(abs, next);
   return "updated";
 }
 function parseSetupIdeFlags(argv) {
@@ -4052,18 +4209,17 @@ function parseSetupIdeFlags(argv) {
     flagError
   };
 }
-async function resolveSetupApiUrl(o, repoRoot, localOrDev) {
-  if (o.apiUrl) return normalizeApiUrl(o.apiUrl);
-  if (!localOrDev) return void 0;
+async function resolveSetupApiUrl(o, repoRoot) {
+  if (o.apiUrl) return normalizeApiUrl2(o.apiUrl);
   const binding = await findBindingRecordByWorkspaceRoot(repoRoot, o.homeDir);
-  if (binding?.apiUrl) return normalizeApiUrl(binding.apiUrl);
+  if (binding?.apiUrl) return normalizeApiUrl2(binding.apiUrl);
   return void 0;
 }
 async function persistBindingApiUrl(repoRoot, apiUrl, homeDir, dryRun) {
   if (dryRun) return;
   const binding = await findBindingRecordByWorkspaceRoot(repoRoot, homeDir);
   if (!binding) return;
-  const normalized = normalizeApiUrl(apiUrl);
+  const normalized = normalizeApiUrl2(apiUrl);
   if (binding.apiUrl === normalized) return;
   await writeBindingRecord(
     {
@@ -4238,7 +4394,7 @@ async function runSetupIdeFiles(o) {
   const outcomes = {};
   let cursorMcp;
   let jetbrainsMcp;
-  const repoRoot = o.workspaceRoot !== void 0 && o.workspaceRoot !== "" ? path16.resolve(o.workspaceRoot) : await findRepoRoot(o.cwd);
+  const repoRoot = o.workspaceRoot !== void 0 && o.workspaceRoot !== "" ? path17.resolve(o.workspaceRoot) : await findRepoRoot(o.cwd);
   if (!repoRoot) {
     return {
       exitCode: 1,
@@ -4274,12 +4430,13 @@ async function runSetupIdeFiles(o) {
   });
   const cursorEnvironment = o.cursorEnvironment ?? "production";
   const localOrDev = cursorEnvironment === "local" || Boolean(o.devMode);
-  const resolvedApiUrl2 = await resolveSetupApiUrl(o, repoRoot, localOrDev);
+  const npmPackageChannel = o.npmPackageChannel ?? npmPackageChannelFromEnvironment(cursorEnvironment);
+  const resolvedApiUrl2 = await resolveSetupApiUrl(o, repoRoot);
   const effectiveApiUrl = resolveIdeApiUrl({
     environment: localOrDev ? "local" : cursorEnvironment,
     apiUrl: resolvedApiUrl2
   });
-  if (localOrDev && !o.dryRun) {
+  if (!o.dryRun && resolvedApiUrl2) {
     await persistBindingApiUrl(repoRoot, effectiveApiUrl, o.homeDir, o.dryRun);
   }
   const cursorContent = `---
@@ -4324,7 +4481,8 @@ description: MemoraOne MCP \u2014 IDE agent instructions
       npxPath: npxPath ?? void 0,
       cliPath,
       repoRoot,
-      apiUrl: resolvedApiUrl2
+      apiUrl: resolvedApiUrl2,
+      npmPackageChannel
     };
     outcomes[".cursor/rules/memoraone-mcp.mdc"] = await writeManagedMarkdown(
       repoRoot,
@@ -4332,12 +4490,22 @@ description: MemoraOne MCP \u2014 IDE agent instructions
       cursorContent,
       { force: o.force, dryRun: o.dryRun }
     );
-    outcomes[".cursor/mcp.json"] = await writeIdeMcpJson(
-      repoRoot,
-      ".cursor/mcp.json",
-      (existing) => buildCursorMcpJsonBody(existing, cursorWriteOptions),
-      { force: o.force, dryRun: o.dryRun }
-    );
+    try {
+      outcomes[".cursor/mcp.json"] = await writeIdeMcpJson(
+        repoRoot,
+        ".cursor/mcp.json",
+        (existing) => buildCursorMcpJsonBody(existing, cursorWriteOptions),
+        { force: o.force, dryRun: o.dryRun }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        exitCode: 1,
+        repoRoot,
+        outcomes,
+        error: message
+      };
+    }
     const repoConfigPath = getCursorRepoMcpConfigPath(repoRoot);
     const repoOutcome = outcomes[".cursor/mcp.json"] ?? "skipped";
     let globalConfigPath;
@@ -4386,7 +4554,7 @@ description: MemoraOne MCP \u2014 IDE agent instructions
     };
   }
   if (o.targets.vscode) {
-    const vscodeEnvironment = localOrDev ? "local" : "production";
+    const vscodeEnvironment = localOrDev ? "local" : cursorEnvironment === "staging" ? "staging" : "production";
     let vscodeCliPath;
     if (vscodeEnvironment === "local") {
       let resolvedCliPath = o.cursorLocalCliPathOverride;
@@ -4407,20 +4575,32 @@ description: MemoraOne MCP \u2014 IDE agent instructions
       }
       vscodeCliPath = resolvedCliPath;
     }
-    outcomes[".vscode/mcp.json"] = await writeIdeMcpJson(
-      repoRoot,
-      ".vscode/mcp.json",
-      (existing) => buildVscodeMcpJsonBody(existing, {
-        environment: vscodeEnvironment,
-        apiUrl: resolvedApiUrl2,
-        cliPath: vscodeCliPath,
-        workspaceRoot: vscodeEnvironment === "local" ? repoRoot : void 0
-      }),
-      {
-        force: o.force,
-        dryRun: o.dryRun
-      }
-    );
+    try {
+      outcomes[".vscode/mcp.json"] = await writeIdeMcpJson(
+        repoRoot,
+        ".vscode/mcp.json",
+        (existing) => buildVscodeMcpJsonBody(existing, {
+          environment: vscodeEnvironment,
+          apiUrl: resolvedApiUrl2,
+          cliPath: vscodeCliPath,
+          workspaceRoot: vscodeEnvironment === "local" ? repoRoot : void 0,
+          npmPackageChannel
+        }),
+        {
+          force: o.force,
+          dryRun: o.dryRun
+        }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        exitCode: 1,
+        repoRoot,
+        outcomes,
+        cursorMcp,
+        error: message
+      };
+    }
     outcomes[".github/copilot-instructions.md"] = await writeManagedMarkdown(
       repoRoot,
       ".github/copilot-instructions.md",
@@ -4443,8 +4623,11 @@ description: MemoraOne MCP \u2014 IDE agent instructions
         repoRoot,
         globalConfigPath: activePath,
         dryRun: o.dryRun,
-        // Connect/local repair passes --dev so JetBrains gets the same backend URL + local CLI.
-        devMode: o.devMode,
+        // 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,
@@ -4511,6 +4694,7 @@ async function cliSetupIdeFiles(argv, options = {}) {
     stdinIsTty,
     env: env2
   });
+  const cursorEnvironment = cursorEnvironmentFromFlags(local, staging);
   const result = await runSetupIdeFiles({
     cwd: cwd2,
     workspaceRoot,
@@ -4520,7 +4704,8 @@ async function cliSetupIdeFiles(argv, options = {}) {
     noGitignore: options.setupOverrides?.noGitignore ?? noGitignore,
     devMode,
     repair,
-    cursorEnvironment: cursorEnvironmentFromFlags(local, staging),
+    cursorEnvironment,
+    npmPackageChannel: npmPackageChannelFromEnvironment(cursorEnvironment),
     apiUrl,
     ...options.setupOverrides
   });
@@ -4591,16 +4776,16 @@ async function cliSetupIdeFiles(argv, options = {}) {
 }
 
 // src/localState/connectCommand.ts
-var path19 = __toESM(require("path"), 1);
+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 path17 = __toESM(require("path"), 1);
+var path18 = __toESM(require("path"), 1);
 var dotenv = __toESM(require("dotenv"), 1);
 var import_v4 = require("zod/v4");
-var dotenvPath = path17.resolve(process2.cwd(), ".env");
+var dotenvPath = path18.resolve(process2.cwd(), ".env");
 if (fs14.existsSync(dotenvPath)) {
   try {
     dotenv.config({ path: dotenvPath });
@@ -4669,7 +4854,7 @@ var config2 = {
 
 // src/repoFingerprint.ts
 var fs15 = __toESM(require("fs"), 1);
-var path18 = __toESM(require("path"), 1);
+var path19 = __toESM(require("path"), 1);
 var crypto2 = __toESM(require("crypto"), 1);
 var parseBooleanFlag3 = (value) => {
   if (!value) {
@@ -4708,7 +4893,7 @@ var resolveGitDir = (gitPath) => {
       const match = content.match(/^gitdir:\s*(.+)$/m);
       if (match) {
         const gitDir = match[1].trim();
-        return path18.resolve(path18.dirname(gitPath), gitDir);
+        return path19.resolve(path19.dirname(gitPath), gitDir);
       }
     }
   } catch {
@@ -4717,16 +4902,16 @@ var resolveGitDir = (gitPath) => {
   return null;
 };
 var findGitRoot = (start) => {
-  let current = path18.resolve(start);
+  let current = path19.resolve(start);
   while (true) {
-    const gitPath = path18.join(current, ".git");
+    const gitPath = path19.join(current, ".git");
     if (fs15.existsSync(gitPath)) {
       const gitDir = resolveGitDir(gitPath);
       if (gitDir) {
         return { gitRoot: current, gitDir };
       }
     }
-    const parent = path18.dirname(current);
+    const parent = path19.dirname(current);
     if (parent === current) {
       break;
     }
@@ -4735,7 +4920,7 @@ var findGitRoot = (start) => {
   return null;
 };
 var readOriginRemote = (gitDir) => {
-  const configPath = path18.join(gitDir, "config");
+  const configPath = path19.join(gitDir, "config");
   try {
     const content = fs15.readFileSync(configPath, "utf8");
     const lines = content.split(/\r?\n/);
@@ -4761,7 +4946,7 @@ var readOriginRemote = (gitDir) => {
 function resolveRepoFingerprint(cwd2) {
   const found = findGitRoot(cwd2);
   if (!found) {
-    const fallbackPath = path18.resolve(cwd2);
+    const fallbackPath = path19.resolve(cwd2);
     const fingerprint2 = sha256(fallbackPath);
     debugLog(`repo fingerprint=${fingerprint2} source=path-fallback`);
     return {
@@ -4783,7 +4968,7 @@ function resolveRepoFingerprint(cwd2) {
       source: "git-remote"
     };
   }
-  const fingerprint = sha256(path18.resolve(gitRoot));
+  const fingerprint = sha256(path19.resolve(gitRoot));
   debugLog(`repo fingerprint=${fingerprint} source=path-fallback`);
   return {
     fingerprint,
@@ -4809,16 +4994,32 @@ function normalizeGitRemote(remoteUrl) {
   normalized = normalized.replace(/\/+$/, "");
   return normalized.toLowerCase() || null;
 }
-function formatIdeSetupRepairHint(workspaceRoot, cliPath) {
-  const cli = cliPath ?? "<path-to-packages/mcp/dist/cli.cjs>";
-  return `Repair with (no new connect code): node ${cli} setup-ide-files --all --local --dev --force --workspace-root ${workspaceRoot}`;
-}
 async function runConnectCommand(options) {
   const code = normalizeConnectCode(options.code);
-  const cwd2 = path19.resolve(options.cwd ?? process.cwd());
+  const cwd2 = path20.resolve(options.cwd ?? process.cwd());
   const apiUrl = (options.apiUrl ?? config2.apiUrl).replace(/\/+$/, "");
   const homeDir = options.homeDir ?? os7.homedir();
   const environment = "local";
+  const executionMode = await resolvePackageExecutionMode({
+    executionMode: options.executionMode,
+    // Only honor an explicit caller cliPath; never auto-resolve before mode detection
+    // (published installs must not be forced into local monorepo mode).
+    cliPath: options.cliPath,
+    apiUrl,
+    scriptPath: options.scriptPath,
+    env: options.env,
+    resolveBuiltCliPath: resolveBuiltCliPathAsync
+  });
+  let resolvedMode = executionMode;
+  if (resolvedMode.kind === "local" && !resolvedMode.cliPath) {
+    const cliPath = await resolveBuiltCliPathAsync();
+    if (!cliPath) {
+      throw new Error(
+        "[memoraone-mcp] Local connect requires a built CLI at packages/mcp/dist/cli.cjs. Run pnpm build first."
+      );
+    }
+    resolvedMode = { kind: "local", cliPath };
+  }
   const ensured = await ensureRepositoryBindingForRoot(cwd2, {
     homeDir,
     identityDeps: options.identityDeps,
@@ -4826,7 +5027,7 @@ async function runConnectCommand(options) {
   });
   if (ensured.legacyM1WarningPath) {
     process.stderr.write(
-      `[memoraone-mcp] warning: ignoring legacy ${path19.basename(ensured.legacyM1WarningPath)} at ${ensured.legacyM1WarningPath} (credentials and binding are package-managed)
+      `[memoraone-mcp] warning: ignoring legacy ${path20.basename(ensured.legacyM1WarningPath)} at ${ensured.legacyM1WarningPath} (credentials and binding are package-managed)
 `
     );
   }
@@ -4902,7 +5103,7 @@ async function runConnectCommand(options) {
   if (options.configureIdes !== false) {
     const targets = { cursor: true, vscode: true, jetbrains: true };
     const setup = options.setupIdeFiles ?? runSetupIdeFiles;
-    const cliPath = options.cliPath !== void 0 ? options.cliPath : await resolveBuiltCliPathAsync();
+    const modeSetup = setupOptionsFromPackageExecutionMode(resolvedMode);
     let setupResult;
     try {
       setupResult = await setup({
@@ -4915,12 +5116,9 @@ async function runConnectCommand(options) {
         noGitignore: true,
         skipDaemonCleanup: true,
         homeDir,
-        cursorEnvironment: "local",
-        devMode: true,
-        // Propagate the same backend endpoint used for redeem into all IDE configs.
+        // Propagate the redeemed binding API URL (backend only — not execution mode).
         apiUrl,
-        cursorLocalCliPathOverride: cliPath,
-        cliPathOverride: cliPath,
+        ...modeSetup,
         ...options.setupIdeOptions
       });
     } catch (err) {
@@ -4934,7 +5132,7 @@ async function runConnectCommand(options) {
     }
     if (setupResult.exitCode !== 0) {
       const detail = setupResult.error ?? "unknown IDE setup error";
-      const repair = formatIdeSetupRepairHint(cwd2, cliPath);
+      const repair = formatIdeSetupRepairHint(cwd2, resolvedMode);
       return {
         exitCode: 1,
         repositoryBindingId: ensured.repositoryBindingId,
@@ -4944,6 +5142,7 @@ async function runConnectCommand(options) {
         createdBinding: ensured.created,
         legacyM1WarningPath: ensured.legacyM1WarningPath,
         ideSetupError: detail,
+        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}`
       };
     }
@@ -4956,6 +5155,7 @@ async function runConnectCommand(options) {
     recovered: redeemed.recovered,
     createdBinding: ensured.created,
     legacyM1WarningPath: ensured.legacyM1WarningPath,
+    executionMode: resolvedMode,
     message: baseSuccess
   };
 }