@memoraone/mcp 0.1.33 → 0.1.35

package/dist/cli.cjs

@@ -30,7 +30,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.33",
+      version: "0.1.35",
       type: "module",
       main: "dist/index.cjs",
       bin: {
@@ -58,8 +58,8 @@ var require_package = __commonJS({
         zod: "^4.0.0"
       },
       devDependencies: {
-        tsx: "^4.21.0",
         tsup: "^8.5.1",
+        tsx: "^4.21.0",
         typescript: "^5.9.2"
       }
     };
@@ -68,8 +68,8 @@ var require_package = __commonJS({
 
 // src/bridgeProxy.ts
 var net = __toESM(require("net"), 1);
-var readline2 = __toESM(require("readline"), 1);
-var import_node_child_process = require("child_process");
+var readline3 = __toESM(require("readline"), 1);
+var import_node_child_process3 = require("child_process");
 
 // src/bindingIdentity.ts
 var crypto = __toESM(require("crypto"), 1);
@@ -84,7 +84,9 @@ function hashBindingIdentity(projectId, workspaceRoot, ideType) {
   return crypto.createHash("sha256").update(input2).digest("hex").slice(0, BINDING_SOCKET_HASH_LENGTH);
 }
 function bindingsMatch(a, b) {
-  return a.projectId.trim().toLowerCase() === b.projectId.trim().toLowerCase() && path.resolve(a.workspaceRoot) === path.resolve(b.workspaceRoot) && path.resolve(a.m1Path) === path.resolve(b.m1Path);
+  const envA = a.environment ?? void 0;
+  const envB = b.environment ?? void 0;
+  return a.projectId.trim().toLowerCase() === b.projectId.trim().toLowerCase() && path.resolve(a.workspaceRoot) === path.resolve(b.workspaceRoot) && path.resolve(a.m1Path) === path.resolve(b.m1Path) && (a.apiKey ?? null) === (b.apiKey ?? null) && envA === envB;
 }
 function formatMissingInitializeWorkspaceError(options) {
   const lines = [
@@ -119,6 +121,10 @@ var path4 = __toESM(require("path"), 1);
 var fs = __toESM(require("fs/promises"), 1);
 var path2 = __toESM(require("path"), 1);
 var uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var CANONICAL_M1_FILENAME = "memoraone.m1";
+function isCanonicalM1Path(m1Path) {
+  return path2.basename(m1Path) === CANONICAL_M1_FILENAME;
+}
 function normalizeEnvironment(raw) {
   if (raw === void 0 || raw === null || typeof raw !== "string") {
     return void 0;
@@ -165,7 +171,7 @@ async function resolveProjectIdFromExplicitM1Path() {
 async function findM1WalkingUp(workspaceRoot) {
   let current = path2.resolve(workspaceRoot);
   while (true) {
-    const markerPath = path2.join(current, "memoraone.m1");
+    const markerPath = path2.join(current, CANONICAL_M1_FILENAME);
     try {
       const content = await fs.readFile(markerPath, "utf8");
       const { projectId, apiKey, environment } = parseAndValidateM1(content, markerPath);
@@ -272,6 +278,45 @@ async function resolveAuthoritativeBinding(workspaceRoot, options = {}) {
   }
   return bindings[0];
 }
+function bindingRelevantValuesMatch(a, b) {
+  const envA = a.environment ?? void 0;
+  const envB = b.environment ?? void 0;
+  return a.projectId.trim().toLowerCase() === b.projectId.trim().toLowerCase() && path2.resolve(a.workspaceRoot) === path2.resolve(b.workspaceRoot) && path2.resolve(a.m1Path) === path2.resolve(b.m1Path) && (a.apiKey ?? null) === (b.apiKey ?? null) && envA === envB;
+}
+async function reconcileResolvedBindingWithDisk(cached) {
+  const m1Path = path2.resolve(cached.m1Path);
+  if (cached.bindingSource !== "explicit-m1-path" && !isCanonicalM1Path(m1Path)) {
+    throw new Error(
+      `[memoraone-mcp] Cached binding m1Path is not the canonical ${CANONICAL_M1_FILENAME}: ${m1Path}`
+    );
+  }
+  let content;
+  try {
+    content = await fs.readFile(m1Path, "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      throw new Error(
+        `[memoraone-mcp] Cached binding file missing at ${m1Path}. Open a folder containing ${CANONICAL_M1_FILENAME}.`
+      );
+    }
+    throw err;
+  }
+  const parsed = parseAndValidateM1(content, m1Path);
+  const resolved = resolveApiKeyWithSource(parsed.apiKey);
+  const fresh = {
+    projectId: parsed.projectId,
+    workspaceRoot: path2.resolve(path2.dirname(m1Path)),
+    m1Path,
+    apiKey: resolved.apiKey,
+    ...parsed.environment !== void 0 ? { environment: parsed.environment } : {},
+    bindingSource: cached.bindingSource,
+    apiKeySource: resolved.apiKeySource
+  };
+  if (bindingRelevantValuesMatch(cached, fresh)) {
+    return { binding: fresh, cacheRefreshed: false };
+  }
+  return { binding: fresh, cacheRefreshed: true };
+}
 function encodeResolvedBinding(binding) {
   return Buffer.from(JSON.stringify(binding), "utf8").toString("base64");
 }
@@ -444,6 +489,29 @@ function readBindingSidecarRecord(socketPath) {
     return null;
   }
 }
+function readBindingSidecar(socketPath) {
+  const record = readBindingSidecarRecord(socketPath);
+  if (!record) {
+    return null;
+  }
+  return decodeResolvedBinding(record.binding);
+}
+function removeBindingSidecar(socketPath) {
+  try {
+    fs3.unlinkSync(bindingSidecarPath(socketPath));
+  } catch {
+  }
+}
+function removeDaemonSocketArtifacts(socketPath) {
+  removeBindingSidecar(socketPath);
+  try {
+    fs3.unlinkSync(socketPath);
+  } catch {
+  }
+}
+function isDaemonBindingMismatchError(err) {
+  return err instanceof Error && err.message.includes("Daemon socket binding mismatch");
+}
 function formatBindingMismatchError(socketPath, sidecar, expected, detail) {
   const lines = [
     `[memoraone-mcp] Daemon socket binding mismatch at ${path4.basename(socketPath)}.`,
@@ -453,7 +521,7 @@ function formatBindingMismatchError(socketPath, sidecar, expected, detail) {
   if (detail) {
     lines.push(`  ${detail}`);
   }
-  lines.push("Reload MCP in this IDE window or run memoraone-mcp cleanup for the stale socket.");
+  lines.push("The bridge will replace this stale daemon automatically from the current memoraone.m1.");
   return lines.join("\n");
 }
 function verifyDaemonSidecarBinding(socketPath, expected, env = process.env) {
@@ -635,6 +703,21 @@ async function requestClientRootsListUris(options) {
   }
 }
 
+// src/cleanup.ts
+var fs5 = __toESM(require("fs/promises"), 1);
+var path7 = __toESM(require("path"), 1);
+var readline2 = __toESM(require("readline/promises"), 1);
+var import_node_child_process2 = require("child_process");
+var import_node_util2 = require("util");
+var import_node_process = require("process");
+
+// src/cursorGlobalMcpConfig.ts
+var fs4 = __toESM(require("fs/promises"), 1);
+var os2 = __toESM(require("os"), 1);
+var path6 = __toESM(require("path"), 1);
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+
 // src/initializeBinding.ts
 var path5 = __toESM(require("path"), 1);
 var import_node_url = require("url");
@@ -802,1112 +885,1223 @@ async function resolveBindingFromInitializeParams(params, options = {}) {
   });
 }
 
-// src/bridgeProxy.ts
-var defaultLog = (msg) => {
-  process.stderr.write(`[memoraone-mcp][bridge] ${msg}
-`);
-};
-function summarizeJsonRpcMethod(line) {
-  try {
-    const message = JSON.parse(line.trim());
-    if (typeof message.method === "string") {
-      return message.method;
-    }
-    if (message.id !== void 0) {
-      return `response:id=${String(message.id)}`;
+// src/cursorGlobalMcpConfig.ts
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.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 cursorMcpApiUrl(environment) {
+  if (environment === "local") return MEMORAONE_LOCAL_API_URL;
+  if (environment === "staging") return MEMORAONE_STAGING_API_URL;
+  return MEMORAONE_PROD_API_URL;
+}
+function buildMemoraoneCursorMcpServer(options) {
+  const env = {
+    MEMORAONE_API_URL: cursorMcpApiUrl(options.environment),
+    MEMORAONE_IDE_TYPE: "cursor"
+  };
+  if (options.workspaceRoot !== void 0) {
+    env[MEMORAONE_WORKSPACE_ROOT_ENV] = path6.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.");
     }
-    return "jsonrpc";
+    return {
+      command: "node",
+      args: [options.cliPath],
+      env
+    };
+  }
+  if (!options.npxPath) {
+    throw new Error("[setup-ide-files] Cursor MCP config requires a resolved npx path.");
+  }
+  return {
+    command: options.npxPath,
+    args: ["-y", "@memoraone/mcp@latest"],
+    env
+  };
+}
+async function pathExists(filePath) {
+  try {
+    await fs4.access(filePath);
+    return true;
   } catch {
-    return "invalid-json";
+    return false;
   }
 }
-function connectWithRetry(socketPath, log, maxRetries, retryDelayMs, connect2) {
-  return new Promise((resolve9, reject) => {
-    const tryConnect = (attempt) => {
-      connect2(socketPath).then(resolve9).catch((err) => {
-        if (attempt >= maxRetries) {
-          reject(err);
-          return;
-        }
-        log(`connect attempt ${attempt + 1} failed, retrying in ${retryDelayMs}ms: ${String(err)}`);
-        setTimeout(() => tryConnect(attempt + 1), retryDelayMs);
-      });
+function stripLeadingLineComments(text) {
+  return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
+}
+function getKnownCursorGlobalMcpConfigCandidates(homeDir) {
+  return [path6.join(homeDir, ".cursor", "mcp.json")];
+}
+async function detectCursorGlobalMcpConfig(options) {
+  if (options?.explicitPath) {
+    return { ok: true, path: options.explicitPath, detectedExisting: await pathExists(options.explicitPath) };
+  }
+  const homeDir = options?.homeDir ?? os2.homedir();
+  const candidates = getKnownCursorGlobalMcpConfigCandidates(homeDir);
+  const existing = [];
+  for (const candidate of candidates) {
+    if (await pathExists(candidate)) existing.push(candidate);
+  }
+  if (existing.length > 1) {
+    return {
+      ok: false,
+      error: "[setup-ide-files] Multiple Cursor global MCP config paths found. Specify one explicitly.",
+      candidates: existing
     };
-    tryConnect(0);
-  });
+  }
+  if (existing.length === 1) {
+    return { ok: true, path: existing[0], detectedExisting: true };
+  }
+  const defaultPath = candidates[0];
+  if (!defaultPath) {
+    return {
+      ok: false,
+      error: "[setup-ide-files] No known Cursor global MCP config path.",
+      candidates: []
+    };
+  }
+  return { ok: true, path: defaultPath, detectedExisting: false };
 }
-async function resolveBridgeSessionBinding(params, env = process.env, options = {}) {
-  const bridgeOptions = getBridgeBindingResolveOptions(env);
-  return resolveBindingFromInitializeParams(params, {
-    env,
-    fallbackWorkspaceRoots: getEnvWorkspaceRootCandidates(),
-    rootsListUris: options.rootsListUris,
-    rootsListAttempted: options.rootsListAttempted,
-    ...bridgeOptions
-  });
+function formatBackupTimestamp(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())}`;
 }
-async function connectOrSpawnDaemonForBinding(binding, opts) {
-  const socketPath = getBindingSocketPath(binding, opts.env);
-  opts.log(
-    `target daemon socket=${socketPath} project=${binding.projectId} workspace=${binding.workspaceRoot}`
-  );
-  let socket;
+async function isWorkingNpx(npxPath) {
   try {
-    socket = await connectWithRetry(
-      socketPath,
-      opts.log,
-      opts.maxRetries,
-      opts.retryDelayMs,
-      opts.connect
-    );
-    verifyDaemonSidecarBinding(socketPath, binding, opts.env);
-    opts.log("reusing running daemon for session binding");
-    return socket;
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("Daemon socket binding mismatch")) {
-      throw err;
+    if (!await pathExists(npxPath)) return false;
+    if (process.platform !== "win32") {
+      try {
+        await fs4.access(npxPath, fs4.constants.X_OK);
+      } catch {
+        return false;
+      }
     }
+    await execFileAsync(npxPath, ["--version"], { timeout: 1e4 });
+    return true;
+  } catch {
+    return false;
   }
-  opts.log("daemon not running, spawning...");
-  await opts.spawnDaemon(binding, socketPath);
-  await new Promise((r) => setTimeout(r, opts.retryDelayMs));
-  socket = await connectWithRetry(
-    socketPath,
-    opts.log,
-    opts.maxRetries,
-    opts.retryDelayMs,
-    opts.connect
-  );
-  verifyDaemonSidecarBinding(socketPath, binding, opts.env);
-  return socket;
 }
-var BridgeDaemonRouter = class {
-  constructor(options) {
-    this.activeSocket = null;
-    this.activeBinding = null;
-    this.socketLineReader = null;
-    this.lastInitializeLine = null;
-    this.pendingDeferredClientLines = [];
-    this.handshakeDeferredClientLines = [];
-    this.clientInitializeSeen = false;
-    this.env = options.env ?? process.env;
-    this.stdout = options.stdout ?? process.stdout;
-    this.log = options.log ?? defaultLog;
-    this.cliPath = options.cliPath;
-    this.maxRetries = options.maxRetries ?? 5;
-    this.retryDelayMs = options.retryDelayMs ?? 200;
-    this.lineReader = options.lineReader ?? null;
-    this.connectImpl = options.connect ?? ((socketPath) => new Promise((resolve9, reject) => {
-      const socket = net.connect(socketPath, () => resolve9(socket));
-      socket.on("error", reject);
-    }));
-    this.spawnDaemonImpl = options.spawnDaemon ?? (async (binding) => {
-      const child = (0, import_node_child_process.spawn)(
-        process.execPath,
-        buildDaemonSpawnArgs(this.cliPath, binding.projectId, this.env),
-        {
-          detached: true,
-          stdio: "ignore",
-          env: {
-            ...this.env,
-            MEMORAONE_DAEMON_BINDING_B64: encodeResolvedBinding(binding)
-          }
-        }
-      );
-      child.on("exit", (code, signal) => {
-        logInitializeDebug(
-          this.log,
-          this.env,
-          `spawned daemon exit code=${code ?? "null"} signal=${signal ?? "null"} project=${binding.projectId}`
-        );
-      });
-      child.unref();
-    });
-  }
-  getActiveBinding() {
-    return this.activeBinding;
+async function resolveNpxPath() {
+  const npxName = process.platform === "win32" ? "npx.cmd" : "npx";
+  const candidates = [];
+  if (process.platform === "darwin") {
+    candidates.push("/opt/homebrew/bin/npx", "/usr/local/bin/npx");
+  } else if (process.platform === "linux") {
+    candidates.push("/usr/local/bin/npx");
   }
-  hasClientInitialize() {
-    return this.clientInitializeSeen;
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  for (const dir of (process.env.PATH ?? "").split(pathSep)) {
+    if (!dir) continue;
+    candidates.push(path6.join(dir, npxName));
   }
-  async ensureDaemonForInitialize(params) {
-    logInitializeDebug(
-      this.log,
-      this.env,
-      `initialize payload: ${summarizeInitializeParamsForDebug(params)}`
-    );
-    const bridgeOptions = getBridgeBindingResolveOptions(this.env);
-    const initializeRoots = extractWorkspaceRootsFromInitialize(params);
-    let rootsListUris;
-    let rootsListAttempted = false;
-    const repoHint = getRepoScopedWorkspaceHint(this.env);
-    if (initializeRoots.length === 0 && bridgeOptions.allowEnvWorkspaceFallback === false && repoHint === null) {
-      if (!this.lineReader) {
-        throw new Error(
-          "[memoraone-mcp] Internal error: Cursor workspace binding requires stdin line reader for roots/list"
-        );
-      }
-      rootsListAttempted = true;
-      this.log("initialize lacks workspace roots; requesting roots/list from Cursor before binding");
-      const rootsListResult = await requestClientRootsListUris({
-        lineReader: this.lineReader,
-        stdout: this.stdout,
-        log: this.log,
-        env: this.env,
-        initializeParams: params
-      });
-      rootsListUris = rootsListResult.uris;
-      if (rootsListResult.deferredLines.length > 0) {
-        this.pendingDeferredClientLines = rootsListResult.deferredLines.slice();
-        logInitializeDebug(
-          this.log,
-          this.env,
-          `queued ${this.pendingDeferredClientLines.length} deferred client line(s) for replay after initialize`
-        );
-      }
-    }
-    const binding = await resolveBridgeSessionBinding(params, this.env, {
-      rootsListUris,
-      rootsListAttempted
-    });
-    const environmentLog = binding.environment !== void 0 ? ` environment=${binding.environment}` : "";
-    this.log(
-      `session binding project=${binding.projectId} workspace=${binding.workspaceRoot} m1=${binding.m1Path} source=${binding.bindingSource} apiKeySource=${binding.apiKeySource}${environmentLog}`
-    );
-    if (this.activeBinding && bindingsMatch(this.activeBinding, binding) && this.activeSocket) {
-      return;
-    }
-    if (this.activeBinding && !bindingsMatch(this.activeBinding, binding)) {
-      this.log(
-        `session binding changed from workspace=${this.activeBinding.workspaceRoot} to workspace=${binding.workspaceRoot}; reconnecting daemon`
-      );
-      this.resetSessionState();
-      this.detachSocketReader();
-      this.activeSocket?.destroy();
-      this.activeSocket = null;
-    }
-    this.activeBinding = binding;
-    await this.connectActiveDaemon();
-    this.log("bridge connected");
+  try {
+    const lookupCmd = process.platform === "win32" ? "where" : "which";
+    const { stdout } = await execFileAsync(lookupCmd, [npxName], { timeout: 5e3 });
+    const first = stdout.trim().split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+    if (first) candidates.unshift(first);
+  } catch {
   }
-  recordClientInitialize(line) {
-    this.lastInitializeLine = line;
-    this.clientInitializeSeen = true;
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const abs = path6.isAbsolute(candidate) ? candidate : path6.resolve(candidate);
+    const key = process.platform === "win32" ? abs.toLowerCase() : abs;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (await isWorkingNpx(abs)) return abs;
   }
-  async forwardInitializeToDaemon(line) {
-    this.recordClientInitialize(line);
-    await this.writeToDaemon(line);
-    logInitializeDebug(this.log, this.env, "initialize replay to daemon");
-    this.log("forwarding active");
+  return null;
+}
+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 } : {};
+  mcpServers.memoraone = buildMemoraoneCursorMcpServer({
+    environment,
+    npxPath: writeOptions.npxPath,
+    cliPath: writeOptions.cliPath,
+    workspaceRoot: writeOptions.repoRoot
+  });
+  return { ...base, mcpServers };
+}
+function isMemoraoneManagedApiUrl(url) {
+  if (typeof url !== "string" || url.length === 0) return false;
+  if (url === MEMORAONE_PROD_API_URL) return true;
+  if (url === MEMORAONE_LOCAL_API_URL) return true;
+  return url.startsWith(MEMORAONE_STAGING_API_URL_PREFIX);
+}
+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;
+  const env = s.env;
+  if (!env || typeof env !== "object") return false;
+  return memoraoneEnvMatchesManagedCleanupShape(env);
+}
+function cursorConfigHasManagedMemoraone(parsed) {
+  if (!parsed || typeof parsed !== "object") return false;
+  const mcpServers = parsed.mcpServers;
+  if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) return false;
+  return isManagedMemoraoneCursorServer(mcpServers.memoraone);
+}
+function memoraoneEnvMatchesManagedCleanupShape(env) {
+  return env.MEMORAONE_IDE_TYPE === "cursor" && isMemoraoneManagedApiUrl(env.MEMORAONE_API_URL);
+}
+function getCursorRepoMcpConfigPath(repoRoot) {
+  return path6.join(repoRoot, ".cursor", "mcp.json");
+}
+async function readCursorMcpConfigObject(configPath) {
+  try {
+    const raw = await fs4.readFile(configPath, "utf8");
+    return JSON.parse(stripLeadingLineComments(raw));
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+    if (code === "ENOENT") return null;
+    throw err;
   }
-  async replayDeferredClientMessages() {
-    if (this.pendingDeferredClientLines.length === 0) {
-      return;
-    }
-    const lines = this.pendingDeferredClientLines.slice();
-    this.pendingDeferredClientLines = [];
-    this.handshakeDeferredClientLines = lines.slice();
-    const types = lines.map((line) => summarizeJsonRpcMethod(line));
-    logInitializeDebug(
-      this.log,
-      this.env,
-      `deferred message replay count=${lines.length} types=${JSON.stringify(types)}`
-    );
-    for (const line of lines) {
-      await this.writeToDaemon(line);
-    }
+}
+async function removeMemoraoneFromCursorGlobalConfig(options) {
+  const { configPath, dryRun } = options;
+  const parsed = await readCursorMcpConfigObject(configPath);
+  if (!parsed || !cursorConfigHasManagedMemoraone(parsed)) {
+    return { changed: false };
   }
-  async writeToDaemon(line) {
-    await this.ensureActiveDaemonSocket();
-    this.activeSocket.write(`${line}
-`);
+  if (dryRun) {
+    return { changed: true, backupPath: `${configPath}.backup-<timestamp>` };
   }
-  resetSessionState() {
-    this.lastInitializeLine = null;
-    this.pendingDeferredClientLines = [];
-    this.handshakeDeferredClientLines = [];
-    this.clientInitializeSeen = false;
-    this.activeBinding = null;
+  const backupPath = `${configPath}.backup-${formatBackupTimestamp()}`;
+  await fs4.copyFile(configPath, backupPath);
+  const mcpServers = typeof parsed.mcpServers === "object" && parsed.mcpServers !== null && !Array.isArray(parsed.mcpServers) ? { ...parsed.mcpServers } : {};
+  delete mcpServers.memoraone;
+  const hasOtherServers = Object.keys(mcpServers).length > 0;
+  if (!hasOtherServers) {
+    await fs4.unlink(configPath);
+    return { changed: true, backupPath };
   }
-  async connectActiveDaemon() {
-    if (!this.activeBinding) {
-      throw new Error("[memoraone-mcp] Internal error: connectActiveDaemon without active binding");
-    }
-    const socket = await connectOrSpawnDaemonForBinding(this.activeBinding, {
-      env: this.env,
-      cliPath: this.cliPath,
-      log: this.log,
-      maxRetries: this.maxRetries,
-      retryDelayMs: this.retryDelayMs,
-      connect: this.connectImpl,
-      spawnDaemon: this.spawnDaemonImpl
-    });
-    this.activeSocket = socket;
-    this.attachSocketReader(socket);
+  const next = { ...parsed, mcpServers };
+  await fs4.mkdir(path6.dirname(configPath), { recursive: true });
+  await fs4.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
+  return { changed: true, backupPath };
+}
+async function auditCursorMcpConfig(options) {
+  const repoRoot = path6.resolve(options?.repoRoot ?? process.cwd());
+  const repoConfigPath = getCursorRepoMcpConfigPath(repoRoot);
+  const globalDetection = await detectCursorGlobalMcpConfig({
+    homeDir: options?.homeDir,
+    explicitPath: options?.explicitGlobalPath
+  });
+  const globalConfigPath = globalDetection.ok ? globalDetection.path : getKnownCursorGlobalMcpConfigCandidates(
+    options?.homeDir ?? os2.homedir()
+  )[0];
+  let repoHasManagedMemoraone = false;
+  try {
+    const repoParsed = await readCursorMcpConfigObject(repoConfigPath);
+    repoHasManagedMemoraone = cursorConfigHasManagedMemoraone(repoParsed);
+  } catch {
+    repoHasManagedMemoraone = false;
   }
-  async ensureActiveDaemonSocket() {
-    if (this.activeSocket && !this.activeSocket.destroyed) {
-      return;
-    }
-    if (!this.clientInitializeSeen || !this.lastInitializeLine || !this.activeBinding) {
-      throw new Error("[memoraone-mcp] MCP request before initialize");
+  let globalHasManagedMemoraone = false;
+  if (globalDetection.ok) {
+    try {
+      const globalParsed = await readCursorMcpConfigObject(globalConfigPath);
+      globalHasManagedMemoraone = cursorConfigHasManagedMemoraone(globalParsed);
+    } catch {
+      globalHasManagedMemoraone = false;
     }
-    this.log("daemon socket unavailable; reconnecting for session binding");
-    await this.connectActiveDaemon();
-    logInitializeDebug(this.log, this.env, "initialize replay to daemon after reconnect");
-    this.activeSocket.write(`${this.lastInitializeLine}
-`);
-    if (this.handshakeDeferredClientLines.length > 0) {
-      const types = this.handshakeDeferredClientLines.map(
-        (deferredLine) => summarizeJsonRpcMethod(deferredLine)
+  }
+  return {
+    repoConfigPath,
+    repoHasManagedMemoraone,
+    globalConfigPath,
+    globalHasManagedMemoraone,
+    conflict: repoHasManagedMemoraone && globalHasManagedMemoraone
+  };
+}
+function logCursorMcpConfigAudit(prefix, audit) {
+  console.log(`${prefix} Cursor MCP config audit:`);
+  console.log(
+    `${prefix}   repo ${audit.repoConfigPath}: managed memoraone=${audit.repoHasManagedMemoraone}`
+  );
+  console.log(
+    `${prefix}   global ${audit.globalConfigPath}: managed memoraone=${audit.globalHasManagedMemoraone}`
+  );
+  if (audit.conflict) {
+    console.warn(
+      `${prefix} WARNING: Both repo and global Cursor MCP define memoraone. Global shared MCP cannot bind per-window repos; remove global memoraone and use repo .cursor/mcp.json only.`
+    );
+  } else if (audit.globalHasManagedMemoraone && !audit.repoHasManagedMemoraone) {
+    console.warn(
+      `${prefix} WARNING: Cursor global MCP has memoraone but this repo lacks .cursor/mcp.json. Global MCP shares one process across windows (first-window-wins roots). Run setup-ide-files --cursor in this repo.`
+    );
+  } else if (audit.repoHasManagedMemoraone && !audit.globalHasManagedMemoraone) {
+    console.log(
+      `${prefix} Cursor MCP is repo-scoped (.cursor/mcp.json) with no global memoraone entry (recommended for multi-repo windows).`
+    );
+  }
+}
+function logCursorMcpCliSummary(info, dryRun, opts) {
+  const { repoConfigPath, repoOutcome, npxPath, cliPath, repoBackupPath, globalConfigPath, globalMemoraoneRemoved, globalBackupPath } = info;
+  const interactive = opts?.forInteractivePostSetup === true;
+  console.log(`[setup-ide-files] Cursor repo MCP config: ${repoConfigPath}`);
+  if (cliPath) {
+    console.log(`[setup-ide-files] Resolved local CLI: ${cliPath}`);
+  } else if (npxPath) {
+    console.log(`[setup-ide-files] Resolved npx: ${npxPath}`);
+  }
+  if (repoBackupPath) {
+    console.log(`[setup-ide-files] Cursor repo MCP config backup: ${repoBackupPath}`);
+  }
+  if (!interactive) {
+    if (repoOutcome === "created") {
+      console.log(
+        dryRun ? `[setup-ide-files] Cursor repo MCP config would be created: ${repoConfigPath}` : `[setup-ide-files] Cursor repo MCP config created: ${repoConfigPath}`
       );
-      logInitializeDebug(
-        this.log,
-        this.env,
-        `deferred message replay after reconnect count=${this.handshakeDeferredClientLines.length} types=${JSON.stringify(types)}`
+    } else if (repoOutcome === "updated") {
+      console.log(
+        dryRun ? `[setup-ide-files] Cursor repo MCP config would be updated: ${repoConfigPath}` : `[setup-ide-files] Cursor repo MCP config updated: ${repoConfigPath}`
       );
-      for (const deferredLine of this.handshakeDeferredClientLines) {
-        this.activeSocket.write(`${deferredLine}
-`);
-      }
+    } else if (repoOutcome === "skipped") {
+      console.log(`[setup-ide-files] Cursor repo MCP config unchanged: ${repoConfigPath}`);
     }
   }
-  attachSocketReader(socket) {
-    this.detachSocketReader();
-    this.socketLineReader = readline2.createInterface({ input: socket, crlfDelay: Infinity });
-    this.socketLineReader.on("line", (line) => {
-      this.stdout.write(`${line}
-`);
-    });
-    socket.on("close", (hadError) => {
-      if (this.activeSocket === socket) {
-        logInitializeDebug(
-          this.log,
-          this.env,
-          `daemon socket closed hadError=${String(hadError)}`
-        );
-        this.log("daemon socket closed; bridge stays alive for reconnect");
-        this.detachSocketReader();
-        this.activeSocket = null;
-      }
-    });
-    socket.on("error", (err) => {
-      this.log(`socket error: ${String(err)}`);
-      logInitializeDebug(this.log, this.env, `daemon socket error: ${String(err)}`);
-      if (this.activeSocket === socket) {
-        this.detachSocketReader();
-        this.activeSocket = null;
-      }
-    });
-  }
-  detachSocketReader() {
-    if (this.socketLineReader) {
-      this.socketLineReader.close();
-      this.socketLineReader = null;
+  if (globalMemoraoneRemoved && globalConfigPath) {
+    console.log(
+      dryRun ? `[setup-ide-files] Would remove memoraone from Cursor global MCP config: ${globalConfigPath}` : `[setup-ide-files] Removed memoraone from Cursor global MCP config: ${globalConfigPath}`
+    );
+    if (globalBackupPath) {
+      console.log(`[setup-ide-files] Cursor global MCP config backup: ${globalBackupPath}`);
     }
+  } else if (globalConfigPath) {
+    console.log(
+      `[setup-ide-files] Cursor global MCP config unchanged (no managed memoraone to remove): ${globalConfigPath}`
+    );
   }
-};
-async function runBridgeProxy(options) {
-  ensureBaseDir();
-  const stdin = options.stdin ?? process.stdin;
-  const stdout = options.stdout ?? process.stdout;
-  const log = options.log ?? defaultLog;
-  const lineReader = options.lineReader ?? new StdioLineReader(stdin);
-  const router = new BridgeDaemonRouter({ ...options, stdout, lineReader });
-  while (true) {
-    const line = await lineReader.readLine();
-    if (line === null) {
-      break;
-    }
-    const trimmed = line.trim();
-    if (trimmed === "") {
-      continue;
-    }
-    let message;
-    try {
-      message = JSON.parse(trimmed);
-    } catch (err) {
-      throw new Error(`[memoraone-mcp] Invalid JSON-RPC on stdin: ${String(err)}`);
-    }
-    if (message.method === "initialize") {
-      log("resolve binding from initialize request before daemon connect");
-      const params = message.params ?? {};
-      await router.ensureDaemonForInitialize(params);
-      await router.forwardInitializeToDaemon(trimmed);
-      await router.replayDeferredClientMessages();
-      continue;
-    }
-    await router.writeToDaemon(trimmed);
+  console.log(
+    "[setup-ide-files] Each Cursor window uses this repo\u2019s .cursor/mcp.json (separate MCP process per repo)."
+  );
+  if (!interactive) {
+    console.log(
+      "[setup-ide-files] Fully quit Cursor and reopen this repo for MCP changes to take effect."
+    );
   }
 }
 
-// src/setupIdeFiles.ts
-var fs8 = __toESM(require("fs/promises"), 1);
-var os4 = __toESM(require("os"), 1);
-var path10 = __toESM(require("path"), 1);
-
 // src/cleanup.ts
-var fs5 = __toESM(require("fs/promises"), 1);
-var path7 = __toESM(require("path"), 1);
-var readline3 = __toESM(require("readline/promises"), 1);
-var import_node_child_process3 = require("child_process");
-var import_node_util2 = require("util");
-var import_node_process = require("process");
-
-// src/cursorGlobalMcpConfig.ts
-var fs4 = __toESM(require("fs/promises"), 1);
-var os2 = __toESM(require("os"), 1);
-var path6 = __toESM(require("path"), 1);
-var import_node_child_process2 = require("child_process");
-var import_node_util = require("util");
-var execFileAsync = (0, import_node_util.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 cursorMcpApiUrl(environment) {
-  if (environment === "local") return MEMORAONE_LOCAL_API_URL;
-  if (environment === "staging") return MEMORAONE_STAGING_API_URL;
-  return MEMORAONE_PROD_API_URL;
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var DAEMON_PROJECT_ID_RE = /--project-id\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+var PROJECT_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var MEMORAONE_MCP_COMMAND_RE = /memoraone-mcp|memoraOne-mcp|@memoraone\/mcp/;
+var CLEANUP_PROJECT_ID_REQUIRED_ERROR = "Provide --project-id <id> or run from a folder containing memoraone.m1.";
+function isMemoraoneMcpCommandLine(commandLine) {
+  return MEMORAONE_MCP_COMMAND_RE.test(commandLine);
 }
-function buildMemoraoneCursorMcpServer(options) {
-  const env = {
-    MEMORAONE_API_URL: cursorMcpApiUrl(options.environment),
-    MEMORAONE_IDE_TYPE: "cursor"
-  };
-  if (options.workspaceRoot !== void 0) {
-    env[MEMORAONE_WORKSPACE_ROOT_ENV] = path6.resolve(options.workspaceRoot);
+function parseDaemonProjectIdFromCommandLine(commandLine) {
+  if (!commandLine.includes("--daemon")) {
+    return null;
   }
-  if (options.environment === "local") {
-    if (!options.cliPath) {
-      throw new Error("[setup-ide-files] Local Cursor MCP config requires a built CLI path.");
-    }
-    return {
-      command: "node",
-      args: [options.cliPath],
-      env
-    };
+  const match = commandLine.match(DAEMON_PROJECT_ID_RE);
+  return match ? match[1].toLowerCase() : null;
+}
+function isDaemonProcessForProject(commandLine, projectId) {
+  if (!isMemoraoneMcpCommandLine(commandLine)) {
+    return false;
   }
-  if (!options.npxPath) {
-    throw new Error("[setup-ide-files] Cursor MCP config requires a resolved npx path.");
+  const normalized = projectId.trim().toLowerCase();
+  if (!commandLine.includes(`--project-id ${normalized}`)) {
+    return false;
   }
-  return {
-    command: options.npxPath,
-    args: ["-y", "@memoraone/mcp@latest"],
-    env
-  };
+  const daemonProjectId = parseDaemonProjectIdFromCommandLine(commandLine);
+  return daemonProjectId !== null && daemonProjectId === normalized;
 }
-async function pathExists(filePath) {
-  try {
-    await fs4.access(filePath);
-    return true;
-  } catch {
+function parseDaemonIdeFromCommandLine(commandLine) {
+  if (!commandLine.includes("--daemon")) {
+    return void 0;
+  }
+  return parseIdeTypeFromCommandLine(commandLine);
+}
+function isDaemonProcessForProjectAndIde(commandLine, projectId, ide) {
+  if (!isDaemonProcessForProject(commandLine, projectId)) {
     return false;
   }
+  const daemonIde = parseDaemonIdeFromCommandLine(commandLine);
+  return daemonIde !== void 0 && daemonIde === ide;
 }
-function stripLeadingLineComments(text) {
-  return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
+function parseDaemonProcessLines(lines) {
+  const processes = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const spaceIdx = trimmed.indexOf(" ");
+    if (spaceIdx <= 0) continue;
+    const pid = Number.parseInt(trimmed.slice(0, spaceIdx), 10);
+    if (!Number.isFinite(pid) || pid <= 0) continue;
+    const command = trimmed.slice(spaceIdx + 1);
+    if (!isMemoraoneMcpCommandLine(command)) continue;
+    const projectId = parseDaemonProjectIdFromCommandLine(command);
+    if (projectId === null) continue;
+    const ide = parseDaemonIdeFromCommandLine(command);
+    processes.push({ pid, command, projectId, ...ide !== void 0 ? { ide } : {} });
+  }
+  return processes;
 }
-function getKnownCursorGlobalMcpConfigCandidates(homeDir) {
-  return [path6.join(homeDir, ".cursor", "mcp.json")];
+function normalizeCleanupProjectId(projectId) {
+  const trimmed = projectId.trim();
+  if (!PROJECT_ID_RE.test(trimmed)) {
+    return { error: `Invalid project id: ${projectId}` };
+  }
+  return trimmed.toLowerCase();
 }
-async function detectCursorGlobalMcpConfig(options) {
-  if (options?.explicitPath) {
-    return { ok: true, path: options.explicitPath, detectedExisting: await pathExists(options.explicitPath) };
+async function defaultListDaemonProcesses() {
+  const { stdout } = await execFileAsync2("ps", ["-eo", "pid=,args="], {
+    maxBuffer: 10 * 1024 * 1024
+  });
+  return parseDaemonProcessLines(stdout.split("\n"));
+}
+async function defaultListSocketPaths(projectId) {
+  const baseDir = getMcpBaseDir();
+  let entries;
+  try {
+    entries = await fs5.readdir(baseDir);
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+    if (code === "ENOENT") {
+      return [];
+    }
+    throw err;
   }
-  const homeDir = options?.homeDir ?? os2.homedir();
-  const candidates = getKnownCursorGlobalMcpConfigCandidates(homeDir);
-  const existing = [];
-  for (const candidate of candidates) {
-    if (await pathExists(candidate)) existing.push(candidate);
+  const paths = [];
+  for (const name of entries) {
+    if (!name.endsWith(".sock") || !isMemoraoneSocketFilename(name)) {
+      continue;
+    }
+    const socketPath = path7.join(baseDir, name);
+    if (projectId === null) {
+      paths.push(socketPath);
+      continue;
+    }
+    const normalizedProjectId = projectId.trim().toLowerCase();
+    if (isLegacySocketFilename(name) && isSocketFilenameForProject(name, normalizedProjectId)) {
+      paths.push(socketPath);
+      continue;
+    }
+    if (isHashSocketFilename(name)) {
+      const record = readBindingSidecarRecord(socketPath);
+      if (record?.projectId.trim().toLowerCase() === normalizedProjectId) {
+        paths.push(socketPath);
+      }
+    }
   }
-  if (existing.length > 1) {
-    return {
-      ok: false,
-      error: "[setup-ide-files] Multiple Cursor global MCP config paths found. Specify one explicitly.",
-      candidates: existing
-    };
+  return paths.sort();
+}
+async function defaultListSocketPathsForM1Path(m1Path) {
+  const resolvedM1 = path7.resolve(m1Path);
+  const baseDir = getMcpBaseDir();
+  let entries;
+  try {
+    entries = await fs5.readdir(baseDir);
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+    if (code === "ENOENT") {
+      return [];
+    }
+    throw err;
   }
-  if (existing.length === 1) {
-    return { ok: true, path: existing[0], detectedExisting: true };
+  const paths = [];
+  for (const name of entries) {
+    if (!name.endsWith(".sock") || !isHashSocketFilename(name)) {
+      continue;
+    }
+    const socketPath = path7.join(baseDir, name);
+    const record = readBindingSidecarRecord(socketPath);
+    if (!record?.m1Path) continue;
+    if (path7.resolve(record.m1Path) === resolvedM1) {
+      paths.push(socketPath);
+    }
   }
-  const defaultPath = candidates[0];
-  if (!defaultPath) {
-    return {
-      ok: false,
-      error: "[setup-ide-files] No known Cursor global MCP config path.",
-      candidates: []
-    };
+  return paths.sort();
+}
+async function filterSocketPathsByIdeForCleanup(socketPaths, projectId, ide, m1Path) {
+  if (ide === void 0) return socketPaths;
+  const normalizedProjectId = projectId.trim().toLowerCase();
+  const resolvedM1 = m1Path ? path7.resolve(m1Path) : null;
+  const filtered = [];
+  for (const socketPath of socketPaths) {
+    const basename5 = path7.basename(socketPath);
+    if (isLegacySocketFilename(basename5)) {
+      if (isSocketFilenameForProjectAndIde(basename5, normalizedProjectId, ide)) {
+        filtered.push(socketPath);
+      }
+      continue;
+    }
+    if (isHashSocketFilename(basename5)) {
+      const record = readBindingSidecarRecord(socketPath);
+      if (!record || record.ideType !== ide) continue;
+      const sameProject = record.projectId.trim().toLowerCase() === normalizedProjectId;
+      const sameM1 = resolvedM1 !== null && path7.resolve(record.m1Path) === resolvedM1;
+      if (sameProject || sameM1) {
+        filtered.push(socketPath);
+      }
+    }
   }
-  return { ok: true, path: defaultPath, detectedExisting: false };
+  return filtered;
 }
-function formatBackupTimestamp(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())}`;
+async function defaultKillProcess(pid) {
+  process.kill(pid, "SIGTERM");
 }
-async function isWorkingNpx(npxPath) {
+async function defaultRemoveSocket(socketPath) {
+  await fs5.unlink(socketPath);
   try {
-    if (!await pathExists(npxPath)) return false;
-    if (process.platform !== "win32") {
-      try {
-        await fs4.access(npxPath, fs4.constants.X_OK);
-      } catch {
-        return false;
-      }
-    }
-    await execFileAsync(npxPath, ["--version"], { timeout: 1e4 });
-    return true;
+    await fs5.unlink(bindingSidecarPath(socketPath));
   } catch {
-    return false;
   }
 }
-async function resolveNpxPath() {
-  const npxName = process.platform === "win32" ? "npx.cmd" : "npx";
-  const candidates = [];
-  if (process.platform === "darwin") {
-    candidates.push("/opt/homebrew/bin/npx", "/usr/local/bin/npx");
-  } else if (process.platform === "linux") {
-    candidates.push("/usr/local/bin/npx");
+async function defaultConfirm(message) {
+  if (!import_node_process.stdin.isTTY) {
+    return false;
   }
-  const pathSep = process.platform === "win32" ? ";" : ":";
-  for (const dir of (process.env.PATH ?? "").split(pathSep)) {
-    if (!dir) continue;
-    candidates.push(path6.join(dir, npxName));
+  const rl = readline2.createInterface({ input: import_node_process.stdin, output: import_node_process.stdout });
+  try {
+    const answer = await rl.question(`${message} [y/N] `);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
   }
+}
+async function resolveCleanupTarget(cwd) {
   try {
-    const lookupCmd = process.platform === "win32" ? "where" : "which";
-    const { stdout } = await execFileAsync(lookupCmd, [npxName], { timeout: 5e3 });
-    const first = stdout.trim().split(/\r?\n/).map((line) => line.trim()).find(Boolean);
-    if (first) candidates.unshift(first);
+    const binding = await resolveAuthoritativeBinding([path7.resolve(cwd)]);
+    return {
+      workspaceRoot: binding.workspaceRoot,
+      m1Path: binding.m1Path,
+      projectId: binding.projectId
+    };
   } catch {
+    return { error: CLEANUP_PROJECT_ID_REQUIRED_ERROR };
   }
-  const seen = /* @__PURE__ */ new Set();
-  for (const candidate of candidates) {
-    const abs = path6.isAbsolute(candidate) ? candidate : path6.resolve(candidate);
-    const key = process.platform === "win32" ? abs.toLowerCase() : abs;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    if (await isWorkingNpx(abs)) return abs;
-  }
-  return null;
-}
-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 } : {};
-  mcpServers.memoraone = buildMemoraoneCursorMcpServer({
-    environment,
-    npxPath: writeOptions.npxPath,
-    cliPath: writeOptions.cliPath,
-    workspaceRoot: writeOptions.repoRoot
-  });
-  return { ...base, mcpServers };
-}
-function isMemoraoneManagedApiUrl(url) {
-  if (typeof url !== "string" || url.length === 0) return false;
-  if (url === MEMORAONE_PROD_API_URL) return true;
-  if (url === MEMORAONE_LOCAL_API_URL) return true;
-  return url.startsWith(MEMORAONE_STAGING_API_URL_PREFIX);
-}
-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;
-  const env = s.env;
-  if (!env || typeof env !== "object") return false;
-  return memoraoneEnvMatchesManagedCleanupShape(env);
-}
-function cursorConfigHasManagedMemoraone(parsed) {
-  if (!parsed || typeof parsed !== "object") return false;
-  const mcpServers = parsed.mcpServers;
-  if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) return false;
-  return isManagedMemoraoneCursorServer(mcpServers.memoraone);
 }
-function memoraoneEnvMatchesManagedCleanupShape(env) {
-  return env.MEMORAONE_IDE_TYPE === "cursor" && isMemoraoneManagedApiUrl(env.MEMORAONE_API_URL);
+function filterProcessesForScope(processes, projectId) {
+  if (projectId === null) {
+    return { matching: processes, skipped: [] };
+  }
+  const normalized = projectId.toLowerCase();
+  const matching = [];
+  const skipped = [];
+  for (const proc of processes) {
+    if (proc.projectId === normalized) {
+      matching.push(proc);
+    } else {
+      skipped.push(proc);
+    }
+  }
+  return { matching, skipped };
 }
-function getCursorRepoMcpConfigPath(repoRoot) {
-  return path6.join(repoRoot, ".cursor", "mcp.json");
+function logPrefix(dryRun) {
+  return dryRun ? "[cleanup][dry-run]" : "[cleanup]";
 }
-async function readCursorMcpConfigObject(configPath) {
-  try {
-    const raw = await fs4.readFile(configPath, "utf8");
-    return JSON.parse(stripLeadingLineComments(raw));
-  } catch (err) {
-    const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
-    if (code === "ENOENT") return null;
-    throw err;
+function logReconnectNotice(opts, prefix, ide) {
+  if (opts.quiet) return;
+  if (ide) {
+    console.log(
+      `${prefix} Note: Valid ${ide} connections for this project may disconnect temporarily; they should reconnect automatically. Stale connections will remain cleared.`
+    );
+  } else {
+    console.log(
+      `${prefix} Note: Valid IDE connections for this project may disconnect temporarily; they should reconnect automatically. Stale connections will remain cleared.`
+    );
   }
 }
-async function removeMemoraoneFromCursorGlobalConfig(options) {
-  const { configPath, dryRun } = options;
-  const parsed = await readCursorMcpConfigObject(configPath);
-  if (!parsed || !cursorConfigHasManagedMemoraone(parsed)) {
-    return { changed: false };
-  }
-  if (dryRun) {
-    return { changed: true, backupPath: `${configPath}.backup-<timestamp>` };
-  }
-  const backupPath = `${configPath}.backup-${formatBackupTimestamp()}`;
-  await fs4.copyFile(configPath, backupPath);
-  const mcpServers = typeof parsed.mcpServers === "object" && parsed.mcpServers !== null && !Array.isArray(parsed.mcpServers) ? { ...parsed.mcpServers } : {};
-  delete mcpServers.memoraone;
-  const hasOtherServers = Object.keys(mcpServers).length > 0;
-  if (!hasOtherServers) {
-    await fs4.unlink(configPath);
-    return { changed: true, backupPath };
+function cleanupLog(opts, message) {
+  if (!opts.quiet) {
+    console.log(message);
   }
-  const next = { ...parsed, mcpServers };
-  await fs4.mkdir(path6.dirname(configPath), { recursive: true });
-  await fs4.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
-  return { changed: true, backupPath };
 }
-async function auditCursorMcpConfig(options) {
-  const repoRoot = path6.resolve(options?.repoRoot ?? process.cwd());
-  const repoConfigPath = getCursorRepoMcpConfigPath(repoRoot);
-  const globalDetection = await detectCursorGlobalMcpConfig({
-    homeDir: options?.homeDir,
-    explicitPath: options?.explicitGlobalPath
-  });
-  const globalConfigPath = globalDetection.ok ? globalDetection.path : getKnownCursorGlobalMcpConfigCandidates(
-    options?.homeDir ?? os2.homedir()
-  )[0];
-  let repoHasManagedMemoraone = false;
-  try {
-    const repoParsed = await readCursorMcpConfigObject(repoConfigPath);
-    repoHasManagedMemoraone = cursorConfigHasManagedMemoraone(repoParsed);
-  } catch {
-    repoHasManagedMemoraone = false;
+function cleanupWarn(opts, message) {
+  if (!opts.quiet) {
+    console.warn(message);
   }
-  let globalHasManagedMemoraone = false;
-  if (globalDetection.ok) {
-    try {
-      const globalParsed = await readCursorMcpConfigObject(globalConfigPath);
-      globalHasManagedMemoraone = cursorConfigHasManagedMemoraone(globalParsed);
-    } catch {
-      globalHasManagedMemoraone = false;
+}
+async function runCleanup(opts) {
+  const listProcesses = opts.listProcesses ?? defaultListDaemonProcesses;
+  const listSocketPaths = opts.listSocketPaths ?? defaultListSocketPaths;
+  const killProcess = opts.killProcess ?? defaultKillProcess;
+  const removeSocket = opts.removeSocket ?? defaultRemoveSocket;
+  const confirm = opts.confirm ?? defaultConfirm;
+  const prefix = logPrefix(opts.dryRun);
+  let targetProjectId = null;
+  let workspaceRoot;
+  let m1Path;
+  if (opts.allProjects) {
+    if (opts.projectId) {
+      return {
+        exitCode: 1,
+        killedPids: [],
+        removedSockets: [],
+        skippedProcesses: [],
+        error: "Cannot combine --all-projects with --project-id."
+      };
+    }
+    cleanupLog(opts, `${prefix} Mode: all projects (--all-projects)`);
+    cleanupWarn(
+      opts,
+      `${prefix} WARNING: This stops every MemoraOne MCP daemon and removes all project sockets under ${getMcpBaseDir()}.`
+    );
+  } else if (opts.projectId) {
+    const normalized = normalizeCleanupProjectId(opts.projectId);
+    if (typeof normalized !== "string") {
+      return { exitCode: 1, killedPids: [], removedSockets: [], skippedProcesses: [], error: normalized.error };
+    }
+    targetProjectId = normalized;
+    cleanupLog(opts, `${prefix} Project id: ${targetProjectId}`);
+    if (opts.ide) {
+      cleanupLog(opts, `${prefix} IDE filter: ${opts.ide}`);
+    }
+  } else {
+    const target = await resolveCleanupTarget(opts.cwd);
+    if ("error" in target) {
+      return { exitCode: 1, killedPids: [], removedSockets: [], skippedProcesses: [], error: target.error };
+    }
+    targetProjectId = target.projectId;
+    workspaceRoot = target.workspaceRoot;
+    m1Path = target.m1Path;
+    cleanupLog(opts, `${prefix} Workspace root: ${workspaceRoot}`);
+    cleanupLog(opts, `${prefix} memoraone.m1: ${m1Path}`);
+    cleanupLog(opts, `${prefix} Project id: ${targetProjectId}`);
+    if (opts.ide) {
+      cleanupLog(opts, `${prefix} IDE filter: ${opts.ide}`);
+    }
+    if (workspaceRoot && (!opts.ide || opts.ide === "cursor")) {
+      try {
+        const cursorAudit = await auditCursorMcpConfig({ repoRoot: workspaceRoot });
+        logCursorMcpConfigAudit(prefix, cursorAudit);
+      } catch (err) {
+        cleanupWarn(opts, `${prefix} Cursor MCP config audit failed: ${String(err)}`);
+      }
     }
   }
-  return {
-    repoConfigPath,
-    repoHasManagedMemoraone,
-    globalConfigPath,
-    globalHasManagedMemoraone,
-    conflict: repoHasManagedMemoraone && globalHasManagedMemoraone
-  };
-}
-function logCursorMcpConfigAudit(prefix, audit) {
-  console.log(`${prefix} Cursor MCP config audit:`);
-  console.log(
-    `${prefix}   repo ${audit.repoConfigPath}: managed memoraone=${audit.repoHasManagedMemoraone}`
-  );
-  console.log(
-    `${prefix}   global ${audit.globalConfigPath}: managed memoraone=${audit.globalHasManagedMemoraone}`
-  );
-  if (audit.conflict) {
-    console.warn(
-      `${prefix} WARNING: Both repo and global Cursor MCP define memoraone. Global shared MCP cannot bind per-window repos; remove global memoraone and use repo .cursor/mcp.json only.`
-    );
-  } else if (audit.globalHasManagedMemoraone && !audit.repoHasManagedMemoraone) {
-    console.warn(
-      `${prefix} WARNING: Cursor global MCP has memoraone but this repo lacks .cursor/mcp.json. Global MCP shares one process across windows (first-window-wins roots). Run setup-ide-files --cursor in this repo.`
-    );
-  } else if (audit.repoHasManagedMemoraone && !audit.globalHasManagedMemoraone) {
-    console.log(
-      `${prefix} Cursor MCP is repo-scoped (.cursor/mcp.json) with no global memoraone entry (recommended for multi-repo windows).`
-    );
+  if (targetProjectId !== null || opts.ide) {
+    logReconnectNotice(opts, prefix, opts.ide);
   }
-}
-function logCursorMcpCliSummary(info, dryRun) {
-  const { repoConfigPath, repoOutcome, npxPath, cliPath, repoBackupPath, globalConfigPath, globalMemoraoneRemoved, globalBackupPath } = info;
-  console.log(`[setup-ide-files] Cursor repo MCP config: ${repoConfigPath}`);
-  if (cliPath) {
-    console.log(`[setup-ide-files] Resolved local CLI: ${cliPath}`);
-  } else if (npxPath) {
-    console.log(`[setup-ide-files] Resolved npx: ${npxPath}`);
+  const allDaemonProcesses = await listProcesses();
+  const { matching: projectProcesses, skipped: skippedProcesses } = filterProcessesForScope(
+    allDaemonProcesses,
+    targetProjectId
+  );
+  let processesToStop = projectProcesses;
+  const ideSkippedProcesses = [];
+  if (opts.ide && targetProjectId !== null) {
+    processesToStop = [];
+    for (const proc of projectProcesses) {
+      if (proc.ide === opts.ide) {
+        processesToStop.push(proc);
+      } else if (proc.ide === void 0) {
+        ideSkippedProcesses.push(proc);
+        cleanupLog(
+          opts,
+          `${prefix} Skipped daemon pid=${proc.pid} because IDE could not be safely determined.`
+        );
+      } else {
+        ideSkippedProcesses.push(proc);
+        cleanupLog(
+          opts,
+          `${prefix} Skipped daemon pid=${proc.pid} (IDE ${proc.ide} does not match filter ${opts.ide}).`
+        );
+      }
+    }
   }
-  if (repoBackupPath) {
-    console.log(`[setup-ide-files] Cursor repo MCP config backup: ${repoBackupPath}`);
+  let allSocketPaths = await listSocketPaths(targetProjectId);
+  if (m1Path && !opts.allProjects) {
+    const m1Sockets = await defaultListSocketPathsForM1Path(m1Path);
+    const seen = new Set(allSocketPaths);
+    for (const socketPath of m1Sockets) {
+      if (!seen.has(socketPath)) {
+        seen.add(socketPath);
+        allSocketPaths.push(socketPath);
+      }
+      const record = readBindingSidecarRecord(socketPath);
+      const staleProjectId = record?.projectId?.trim().toLowerCase();
+      if (staleProjectId && targetProjectId !== null && staleProjectId !== targetProjectId) {
+        for (const proc of allDaemonProcesses) {
+          if (proc.projectId !== staleProjectId) continue;
+          if (opts.ide && proc.ide !== void 0 && proc.ide !== opts.ide) continue;
+          if (!processesToStop.some((p) => p.pid === proc.pid)) {
+            processesToStop.push(proc);
+            cleanupLog(
+              opts,
+              `${prefix} Including stale daemon pid=${proc.pid} project=${staleProjectId} (sidecar m1=${m1Path})`
+            );
+          }
+        }
+      }
+    }
+    allSocketPaths = [...seen].sort();
   }
-  if (repoOutcome === "created") {
-    console.log(
-      dryRun ? `[setup-ide-files] Cursor repo MCP config would be created: ${repoConfigPath}` : `[setup-ide-files] Cursor repo MCP config created: ${repoConfigPath}`
-    );
-  } else if (repoOutcome === "updated") {
-    console.log(
-      dryRun ? `[setup-ide-files] Cursor repo MCP config would be updated: ${repoConfigPath}` : `[setup-ide-files] Cursor repo MCP config updated: ${repoConfigPath}`
+  const socketPaths = targetProjectId === null ? allSocketPaths : await filterSocketPathsByIdeForCleanup(allSocketPaths, targetProjectId, opts.ide, m1Path);
+  if (opts.allProjects) {
+    const projectIds = /* @__PURE__ */ new Set();
+    for (const proc of processesToStop) {
+      projectIds.add(proc.projectId);
+    }
+    for (const socketPath of socketPaths) {
+      const id = extractProjectIdFromSocketFilename(path7.basename(socketPath));
+      if (id) {
+        projectIds.add(id);
+        continue;
+      }
+      const record = readBindingSidecarRecord(socketPath);
+      if (record) {
+        projectIds.add(record.projectId.trim().toLowerCase());
+      }
+    }
+    cleanupLog(
+      opts,
+      `${prefix} Projects affected: ${projectIds.size ? [...projectIds].sort().join(", ") : "(none found)"}`
     );
-  } else if (repoOutcome === "skipped") {
-    console.log(`[setup-ide-files] Cursor repo MCP config unchanged: ${repoConfigPath}`);
   }
-  if (globalMemoraoneRemoved && globalConfigPath) {
-    console.log(
-      dryRun ? `[setup-ide-files] Would remove memoraone from Cursor global MCP config: ${globalConfigPath}` : `[setup-ide-files] Removed memoraone from Cursor global MCP config: ${globalConfigPath}`
-    );
-    if (globalBackupPath) {
-      console.log(`[setup-ide-files] Cursor global MCP config backup: ${globalBackupPath}`);
+  if (processesToStop.length) {
+    cleanupLog(opts, `${prefix} Daemon processes to stop:`);
+    for (const proc of processesToStop) {
+      const ideLabel = proc.ide ? ` ide=${proc.ide}` : "";
+      cleanupLog(opts, `${prefix}   pid=${proc.pid} project=${proc.projectId}${ideLabel}`);
     }
-  } else if (globalConfigPath) {
-    console.log(
-      `[setup-ide-files] Cursor global MCP config unchanged (no managed memoraone to remove): ${globalConfigPath}`
-    );
+  } else if (ideSkippedProcesses.length) {
+    cleanupLog(opts, `${prefix} No matching daemon processes for IDE filter ${opts.ide}.`);
+  } else {
+    cleanupLog(opts, `${prefix} No matching daemon processes found.`);
   }
-  console.log(
-    "[setup-ide-files] Each Cursor window uses this repo\u2019s .cursor/mcp.json (separate MCP process per repo)."
-  );
-  console.log(
-    "[setup-ide-files] Fully quit Cursor and reopen this repo for MCP changes to take effect."
-  );
-}
-
-// src/cleanup.ts
-var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process3.execFile);
-var DAEMON_PROJECT_ID_RE = /--project-id\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
-var PROJECT_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var MEMORAONE_MCP_COMMAND_RE = /memoraone-mcp|memoraOne-mcp|@memoraone\/mcp/;
-var CLEANUP_PROJECT_ID_REQUIRED_ERROR = "Provide --project-id <id> or run from a folder containing memoraone.m1.";
-function isMemoraoneMcpCommandLine(commandLine) {
-  return MEMORAONE_MCP_COMMAND_RE.test(commandLine);
-}
-function parseDaemonProjectIdFromCommandLine(commandLine) {
-  if (!commandLine.includes("--daemon")) {
-    return null;
+  if (socketPaths.length) {
+    cleanupLog(opts, `${prefix} Sockets to remove:`);
+    for (const socketPath of socketPaths) {
+      cleanupLog(opts, `${prefix}   ${socketPath}`);
+    }
+  } else {
+    cleanupLog(opts, `${prefix} No matching sockets found under ${getMcpBaseDir()}.`);
   }
-  const match = commandLine.match(DAEMON_PROJECT_ID_RE);
-  return match ? match[1].toLowerCase() : null;
-}
-function parseDaemonIdeFromCommandLine(commandLine) {
-  if (!commandLine.includes("--daemon")) {
-    return void 0;
+  if (skippedProcesses.length) {
+    cleanupLog(opts, `${prefix} Skipped unrelated daemon processes:`);
+    for (const proc of skippedProcesses) {
+      cleanupLog(opts, `${prefix}   pid=${proc.pid} project=${proc.projectId}`);
+    }
   }
-  return parseIdeTypeFromCommandLine(commandLine);
-}
-function parseDaemonProcessLines(lines) {
-  const processes = [];
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    const spaceIdx = trimmed.indexOf(" ");
-    if (spaceIdx <= 0) continue;
-    const pid = Number.parseInt(trimmed.slice(0, spaceIdx), 10);
-    if (!Number.isFinite(pid) || pid <= 0) continue;
-    const command = trimmed.slice(spaceIdx + 1);
-    if (!isMemoraoneMcpCommandLine(command)) continue;
-    const projectId = parseDaemonProjectIdFromCommandLine(command);
-    if (projectId === null) continue;
-    const ide = parseDaemonIdeFromCommandLine(command);
-    processes.push({ pid, command, projectId, ...ide !== void 0 ? { ide } : {} });
+  if (opts.allProjects && !opts.dryRun) {
+    const ok = opts.assumeYes ? true : await confirm(`${prefix} Proceed with cleanup for ALL projects?`);
+    if (!ok) {
+      cleanupLog(opts, `${prefix} Aborted.`);
+      return {
+        exitCode: 1,
+        workspaceRoot,
+        m1Path,
+        projectId: targetProjectId ?? void 0,
+        killedPids: [],
+        removedSockets: [],
+        skippedProcesses: [...skippedProcesses, ...ideSkippedProcesses],
+        error: opts.assumeYes ? void 0 : "Aborted (--all requires --yes in non-interactive mode)"
+      };
+    }
   }
-  return processes;
-}
-function normalizeCleanupProjectId(projectId) {
-  const trimmed = projectId.trim();
-  if (!PROJECT_ID_RE.test(trimmed)) {
-    return { error: `Invalid project id: ${projectId}` };
+  const killedPids = [];
+  const removedSockets = [];
+  if (opts.dryRun) {
+    cleanupLog(opts, `${prefix} Dry run complete \u2014 no processes stopped, no sockets removed.`);
+    return {
+      exitCode: 0,
+      workspaceRoot,
+      m1Path,
+      projectId: targetProjectId ?? void 0,
+      killedPids: processesToStop.map((p) => p.pid),
+      removedSockets: socketPaths,
+      skippedProcesses: [...skippedProcesses, ...ideSkippedProcesses]
+    };
   }
-  return trimmed.toLowerCase();
-}
-async function defaultListDaemonProcesses() {
-  const { stdout } = await execFileAsync2("ps", ["-eo", "pid=,args="], {
-    maxBuffer: 10 * 1024 * 1024
-  });
-  return parseDaemonProcessLines(stdout.split("\n"));
-}
-async function defaultListSocketPaths(projectId) {
-  const baseDir = getMcpBaseDir();
-  let entries;
-  try {
-    entries = await fs5.readdir(baseDir);
-  } catch (err) {
-    const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
-    if (code === "ENOENT") {
-      return [];
+  for (const proc of processesToStop) {
+    try {
+      await killProcess(proc.pid);
+      killedPids.push(proc.pid);
+      cleanupLog(opts, `${prefix} Stopped daemon pid=${proc.pid} project=${proc.projectId}`);
+    } catch (err) {
+      cleanupWarn(opts, `${prefix} Could not stop pid=${proc.pid}: ${String(err)}`);
     }
-    throw err;
   }
-  const paths = [];
-  for (const name of entries) {
-    if (!name.endsWith(".sock") || !isMemoraoneSocketFilename(name)) {
-      continue;
-    }
-    const socketPath = path7.join(baseDir, name);
-    if (projectId === null) {
-      paths.push(socketPath);
-      continue;
-    }
-    const normalizedProjectId = projectId.trim().toLowerCase();
-    if (isLegacySocketFilename(name) && isSocketFilenameForProject(name, normalizedProjectId)) {
-      paths.push(socketPath);
-      continue;
-    }
-    if (isHashSocketFilename(name)) {
-      const record = readBindingSidecarRecord(socketPath);
-      if (record?.projectId.trim().toLowerCase() === normalizedProjectId) {
-        paths.push(socketPath);
+  if (killedPids.length) {
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  for (const socketPath of socketPaths) {
+    try {
+      await removeSocket(socketPath);
+      removedSockets.push(socketPath);
+      cleanupLog(opts, `${prefix} Removed socket ${socketPath}`);
+    } catch (err) {
+      const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+      if (code !== "ENOENT") {
+        cleanupWarn(opts, `${prefix} Could not remove socket ${socketPath}: ${String(err)}`);
       }
     }
   }
-  return paths.sort();
+  cleanupLog(opts, `${prefix} Done. stopped=${killedPids.length} socketsRemoved=${removedSockets.length}`);
+  return {
+    exitCode: 0,
+    workspaceRoot,
+    m1Path,
+    projectId: targetProjectId ?? void 0,
+    killedPids,
+    removedSockets,
+    skippedProcesses: [...skippedProcesses, ...ideSkippedProcesses]
+  };
 }
-async function filterSocketPathsByIde(socketPaths, projectId, ide) {
-  if (ide === void 0) return socketPaths;
-  const normalizedProjectId = projectId.trim().toLowerCase();
-  const filtered = [];
-  for (const socketPath of socketPaths) {
-    const basename4 = path7.basename(socketPath);
-    if (isLegacySocketFilename(basename4)) {
-      if (isSocketFilenameForProjectAndIde(basename4, normalizedProjectId, ide)) {
-        filtered.push(socketPath);
+function parseCleanupFlags(argv) {
+  let dryRun = false;
+  let allProjects = false;
+  let assumeYes = false;
+  let projectId;
+  let ide;
+  let invalidIde;
+  const unknown = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--dry-run") dryRun = true;
+    else if (arg === "--all-projects" || arg === "--all") allProjects = true;
+    else if (arg === "--yes" || arg === "-y") assumeYes = true;
+    else if (arg === "--project-id") {
+      if (i + 1 >= argv.length) {
+        unknown.push("--project-id (missing value)");
+      } else {
+        projectId = argv[++i];
       }
-      continue;
-    }
-    if (isHashSocketFilename(basename4)) {
-      const record = readBindingSidecarRecord(socketPath);
-      if (record?.projectId.trim().toLowerCase() === normalizedProjectId && record.ideType === ide) {
-        filtered.push(socketPath);
+    } else if (arg === "--ide") {
+      if (i + 1 >= argv.length) {
+        unknown.push("--ide (missing value)");
+      } else {
+        const value = argv[++i];
+        if (IDE_TYPES.includes(value)) {
+          ide = value;
+        } else {
+          invalidIde = value;
+        }
       }
-    }
+    } else if (arg.startsWith("-")) unknown.push(arg);
+    else unknown.push(arg);
   }
-  return filtered;
-}
-async function defaultKillProcess(pid) {
-  process.kill(pid, "SIGTERM");
+  return { dryRun, allProjects, assumeYes, projectId, ide, invalidIde, unknown };
 }
-async function defaultRemoveSocket(socketPath) {
-  await fs5.unlink(socketPath);
-  try {
-    await fs5.unlink(bindingSidecarPath(socketPath));
-  } catch {
+async function cliCleanup(argv) {
+  const { dryRun, allProjects, assumeYes, projectId, ide, invalidIde, unknown } = parseCleanupFlags(argv);
+  if (invalidIde) {
+    console.error(
+      `[cleanup] Invalid --ide value: ${invalidIde}. Expected one of: ${IDE_TYPES.join(", ")}.`
+    );
+    return 1;
   }
-}
-async function defaultConfirm(message) {
-  if (!import_node_process.stdin.isTTY) {
-    return false;
+  if (unknown.length) {
+    console.error(`[cleanup] Unknown option(s): ${unknown.join(", ")}`);
+    return 1;
   }
-  const rl = readline3.createInterface({ input: import_node_process.stdin, output: import_node_process.stdout });
-  try {
-    const answer = await rl.question(`${message} [y/N] `);
-    return /^y(es)?$/i.test(answer.trim());
-  } finally {
-    rl.close();
+  const result = await runCleanup({
+    cwd: process.cwd(),
+    dryRun,
+    allProjects,
+    assumeYes,
+    projectId,
+    ide
+  });
+  if (result.error) {
+    console.error(`[cleanup] ${result.error}`);
   }
+  return result.exitCode;
 }
-async function resolveCleanupTarget(cwd) {
+
+// src/bridgeProxy.ts
+var defaultLog = (msg) => {
+  process.stderr.write(`[memoraone-mcp][bridge] ${msg}
+`);
+};
+function summarizeJsonRpcMethod(line) {
   try {
-    const binding = await resolveAuthoritativeBinding([path7.resolve(cwd)]);
-    return {
-      workspaceRoot: binding.workspaceRoot,
-      m1Path: binding.m1Path,
-      projectId: binding.projectId
-    };
+    const message = JSON.parse(line.trim());
+    if (typeof message.method === "string") {
+      return message.method;
+    }
+    if (message.id !== void 0) {
+      return `response:id=${String(message.id)}`;
+    }
+    return "jsonrpc";
   } catch {
-    return { error: CLEANUP_PROJECT_ID_REQUIRED_ERROR };
+    return "invalid-json";
   }
 }
-function filterProcessesForScope(processes, projectId) {
-  if (projectId === null) {
-    return { matching: processes, skipped: [] };
+function connectWithRetry(socketPath, log, maxRetries, retryDelayMs, connect2) {
+  return new Promise((resolve9, reject) => {
+    const tryConnect = (attempt) => {
+      connect2(socketPath).then(resolve9).catch((err) => {
+        if (attempt >= maxRetries) {
+          reject(err);
+          return;
+        }
+        log(`connect attempt ${attempt + 1} failed, retrying in ${retryDelayMs}ms: ${String(err)}`);
+        setTimeout(() => tryConnect(attempt + 1), retryDelayMs);
+      });
+    };
+    tryConnect(0);
+  });
+}
+async function resolveBridgeSessionBinding(params, env = process.env, options = {}) {
+  const bridgeOptions = getBridgeBindingResolveOptions(env);
+  return resolveBindingFromInitializeParams(params, {
+    env,
+    fallbackWorkspaceRoots: getEnvWorkspaceRootCandidates(),
+    rootsListUris: options.rootsListUris,
+    rootsListAttempted: options.rootsListAttempted,
+    ...bridgeOptions
+  });
+}
+async function stopDaemonsForStaleBinding(stale, env, log) {
+  const ideType = resolveBindingIdeType(env);
+  let processes;
+  try {
+    processes = await defaultListDaemonProcesses();
+  } catch (err) {
+    log(`could not list daemon processes while replacing stale binding: ${String(err)}`);
+    return;
   }
-  const normalized = projectId.toLowerCase();
-  const matching = [];
-  const skipped = [];
   for (const proc of processes) {
-    if (proc.projectId === normalized) {
-      matching.push(proc);
-    } else {
-      skipped.push(proc);
+    const matchesIde = ideType === "" ? isDaemonProcessForProject(proc.command, stale.projectId) : isDaemonProcessForProjectAndIde(proc.command, stale.projectId, ideType);
+    if (!matchesIde) continue;
+    try {
+      process.kill(proc.pid, "SIGTERM");
+      log(`stopped stale daemon pid=${proc.pid} project=${stale.projectId}`);
+    } catch (err) {
+      log(`failed to stop stale daemon pid=${proc.pid}: ${String(err)}`);
     }
   }
-  return { matching, skipped };
 }
-function logPrefix(dryRun) {
-  return dryRun ? "[cleanup][dry-run]" : "[cleanup]";
-}
-function logReconnectNotice(opts, prefix, ide) {
-  if (opts.quiet) return;
-  if (ide) {
-    console.log(
-      `${prefix} Note: Valid ${ide} connections for this project may disconnect temporarily; they should reconnect automatically. Stale connections will remain cleared.`
+async function connectOrSpawnDaemonForBinding(binding, opts) {
+  const reconciled = await reconcileResolvedBindingWithDisk(binding);
+  const sessionBinding = reconciled.binding;
+  if (reconciled.cacheRefreshed) {
+    opts.log(
+      `refreshed stale binding from ${sessionBinding.m1Path}: project=${sessionBinding.projectId}`
     );
-  } else {
-    console.log(
-      `${prefix} Note: Valid IDE connections for this project may disconnect temporarily; they should reconnect automatically. Stale connections will remain cleared.`
+  }
+  const socketPath = getBindingSocketPath(sessionBinding, opts.env);
+  opts.log(
+    `target daemon socket=${socketPath} project=${sessionBinding.projectId} workspace=${sessionBinding.workspaceRoot}`
+  );
+  let socket;
+  try {
+    socket = await connectWithRetry(
+      socketPath,
+      opts.log,
+      opts.maxRetries,
+      opts.retryDelayMs,
+      opts.connect
     );
+    verifyDaemonSidecarBinding(socketPath, sessionBinding, opts.env);
+    opts.log("reusing running daemon for session binding");
+    return { socket, binding: sessionBinding, cacheRefreshed: reconciled.cacheRefreshed };
+  } catch (err) {
+    if (socket) {
+      try {
+        socket.destroy();
+      } catch {
+      }
+      socket = void 0;
+    }
+    if (isDaemonBindingMismatchError(err)) {
+      opts.log("stale daemon binding detected; replacing daemon for current memoraone.m1");
+      const staleSidecar = readBindingSidecar(socketPath);
+      if (staleSidecar) {
+        await stopDaemonsForStaleBinding(staleSidecar, opts.env, opts.log);
+      }
+      await stopDaemonsForStaleBinding(sessionBinding, opts.env, opts.log);
+      if (!bindingsMatch(binding, sessionBinding)) {
+        await stopDaemonsForStaleBinding(binding, opts.env, opts.log);
+      }
+      removeDaemonSocketArtifacts(socketPath);
+    }
   }
+  opts.log("daemon not running, spawning...");
+  await opts.spawnDaemon(sessionBinding, socketPath);
+  await new Promise((r) => setTimeout(r, opts.retryDelayMs));
+  socket = await connectWithRetry(
+    socketPath,
+    opts.log,
+    opts.maxRetries,
+    opts.retryDelayMs,
+    opts.connect
+  );
+  verifyDaemonSidecarBinding(socketPath, sessionBinding, opts.env);
+  return { socket, binding: sessionBinding, cacheRefreshed: reconciled.cacheRefreshed };
 }
-function cleanupLog(opts, message) {
-  if (!opts.quiet) {
-    console.log(message);
+var BridgeDaemonRouter = class {
+  constructor(options) {
+    this.activeSocket = null;
+    this.activeBinding = null;
+    this.socketLineReader = null;
+    this.lastInitializeLine = null;
+    this.pendingDeferredClientLines = [];
+    this.handshakeDeferredClientLines = [];
+    this.clientInitializeSeen = false;
+    this.env = options.env ?? process.env;
+    this.stdout = options.stdout ?? process.stdout;
+    this.log = options.log ?? defaultLog;
+    this.cliPath = options.cliPath;
+    this.maxRetries = options.maxRetries ?? 5;
+    this.retryDelayMs = options.retryDelayMs ?? 200;
+    this.lineReader = options.lineReader ?? null;
+    this.connectImpl = options.connect ?? ((socketPath) => new Promise((resolve9, reject) => {
+      const socket = net.connect(socketPath, () => resolve9(socket));
+      socket.on("error", reject);
+    }));
+    this.spawnDaemonImpl = options.spawnDaemon ?? (async (binding) => {
+      const child = (0, import_node_child_process3.spawn)(
+        process.execPath,
+        buildDaemonSpawnArgs(this.cliPath, binding.projectId, this.env),
+        {
+          detached: true,
+          stdio: "ignore",
+          env: {
+            ...this.env,
+            MEMORAONE_DAEMON_BINDING_B64: encodeResolvedBinding(binding)
+          }
+        }
+      );
+      child.on("exit", (code, signal) => {
+        logInitializeDebug(
+          this.log,
+          this.env,
+          `spawned daemon exit code=${code ?? "null"} signal=${signal ?? "null"} project=${binding.projectId}`
+        );
+      });
+      child.unref();
+    });
+  }
+  getActiveBinding() {
+    return this.activeBinding;
   }
-}
-function cleanupWarn(opts, message) {
-  if (!opts.quiet) {
-    console.warn(message);
+  hasClientInitialize() {
+    return this.clientInitializeSeen;
   }
-}
-async function runCleanup(opts) {
-  const listProcesses = opts.listProcesses ?? defaultListDaemonProcesses;
-  const listSocketPaths = opts.listSocketPaths ?? defaultListSocketPaths;
-  const killProcess = opts.killProcess ?? defaultKillProcess;
-  const removeSocket = opts.removeSocket ?? defaultRemoveSocket;
-  const confirm = opts.confirm ?? defaultConfirm;
-  const prefix = logPrefix(opts.dryRun);
-  let targetProjectId = null;
-  let workspaceRoot;
-  let m1Path;
-  if (opts.allProjects) {
-    if (opts.projectId) {
-      return {
-        exitCode: 1,
-        killedPids: [],
-        removedSockets: [],
-        skippedProcesses: [],
-        error: "Cannot combine --all-projects with --project-id."
-      };
-    }
-    cleanupLog(opts, `${prefix} Mode: all projects (--all-projects)`);
-    cleanupWarn(
-      opts,
-      `${prefix} WARNING: This stops every MemoraOne MCP daemon and removes all project sockets under ${getMcpBaseDir()}.`
+  async ensureDaemonForInitialize(params) {
+    logInitializeDebug(
+      this.log,
+      this.env,
+      `initialize payload: ${summarizeInitializeParamsForDebug(params)}`
     );
-  } else if (opts.projectId) {
-    const normalized = normalizeCleanupProjectId(opts.projectId);
-    if (typeof normalized !== "string") {
-      return { exitCode: 1, killedPids: [], removedSockets: [], skippedProcesses: [], error: normalized.error };
+    const bridgeOptions = getBridgeBindingResolveOptions(this.env);
+    const initializeRoots = extractWorkspaceRootsFromInitialize(params);
+    let rootsListUris;
+    let rootsListAttempted = false;
+    const repoHint = getRepoScopedWorkspaceHint(this.env);
+    if (initializeRoots.length === 0 && bridgeOptions.allowEnvWorkspaceFallback === false && repoHint === null) {
+      if (!this.lineReader) {
+        throw new Error(
+          "[memoraone-mcp] Internal error: Cursor workspace binding requires stdin line reader for roots/list"
+        );
+      }
+      rootsListAttempted = true;
+      this.log("initialize lacks workspace roots; requesting roots/list from Cursor before binding");
+      const rootsListResult = await requestClientRootsListUris({
+        lineReader: this.lineReader,
+        stdout: this.stdout,
+        log: this.log,
+        env: this.env,
+        initializeParams: params
+      });
+      rootsListUris = rootsListResult.uris;
+      if (rootsListResult.deferredLines.length > 0) {
+        this.pendingDeferredClientLines = rootsListResult.deferredLines.slice();
+        logInitializeDebug(
+          this.log,
+          this.env,
+          `queued ${this.pendingDeferredClientLines.length} deferred client line(s) for replay after initialize`
+        );
+      }
     }
-    targetProjectId = normalized;
-    cleanupLog(opts, `${prefix} Project id: ${targetProjectId}`);
-    if (opts.ide) {
-      cleanupLog(opts, `${prefix} IDE filter: ${opts.ide}`);
+    const binding = await resolveBridgeSessionBinding(params, this.env, {
+      rootsListUris,
+      rootsListAttempted
+    });
+    const environmentLog = binding.environment !== void 0 ? ` environment=${binding.environment}` : "";
+    this.log(
+      `session binding project=${binding.projectId} workspace=${binding.workspaceRoot} m1=${binding.m1Path} source=${binding.bindingSource} apiKeySource=${binding.apiKeySource}${environmentLog}`
+    );
+    if (this.activeBinding && bindingsMatch(this.activeBinding, binding) && this.activeSocket) {
+      return;
     }
-  } else {
-    const target = await resolveCleanupTarget(opts.cwd);
-    if ("error" in target) {
-      return { exitCode: 1, killedPids: [], removedSockets: [], skippedProcesses: [], error: target.error };
+    if (this.activeBinding && !bindingsMatch(this.activeBinding, binding)) {
+      this.log(
+        `session binding changed from workspace=${this.activeBinding.workspaceRoot} to workspace=${binding.workspaceRoot}; reconnecting daemon`
+      );
+      this.resetSessionState();
+      this.detachSocketReader();
+      this.activeSocket?.destroy();
+      this.activeSocket = null;
     }
-    targetProjectId = target.projectId;
-    workspaceRoot = target.workspaceRoot;
-    m1Path = target.m1Path;
-    cleanupLog(opts, `${prefix} Workspace root: ${workspaceRoot}`);
-    cleanupLog(opts, `${prefix} memoraone.m1: ${m1Path}`);
-    cleanupLog(opts, `${prefix} Project id: ${targetProjectId}`);
-    if (opts.ide) {
-      cleanupLog(opts, `${prefix} IDE filter: ${opts.ide}`);
+    this.activeBinding = binding;
+    await this.connectActiveDaemon();
+    this.log("bridge connected");
+  }
+  recordClientInitialize(line) {
+    this.lastInitializeLine = line;
+    this.clientInitializeSeen = true;
+  }
+  async forwardInitializeToDaemon(line) {
+    this.recordClientInitialize(line);
+    await this.writeToDaemon(line);
+    logInitializeDebug(this.log, this.env, "initialize replay to daemon");
+    this.log("forwarding active");
+  }
+  async replayDeferredClientMessages() {
+    if (this.pendingDeferredClientLines.length === 0) {
+      return;
     }
-    if (workspaceRoot && (!opts.ide || opts.ide === "cursor")) {
-      try {
-        const cursorAudit = await auditCursorMcpConfig({ repoRoot: workspaceRoot });
-        logCursorMcpConfigAudit(prefix, cursorAudit);
-      } catch (err) {
-        cleanupWarn(opts, `${prefix} Cursor MCP config audit failed: ${String(err)}`);
-      }
+    const lines = this.pendingDeferredClientLines.slice();
+    this.pendingDeferredClientLines = [];
+    this.handshakeDeferredClientLines = lines.slice();
+    const types = lines.map((line) => summarizeJsonRpcMethod(line));
+    logInitializeDebug(
+      this.log,
+      this.env,
+      `deferred message replay count=${lines.length} types=${JSON.stringify(types)}`
+    );
+    for (const line of lines) {
+      await this.writeToDaemon(line);
     }
   }
-  if (targetProjectId !== null || opts.ide) {
-    logReconnectNotice(opts, prefix, opts.ide);
+  async writeToDaemon(line) {
+    await this.ensureActiveDaemonSocket();
+    this.activeSocket.write(`${line}
+`);
   }
-  const allDaemonProcesses = await listProcesses();
-  const { matching: projectProcesses, skipped: skippedProcesses } = filterProcessesForScope(
-    allDaemonProcesses,
-    targetProjectId
-  );
-  let processesToStop = projectProcesses;
-  const ideSkippedProcesses = [];
-  if (opts.ide && targetProjectId !== null) {
-    processesToStop = [];
-    for (const proc of projectProcesses) {
-      if (proc.ide === opts.ide) {
-        processesToStop.push(proc);
-      } else if (proc.ide === void 0) {
-        ideSkippedProcesses.push(proc);
-        cleanupLog(
-          opts,
-          `${prefix} Skipped daemon pid=${proc.pid} because IDE could not be safely determined.`
-        );
-      } else {
-        ideSkippedProcesses.push(proc);
-        cleanupLog(
-          opts,
-          `${prefix} Skipped daemon pid=${proc.pid} (IDE ${proc.ide} does not match filter ${opts.ide}).`
-        );
-      }
+  resetSessionState() {
+    this.lastInitializeLine = null;
+    this.pendingDeferredClientLines = [];
+    this.handshakeDeferredClientLines = [];
+    this.clientInitializeSeen = false;
+    this.activeBinding = null;
+  }
+  async connectActiveDaemon() {
+    if (!this.activeBinding) {
+      throw new Error("[memoraone-mcp] Internal error: connectActiveDaemon without active binding");
     }
+    const connected = await connectOrSpawnDaemonForBinding(this.activeBinding, {
+      env: this.env,
+      cliPath: this.cliPath,
+      log: this.log,
+      maxRetries: this.maxRetries,
+      retryDelayMs: this.retryDelayMs,
+      connect: this.connectImpl,
+      spawnDaemon: this.spawnDaemonImpl
+    });
+    this.activeBinding = connected.binding;
+    this.activeSocket = connected.socket;
+    this.attachSocketReader(connected.socket);
   }
-  const allSocketPaths = await listSocketPaths(targetProjectId);
-  const socketPaths = targetProjectId === null ? allSocketPaths : await filterSocketPathsByIde(allSocketPaths, targetProjectId, opts.ide);
-  if (opts.allProjects) {
-    const projectIds = /* @__PURE__ */ new Set();
-    for (const proc of processesToStop) {
-      projectIds.add(proc.projectId);
+  async ensureActiveDaemonSocket() {
+    if (this.activeSocket && !this.activeSocket.destroyed) {
+      return;
     }
-    for (const socketPath of socketPaths) {
-      const id = extractProjectIdFromSocketFilename(path7.basename(socketPath));
-      if (id) {
-        projectIds.add(id);
-        continue;
-      }
-      const record = readBindingSidecarRecord(socketPath);
-      if (record) {
-        projectIds.add(record.projectId.trim().toLowerCase());
+    if (!this.clientInitializeSeen || !this.lastInitializeLine || !this.activeBinding) {
+      throw new Error("[memoraone-mcp] MCP request before initialize");
+    }
+    this.log("daemon socket unavailable; reconnecting for session binding");
+    await this.connectActiveDaemon();
+    logInitializeDebug(this.log, this.env, "initialize replay to daemon after reconnect");
+    this.activeSocket.write(`${this.lastInitializeLine}
+`);
+    if (this.handshakeDeferredClientLines.length > 0) {
+      const types = this.handshakeDeferredClientLines.map(
+        (deferredLine) => summarizeJsonRpcMethod(deferredLine)
+      );
+      logInitializeDebug(
+        this.log,
+        this.env,
+        `deferred message replay after reconnect count=${this.handshakeDeferredClientLines.length} types=${JSON.stringify(types)}`
+      );
+      for (const deferredLine of this.handshakeDeferredClientLines) {
+        this.activeSocket.write(`${deferredLine}
+`);
       }
     }
-    cleanupLog(
-      opts,
-      `${prefix} Projects affected: ${projectIds.size ? [...projectIds].sort().join(", ") : "(none found)"}`
-    );
   }
-  if (processesToStop.length) {
-    cleanupLog(opts, `${prefix} Daemon processes to stop:`);
-    for (const proc of processesToStop) {
-      const ideLabel = proc.ide ? ` ide=${proc.ide}` : "";
-      cleanupLog(opts, `${prefix}   pid=${proc.pid} project=${proc.projectId}${ideLabel}`);
-    }
-  } else if (ideSkippedProcesses.length) {
-    cleanupLog(opts, `${prefix} No matching daemon processes for IDE filter ${opts.ide}.`);
-  } else {
-    cleanupLog(opts, `${prefix} No matching daemon processes found.`);
+  attachSocketReader(socket) {
+    this.detachSocketReader();
+    this.socketLineReader = readline3.createInterface({ input: socket, crlfDelay: Infinity });
+    this.socketLineReader.on("line", (line) => {
+      this.stdout.write(`${line}
+`);
+    });
+    socket.on("close", (hadError) => {
+      if (this.activeSocket === socket) {
+        logInitializeDebug(
+          this.log,
+          this.env,
+          `daemon socket closed hadError=${String(hadError)}`
+        );
+        this.log("daemon socket closed; bridge stays alive for reconnect");
+        this.detachSocketReader();
+        this.activeSocket = null;
+      }
+    });
+    socket.on("error", (err) => {
+      this.log(`socket error: ${String(err)}`);
+      logInitializeDebug(this.log, this.env, `daemon socket error: ${String(err)}`);
+      if (this.activeSocket === socket) {
+        this.detachSocketReader();
+        this.activeSocket = null;
+      }
+    });
   }
-  if (socketPaths.length) {
-    cleanupLog(opts, `${prefix} Sockets to remove:`);
-    for (const socketPath of socketPaths) {
-      cleanupLog(opts, `${prefix}   ${socketPath}`);
+  detachSocketReader() {
+    if (this.socketLineReader) {
+      this.socketLineReader.close();
+      this.socketLineReader = null;
     }
-  } else {
-    cleanupLog(opts, `${prefix} No matching sockets found under ${getMcpBaseDir()}.`);
   }
-  if (skippedProcesses.length) {
-    cleanupLog(opts, `${prefix} Skipped unrelated daemon processes:`);
-    for (const proc of skippedProcesses) {
-      cleanupLog(opts, `${prefix}   pid=${proc.pid} project=${proc.projectId}`);
+};
+async function runBridgeProxy(options) {
+  ensureBaseDir();
+  const stdin = options.stdin ?? process.stdin;
+  const stdout = options.stdout ?? process.stdout;
+  const log = options.log ?? defaultLog;
+  const lineReader = options.lineReader ?? new StdioLineReader(stdin);
+  const router = new BridgeDaemonRouter({ ...options, stdout, lineReader });
+  while (true) {
+    const line = await lineReader.readLine();
+    if (line === null) {
+      break;
     }
-  }
-  if (opts.allProjects && !opts.dryRun) {
-    const ok = opts.assumeYes ? true : await confirm(`${prefix} Proceed with cleanup for ALL projects?`);
-    if (!ok) {
-      cleanupLog(opts, `${prefix} Aborted.`);
-      return {
-        exitCode: 1,
-        workspaceRoot,
-        m1Path,
-        projectId: targetProjectId ?? void 0,
-        killedPids: [],
-        removedSockets: [],
-        skippedProcesses: [...skippedProcesses, ...ideSkippedProcesses],
-        error: opts.assumeYes ? void 0 : "Aborted (--all requires --yes in non-interactive mode)"
-      };
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      continue;
     }
-  }
-  const killedPids = [];
-  const removedSockets = [];
-  if (opts.dryRun) {
-    cleanupLog(opts, `${prefix} Dry run complete \u2014 no processes stopped, no sockets removed.`);
-    return {
-      exitCode: 0,
-      workspaceRoot,
-      m1Path,
-      projectId: targetProjectId ?? void 0,
-      killedPids: processesToStop.map((p) => p.pid),
-      removedSockets: socketPaths,
-      skippedProcesses: [...skippedProcesses, ...ideSkippedProcesses]
-    };
-  }
-  for (const proc of processesToStop) {
+    let message;
     try {
-      await killProcess(proc.pid);
-      killedPids.push(proc.pid);
-      cleanupLog(opts, `${prefix} Stopped daemon pid=${proc.pid} project=${proc.projectId}`);
+      message = JSON.parse(trimmed);
     } catch (err) {
-      cleanupWarn(opts, `${prefix} Could not stop pid=${proc.pid}: ${String(err)}`);
+      throw new Error(`[memoraone-mcp] Invalid JSON-RPC on stdin: ${String(err)}`);
     }
-  }
-  if (killedPids.length) {
-    await new Promise((r) => setTimeout(r, 300));
-  }
-  for (const socketPath of socketPaths) {
-    try {
-      await removeSocket(socketPath);
-      removedSockets.push(socketPath);
-      cleanupLog(opts, `${prefix} Removed socket ${socketPath}`);
-    } catch (err) {
-      const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
-      if (code !== "ENOENT") {
-        cleanupWarn(opts, `${prefix} Could not remove socket ${socketPath}: ${String(err)}`);
-      }
+    if (message.method === "initialize") {
+      log("resolve binding from initialize request before daemon connect");
+      const params = message.params ?? {};
+      await router.ensureDaemonForInitialize(params);
+      await router.forwardInitializeToDaemon(trimmed);
+      await router.replayDeferredClientMessages();
+      continue;
     }
+    await router.writeToDaemon(trimmed);
   }
-  cleanupLog(opts, `${prefix} Done. stopped=${killedPids.length} socketsRemoved=${removedSockets.length}`);
-  return {
-    exitCode: 0,
-    workspaceRoot,
-    m1Path,
-    projectId: targetProjectId ?? void 0,
-    killedPids,
-    removedSockets,
-    skippedProcesses: [...skippedProcesses, ...ideSkippedProcesses]
-  };
-}
-function parseCleanupFlags(argv) {
-  let dryRun = false;
-  let allProjects = false;
-  let assumeYes = false;
-  let projectId;
-  let ide;
-  let invalidIde;
-  const unknown = [];
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === "--dry-run") dryRun = true;
-    else if (arg === "--all-projects" || arg === "--all") allProjects = true;
-    else if (arg === "--yes" || arg === "-y") assumeYes = true;
-    else if (arg === "--project-id") {
-      if (i + 1 >= argv.length) {
-        unknown.push("--project-id (missing value)");
-      } else {
-        projectId = argv[++i];
-      }
-    } else if (arg === "--ide") {
-      if (i + 1 >= argv.length) {
-        unknown.push("--ide (missing value)");
-      } else {
-        const value = argv[++i];
-        if (IDE_TYPES.includes(value)) {
-          ide = value;
-        } else {
-          invalidIde = value;
-        }
-      }
-    } else if (arg.startsWith("-")) unknown.push(arg);
-    else unknown.push(arg);
-  }
-  return { dryRun, allProjects, assumeYes, projectId, ide, invalidIde, unknown };
-}
-async function cliCleanup(argv) {
-  const { dryRun, allProjects, assumeYes, projectId, ide, invalidIde, unknown } = parseCleanupFlags(argv);
-  if (invalidIde) {
-    console.error(
-      `[cleanup] Invalid --ide value: ${invalidIde}. Expected one of: ${IDE_TYPES.join(", ")}.`
-    );
-    return 1;
-  }
-  if (unknown.length) {
-    console.error(`[cleanup] Unknown option(s): ${unknown.join(", ")}`);
-    return 1;
-  }
-  const result = await runCleanup({
-    cwd: process.cwd(),
-    dryRun,
-    allProjects,
-    assumeYes,
-    projectId,
-    ide
-  });
-  if (result.error) {
-    console.error(`[cleanup] ${result.error}`);
-  }
-  return result.exitCode;
 }
 
+// src/setupIdeFiles.ts
+var fs8 = __toESM(require("fs/promises"), 1);
+var os4 = __toESM(require("os"), 1);
+var path10 = __toESM(require("path"), 1);
+
 // src/jetbrainsMcpConfig.ts
 var fs6 = __toESM(require("fs/promises"), 1);
 var os3 = __toESM(require("os"), 1);
@@ -2391,6 +2585,234 @@ async function resolveBuiltCliPathAsync(options) {
   return null;
 }
 
+// src/openCursorMcpSettings.ts
+var import_node_child_process5 = require("child_process");
+var readline4 = __toESM(require("readline/promises"), 1);
+var import_node_util3 = 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(env = process.env) {
+  if (env.CI === "true" || env.CI === "1") return true;
+  if (env.GITHUB_ACTIONS === "true" || env.GITHUB_ACTIONS === "1") return true;
+  if (env.GITLAB_CI === "true" || env.GITLAB_CI === "1") return true;
+  if (env.CIRCLECI === "true" || env.CIRCLECI === "1") return true;
+  if (env.BUILDKITE === "true" || env.BUILDKITE === "1") return true;
+  if (typeof env.CI === "string" && env.CI.trim() !== "" && env.CI !== "0" && env.CI !== "false") {
+    return true;
+  }
+  return false;
+}
+function shouldEnableAnsiColor(opts = {}) {
+  if (typeof opts.color === "boolean") return opts.color;
+  const env = opts.env ?? process.env;
+  if (env.NO_COLOR !== void 0) return false;
+  if (isCiLikeEnv(env)) return false;
+  const tty = opts.stdoutIsTty ?? process.stdout.isTTY === true;
+  return tty;
+}
+function shouldUseUnicodeSymbols(opts = {}) {
+  if (typeof opts.unicode === "boolean") return opts.unicode;
+  const env = opts.env ?? process.env;
+  const tty = opts.stdoutIsTty ?? process.stdout.isTTY === true;
+  if (!tty) return false;
+  if (env.TERM === "dumb") return false;
+  if (process.platform === "win32") {
+    return Boolean(
+      env.WT_SESSION || env.WT_PROFILE_ID || env.ConEmuANSI === "ON" || env.TERM_PROGRAM === "vscode" || env.TERM_PROGRAM === "cursor" || typeof env.TERM === "string" && env.TERM !== "" && env.TERM !== "dumb"
+    );
+  }
+  return true;
+}
+function paint(enabled, code, text) {
+  if (!enabled || text === "") return text;
+  return `${code}${text}${ANSI.reset}`;
+}
+function createTerminalPresentation(opts = {}) {
+  const color = shouldEnableAnsiColor(opts);
+  const unicode = shouldUseUnicodeSymbols(opts);
+  const successSymbol = unicode ? "\u2713" : "[OK]";
+  const warningSymbol = unicode ? "\u26A0" : "[WARN]";
+  const nextActionPrefix = unicode ? "\u2192" : "Next:";
+  return {
+    color,
+    unicode,
+    bold: (text) => paint(color, ANSI.bold, text),
+    green: (text) => paint(color, ANSI.green, text),
+    cyan: (text) => paint(color, ANSI.cyan, text),
+    yellow: (text) => paint(color, ANSI.yellow, text),
+    dim: (text) => paint(color, ANSI.dim, text),
+    successSymbol,
+    warningSymbol,
+    nextActionPrefix,
+    successLine: (message) => paint(color, ANSI.green, `${successSymbol} ${message}`),
+    warningLine: (message) => paint(color, ANSI.yellow, `${warningSymbol} ${message}`),
+    nextActionLine: (message) => `${nextActionPrefix} ${message}`,
+    heading: (text) => paint(color, ANSI.bold, text),
+    indent: (text) => `  ${text}`
+  };
+}
+
+// src/openCursorMcpSettings.ts
+var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process5.execFile);
+var OPEN_CURSOR_MCP_SETTINGS_PROMPT = "Open Cursor MCP settings now? [Y/n] ";
+function resolvePresentation(deps) {
+  if (deps.presentation) return deps.presentation;
+  const opts = {
+    env: deps.env ?? process.env,
+    stdoutIsTty: deps.stdoutIsTty ?? process.stdout.isTTY === true,
+    color: deps.color,
+    unicode: deps.unicode
+  };
+  return createTerminalPresentation(opts);
+}
+function shouldPromptOpenCursorMcpSettings(opts) {
+  if (!opts.explicitCursor) return false;
+  if (opts.all) return false;
+  if (opts.dryRun) return false;
+  if (!opts.stdinIsTty) return false;
+  if (isCiLikeEnv(opts.env ?? process.env)) return false;
+  return true;
+}
+function isYesDefaultAnswer(answer) {
+  const trimmed = answer.trim();
+  if (trimmed === "") return true;
+  if (/^y(es)?$/i.test(trimmed)) return true;
+  if (/^n(o)?$/i.test(trimmed)) return false;
+  return false;
+}
+async function confirmYesDefault(question, deps = {}) {
+  if (deps.ask) {
+    return isYesDefaultAnswer(await deps.ask(question));
+  }
+  const input2 = deps.input ?? process.stdin;
+  const output2 = deps.output ?? process.stdout;
+  if (!("isTTY" in input2) || !input2.isTTY) {
+    return false;
+  }
+  const rl = readline4.createInterface({ input: input2, output: output2 });
+  try {
+    const answer = await rl.question(question.endsWith(" ") ? question : `${question} `);
+    return isYesDefaultAnswer(answer);
+  } finally {
+    rl.close();
+  }
+}
+function collectOutcomePaths(outcomes) {
+  const created = [];
+  const updated = [];
+  for (const [file, outcome] of Object.entries(outcomes)) {
+    if (outcome === "created") created.push(file);
+    else if (outcome === "updated") updated.push(file);
+  }
+  return { created, updated };
+}
+function formatCursorSetupCompletedSummary(opts, presentation = createTerminalPresentation({ color: false, unicode: false })) {
+  const { created, updated } = collectOutcomePaths(opts.outcomes);
+  const tp = presentation;
+  const lines = [
+    tp.successLine("MemoraOne setup completed for Cursor"),
+    "",
+    tp.heading("Repository"),
+    tp.indent(tp.cyan(opts.repoRoot)),
+    "",
+    tp.heading("Changes")
+  ];
+  if (created.length === 0 && updated.length === 0) {
+    lines.push(tp.indent(tp.dim("No file changes needed")));
+  } else {
+    if (created.length) {
+      lines.push(tp.indent(`Created: ${created.join(", ")}`));
+    }
+    if (updated.length) {
+      lines.push(tp.indent(`Updated: ${updated.join(", ")}`));
+    }
+  }
+  return lines;
+}
+function printCursorSetupCompletedSummary(opts, println = console.log, presentation) {
+  const tp = presentation ?? createTerminalPresentation();
+  for (const line of formatCursorSetupCompletedSummary(opts, tp)) {
+    println(line);
+  }
+}
+function macosOpenCursorMcpSettingsAppleScript() {
+  return [
+    'tell application "Cursor" to activate',
+    "delay 0.5",
+    'tell application "System Events"',
+    'keystroke "p" using {command down, shift down}',
+    "delay 0.4",
+    'keystroke "View: Open MCP Settings"',
+    "delay 0.4",
+    "key code 36",
+    "end tell"
+  ].join("\n");
+}
+async function openCursorMcpSettingsViaOsascript(execFileImpl = execFileAsync3) {
+  await execFileImpl("osascript", ["-e", macosOpenCursorMcpSettingsAppleScript()], {
+    timeout: 3e4
+  });
+}
+function manualCursorMcpSettingsSteps(platform) {
+  const chord = platform === "darwin" ? "Command + Shift + P" : "Ctrl + Shift + P";
+  return [
+    "To finish setup manually:",
+    "1. Open this repository in Cursor.",
+    `2. Press ${chord}.`,
+    '3. Run "View: Open MCP Settings".',
+    '4. Find "memoraone" and enable it.',
+    "5. Confirm it turns green.",
+    "6. Return to MemoraOne Studio and refresh Sources."
+  ];
+}
+function printManualCursorMcpSettingsSteps(platform, println = console.log) {
+  for (const line of manualCursorMcpSettingsSteps(platform)) {
+    println(line);
+  }
+}
+function formatOpenCursorMcpSettingsPrompt(presentation = createTerminalPresentation({ color: false, unicode: false })) {
+  return `${presentation.indent(OPEN_CURSOR_MCP_SETTINGS_PROMPT.trimEnd())} `;
+}
+async function runOpenCursorMcpSettingsFlow(deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  const println = deps.println ?? console.log;
+  const tp = resolvePresentation(deps);
+  const confirm = deps.confirm ?? ((question) => confirmYesDefault(question));
+  println("");
+  println(tp.heading("Next"));
+  const yes = await confirm(formatOpenCursorMcpSettingsPrompt(tp));
+  if (!yes) {
+    printManualCursorMcpSettingsSteps(platform, println);
+    return;
+  }
+  if (platform === "darwin") {
+    println(tp.warningLine("macOS may request Automation or Accessibility permission."));
+    try {
+      const open = deps.openViaOsascript ?? (() => openCursorMcpSettingsViaOsascript(deps.execFile ?? execFileAsync3));
+      await open();
+      println(tp.successLine('Confirm "memoraone" is enabled and green'));
+      println(tp.nextActionLine("Return to MemoraOne Studio and refresh Sources"));
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      println(tp.warningLine(`Could not open Cursor MCP settings automatically (${detail}).`));
+      println(
+        "Permission may be required at: System Settings \u2192 Privacy & Security \u2192 Accessibility"
+      );
+      printManualCursorMcpSettingsSteps("darwin", println);
+    }
+    return;
+  }
+  printManualCursorMcpSettingsSteps(platform, println);
+}
+
 // src/setupIdeFiles.ts
 var MANAGED_MARKER = "<!-- MemoraOne managed IDE helper -->";
 var GITIGNORE_MEMORAONE_COMMENT = "# MemoraOne local project binding / API key";
@@ -2627,7 +3049,21 @@ function parseSetupIdeFlags(argv) {
   if (local && staging) {
     flagError = "[setup-ide-files] --local and --staging are mutually exclusive.";
   }
-  return { targets, force, dryRun, noGitignore, cleanup, devMode, repair, local, staging, all, unknown, flagError };
+  return {
+    targets,
+    force,
+    dryRun,
+    noGitignore,
+    cleanup,
+    devMode,
+    repair,
+    local,
+    staging,
+    all,
+    explicitCursor: cursor,
+    unknown,
+    flagError
+  };
 }
 function cursorEnvironmentFromFlags(local, staging) {
   if (local) return "local";
@@ -2892,7 +3328,7 @@ description: MemoraOne MCP \u2014 IDE agent instructions
       homeDir: o.homeDir,
       explicitPath: o.cursorGlobalMcpConfigPath
     });
-    if (!globalDetection.ok) {
+    if (globalDetection.ok === false) {
       return {
         exitCode: 1,
         repoRoot,
@@ -2991,8 +3427,22 @@ description: MemoraOne MCP \u2014 IDE agent instructions
   }
   return { exitCode: 0, repoRoot, outcomes, cursorMcp, jetbrainsMcp, daemonCleanup };
 }
-async function cliSetupIdeFiles(argv) {
-  const { targets, force, dryRun, noGitignore, cleanup, devMode, repair, local, staging, unknown, flagError } = parseSetupIdeFlags(argv);
+async function cliSetupIdeFiles(argv, options = {}) {
+  const {
+    targets,
+    force,
+    dryRun,
+    noGitignore,
+    cleanup,
+    devMode,
+    repair,
+    local,
+    staging,
+    all,
+    explicitCursor,
+    unknown,
+    flagError
+  } = parseSetupIdeFlags(argv);
   if (flagError) {
     console.error(flagError);
     return 1;
@@ -3001,15 +3451,27 @@ async function cliSetupIdeFiles(argv) {
     console.error(`[setup-ide-files] Unknown option(s): ${unknown.join(", ")}`);
     return 1;
   }
+  const cwd = options.cwd ?? process.cwd();
+  const openDeps = options.openCursorMcpSettings ?? {};
+  const stdinIsTty = openDeps.stdinIsTty ?? process.stdin.isTTY === true;
+  const env = openDeps.env ?? process.env;
+  const promptOpenCursorSettings = shouldPromptOpenCursorMcpSettings({
+    explicitCursor,
+    all,
+    dryRun,
+    stdinIsTty,
+    env
+  });
   const result = await runSetupIdeFiles({
-    cwd: process.cwd(),
+    cwd,
     targets,
     force,
     dryRun,
-    noGitignore,
+    noGitignore: options.setupOverrides?.noGitignore ?? noGitignore,
     devMode,
     repair,
-    cursorEnvironment: cursorEnvironmentFromFlags(local, staging)
+    cursorEnvironment: cursorEnvironmentFromFlags(local, staging),
+    ...options.setupOverrides
   });
   if (result.error) {
     console.error(result.error);
@@ -3026,23 +3488,45 @@ async function cliSetupIdeFiles(argv) {
     logSetupIdeCleanupSummary(result.daemonCleanup);
   }
   if (targets.cursor && result.cursorMcp) {
-    logCursorMcpCliSummary(result.cursorMcp, dryRun);
+    logCursorMcpCliSummary(result.cursorMcp, dryRun, {
+      forInteractivePostSetup: promptOpenCursorSettings
+    });
   }
   if (targets.jetbrains && result.jetbrainsMcp) {
     logJetBrainsMcpCliSummary(result.jetbrainsMcp, dryRun);
   }
-  summarizeOutcomes(result.outcomes);
-  if (dryRun) {
-    console.log("[setup-ide-files] Dry run: no files written.");
-    if (result.daemonCleanup && !result.daemonCleanup.skipped) {
-      console.log("[setup-ide-files] Dry run: no daemons stopped, no sockets removed.");
+  if (promptOpenCursorSettings && result.repoRoot) {
+    const presentation = openDeps.presentation ?? createTerminalPresentation({
+      env,
+      stdoutIsTty: openDeps.stdoutIsTty ?? process.stdout.isTTY === true,
+      color: openDeps.color,
+      unicode: openDeps.unicode
+    });
+    printCursorSetupCompletedSummary(
+      { repoRoot: result.repoRoot, outcomes: result.outcomes },
+      openDeps.println,
+      presentation
+    );
+    await runOpenCursorMcpSettingsFlow({
+      ...openDeps,
+      stdinIsTty,
+      env,
+      presentation
+    });
+  } else {
+    summarizeOutcomes(result.outcomes);
+    if (dryRun) {
+      console.log("[setup-ide-files] Dry run: no files written.");
+      if (result.daemonCleanup && !result.daemonCleanup.skipped) {
+        console.log("[setup-ide-files] Dry run: no daemons stopped, no sockets removed.");
+      }
     }
+    console.log(`[setup-ide-files] ${restartIdeInstruction(targets)}`);
   }
-  console.log(`[setup-ide-files] ${restartIdeInstruction(targets)}`);
   if (cleanup) {
     console.log("[setup-ide-files] Running additional full-project cleanup (--cleanup)...");
     const cleanupResult = await runCleanup({
-      cwd: process.cwd(),
+      cwd,
       dryRun,
       allProjects: false,
       assumeYes: true