@memoraone/mcp 0.1.30 → 0.1.31

package/dist/cli.cjs

@@ -30,7 +30,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.30",
+      version: "0.1.31",
       type: "module",
       main: "dist/index.cjs",
       bin: {
@@ -66,88 +66,57 @@ var require_package = __commonJS({
   }
 });
 
-// src/cli.ts
-var path7 = __toESM(require("path"), 1);
+// src/bridgeProxy.ts
 var net = __toESM(require("net"), 1);
-var import_node_child_process4 = require("child_process");
+var readline2 = __toESM(require("readline"), 1);
+var import_node_child_process = require("child_process");
 
-// src/socketPaths.ts
-var os = __toESM(require("os"), 1);
+// src/bindingIdentity.ts
+var crypto = __toESM(require("crypto"), 1);
 var path = __toESM(require("path"), 1);
-var fs = __toESM(require("fs"), 1);
-var BASE_DIR = process.env.MEMORAONE_MCP_LOCK_DIR || path.join(os.homedir(), ".memoraone-mcp");
-var SOCKET_PROJECT_ID_RE = /^mcp-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:-([a-z-]+))?\.sock$/i;
-function getMcpBaseDir() {
-  return BASE_DIR;
-}
-var IDE_TYPES = ["cursor", "copilot-vscode", "jetbrains"];
-var IDE_TYPE_SET = new Set(IDE_TYPES);
-function parseIdeType(value) {
-  if (value === void 0 || value.trim() === "" || !IDE_TYPE_SET.has(value)) {
-    return void 0;
-  }
-  return value;
-}
-function resolveIdeTypeFromEnv(env = process.env) {
-  return parseIdeType(env.MEMORAONE_IDE_TYPE);
-}
-function parseIdeTypeFromCommandLine(commandLine) {
-  const match = commandLine.match(/--ide\s+(cursor|copilot-vscode|jetbrains)(?:\s|$)/);
-  return match ? match[1] : void 0;
-}
-function buildDaemonSpawnArgs(scriptPath, projectId, env = process.env) {
-  const args2 = [scriptPath, "--daemon", "--project-id", projectId];
-  const ideType = resolveIdeTypeFromEnv(env);
-  if (ideType) {
-    args2.push("--ide", ideType);
-  }
-  return args2;
-}
-function getSocketPath(projectId, ideType) {
-  if (ideType) {
-    return path.join(BASE_DIR, `mcp-${projectId}-${ideType}.sock`);
-  }
-  return path.join(BASE_DIR, `mcp-${projectId}.sock`);
-}
-function getDaemonSocketPath(projectId, env = process.env) {
-  return getSocketPath(projectId, resolveIdeTypeFromEnv(env));
-}
-function ensureBaseDir() {
-  fs.mkdirSync(BASE_DIR, { recursive: true });
-  return BASE_DIR;
-}
-function isMemoraoneSocketFilename(filename) {
-  return SOCKET_PROJECT_ID_RE.test(path.basename(filename));
-}
-function extractProjectIdFromSocketFilename(filename) {
-  const match = path.basename(filename).match(SOCKET_PROJECT_ID_RE);
-  return match ? match[1].toLowerCase() : null;
-}
-function isSocketFilenameForProject(filename, projectId) {
-  const extracted = extractProjectIdFromSocketFilename(filename);
-  return extracted !== null && extracted === projectId.trim().toLowerCase();
-}
-function extractIdeTypeFromSocketFilename(filename) {
-  const match = path.basename(filename).match(SOCKET_PROJECT_ID_RE);
-  if (!match) return null;
-  const suffix = match[2];
-  if (suffix === void 0) return "legacy";
-  if (IDE_TYPE_SET.has(suffix)) return suffix;
-  return null;
-}
-function isSocketFilenameForProjectAndIde(filename, projectId, ide) {
-  if (!isSocketFilenameForProject(filename, projectId)) return false;
-  if (ide === void 0) return true;
-  const socketIde = extractIdeTypeFromSocketFilename(filename);
-  if (socketIde === null) return false;
-  if (ide === "cursor") {
-    return socketIde === "cursor" || socketIde === "legacy";
+var BINDING_SOCKET_HASH_LENGTH = 16;
+function hashBindingIdentity(projectId, workspaceRoot, ideType) {
+  const input2 = [
+    projectId.trim().toLowerCase(),
+    path.resolve(workspaceRoot),
+    ideType
+  ].join("|");
+  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);
+}
+function formatMissingInitializeWorkspaceError(options) {
+  const lines = [
+    "[memoraone-mcp] Could not resolve workspace from MCP initialize params."
+  ];
+  if (options?.rootsListAttempted) {
+    lines.push(
+      "Cursor initialize lacked workspaceFolders/rootUri; roots/list was attempted but returned no usable repo root."
+    );
+    if (options.rootsListUris && options.rootsListUris.length > 0) {
+      lines.push(`roots/list URIs: ${options.rootsListUris.join(", ")}`);
+    }
+    lines.push(
+      "Global Cursor MCP cannot safely bind per-window repos without a workspace signal from Cursor (initialize roots or roots/list)."
+    );
+    lines.push(
+      "Reload MCP in this Cursor window, or ensure this repo has a managed .cursor/mcp.json from setup-ide-files --cursor."
+    );
+    return lines.join("\n");
   }
-  return socketIde === ide;
+  lines.push(
+    "Reload MCP in this Cursor window so initialize includes workspaceFolders, rootUri, or a usable roots/list response for this repo."
+  );
+  return lines.join("\n");
 }
 
+// src/bindingSidecar.ts
+var fs3 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+
 // src/projectBinding.ts
-var fs2 = __toESM(require("fs/promises"), 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;
 function normalizeEnvironment(raw) {
@@ -183,7 +152,7 @@ async function resolveProjectIdFromExplicitM1Path() {
   }
   const markerPath = path2.resolve(raw);
   try {
-    const content = await fs2.readFile(markerPath, "utf8");
+    const content = await fs.readFile(markerPath, "utf8");
     const { projectId, apiKey, environment } = parseAndValidateM1(content, markerPath);
     return environment === void 0 ? { projectId, apiKey, foundAt: markerPath } : { projectId, apiKey, environment, foundAt: markerPath };
   } catch (err) {
@@ -198,7 +167,7 @@ async function findM1WalkingUp(workspaceRoot) {
   while (true) {
     const markerPath = path2.join(current, "memoraone.m1");
     try {
-      const content = await fs2.readFile(markerPath, "utf8");
+      const content = await fs.readFile(markerPath, "utf8");
       const { projectId, apiKey, environment } = parseAndValidateM1(content, markerPath);
       const repoRoot = path2.dirname(markerPath);
       return environment === void 0 ? { projectId, apiKey, repoRoot, markerPath } : { projectId, apiKey, environment, repoRoot, markerPath };
@@ -252,29 +221,33 @@ function resolveApiKeyWithSource(fileApiKey) {
   }
   return { apiKey: null, apiKeySource: "none" };
 }
-async function resolveAuthoritativeBinding(workspaceRoot) {
-  const explicitBinding = await resolveProjectIdFromExplicitM1Path();
-  if (explicitBinding) {
-    const resolved = resolveApiKeyWithSource(explicitBinding.apiKey);
-    return {
-      projectId: explicitBinding.projectId,
-      workspaceRoot: path2.dirname(explicitBinding.foundAt),
-      m1Path: explicitBinding.foundAt,
-      apiKey: resolved.apiKey,
-      ...explicitBinding.environment !== void 0 ? { environment: explicitBinding.environment } : {},
-      bindingSource: "explicit-m1-path",
-      apiKeySource: resolved.apiKeySource
-    };
+async function resolveAuthoritativeBinding(workspaceRoot, options = {}) {
+  const respectExplicitM1Path = options.respectExplicitM1Path !== false;
+  if (respectExplicitM1Path) {
+    const explicitBinding = await resolveProjectIdFromExplicitM1Path();
+    if (explicitBinding) {
+      const resolved = resolveApiKeyWithSource(explicitBinding.apiKey);
+      return {
+        projectId: explicitBinding.projectId,
+        workspaceRoot: path2.dirname(explicitBinding.foundAt),
+        m1Path: explicitBinding.foundAt,
+        apiKey: resolved.apiKey,
+        ...explicitBinding.environment !== void 0 ? { environment: explicitBinding.environment } : {},
+        bindingSource: "explicit-m1-path",
+        apiKeySource: resolved.apiKeySource
+      };
+    }
   }
   const candidates = normalizeWorkspaceSearchRoots(workspaceRoot);
   if (candidates.length === 0) {
     throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
   }
+  const bindings = [];
   for (const root of candidates) {
     const binding = await findM1WalkingUp(root);
     if (binding) {
       const resolved = resolveApiKeyWithSource(binding.apiKey);
-      return {
+      bindings.push({
         projectId: binding.projectId,
         workspaceRoot: binding.repoRoot,
         m1Path: binding.markerPath,
@@ -282,159 +255,1339 @@ async function resolveAuthoritativeBinding(workspaceRoot) {
         ...binding.environment !== void 0 ? { environment: binding.environment } : {},
         bindingSource: "workspace-search",
         apiKeySource: resolved.apiKeySource
-      };
+      });
     }
   }
-  throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
+  if (bindings.length === 0) {
+    throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
+  }
+  const distinctProjectIds = new Set(bindings.map((b) => b.projectId));
+  if (distinctProjectIds.size > 1) {
+    const lines = bindings.map(
+      (b) => `  - workspace=${b.workspaceRoot} project=${b.projectId} m1=${b.m1Path}`
+    );
+    throw new Error(
+      "[memoraone-mcp] Ambiguous workspace binding: multiple open roots map to different MemoraOne projects.\n" + lines.join("\n") + "\nOpen one repo per Cursor window, or use repo-scoped .cursor/mcp.json from setup-ide-files --cursor."
+    );
+  }
+  return bindings[0];
 }
 function encodeResolvedBinding(binding) {
   return Buffer.from(JSON.stringify(binding), "utf8").toString("base64");
 }
-
-// src/setupIdeFiles.ts
-var fs6 = __toESM(require("fs/promises"), 1);
-var os4 = __toESM(require("os"), 1);
-var path6 = __toESM(require("path"), 1);
-
-// src/cleanup.ts
-var fs3 = __toESM(require("fs/promises"), 1);
-var path3 = __toESM(require("path"), 1);
-var readline = __toESM(require("readline/promises"), 1);
-var import_node_child_process = require("child_process");
-var import_node_util = require("util");
-var import_node_process = require("process");
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.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")) {
+function decodeResolvedBinding(value) {
+  if (!value) {
     return null;
   }
-  const match = commandLine.match(DAEMON_PROJECT_ID_RE);
-  return match ? match[1].toLowerCase() : null;
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(value, "base64").toString("utf8"));
+  } catch {
+    throw new Error("[memoraone-mcp] Invalid encoded binding payload");
+  }
+  const projectId = parsed?.projectId;
+  const workspaceRoot = parsed?.workspaceRoot;
+  const m1Path = parsed?.m1Path;
+  const apiKey = parsed?.apiKey;
+  const environment = normalizeEnvironment(parsed?.environment);
+  const bindingSource = parsed?.bindingSource;
+  const apiKeySource = parsed?.apiKeySource;
+  if (!projectId || typeof projectId !== "string" || !uuidRegex.test(projectId.trim())) {
+    throw new Error("[memoraone-mcp] Invalid binding projectId");
+  }
+  if (!workspaceRoot || typeof workspaceRoot !== "string") {
+    throw new Error("[memoraone-mcp] Invalid binding workspaceRoot");
+  }
+  if (!m1Path || typeof m1Path !== "string") {
+    throw new Error("[memoraone-mcp] Invalid binding m1Path");
+  }
+  if (apiKey !== null && apiKey !== void 0 && typeof apiKey !== "string") {
+    throw new Error("[memoraone-mcp] Invalid binding apiKey");
+  }
+  if (bindingSource !== "explicit-m1-path" && bindingSource !== "workspace-search") {
+    throw new Error("[memoraone-mcp] Invalid binding source");
+  }
+  if (apiKeySource !== "env" && apiKeySource !== "memoraone.m1" && apiKeySource !== "none") {
+    throw new Error("[memoraone-mcp] Invalid binding apiKeySource");
+  }
+  return {
+    projectId: projectId.trim(),
+    workspaceRoot,
+    m1Path,
+    apiKey: typeof apiKey === "string" && apiKey.trim() !== "" ? apiKey.trim() : null,
+    ...environment !== void 0 ? { environment } : {},
+    bindingSource,
+    apiKeySource
+  };
 }
-function parseDaemonIdeFromCommandLine(commandLine) {
-  if (!commandLine.includes("--daemon")) {
+
+// src/socketPaths.ts
+var os = __toESM(require("os"), 1);
+var path3 = __toESM(require("path"), 1);
+var fs2 = __toESM(require("fs"), 1);
+var BASE_DIR = process.env.MEMORAONE_MCP_LOCK_DIR || path3.join(os.homedir(), ".memoraone-mcp");
+var HASH_SOCKET_FILENAME_RE = new RegExp(
+  `^mcp-[0-9a-f]{${BINDING_SOCKET_HASH_LENGTH}}\\.sock$`,
+  "i"
+);
+var LEGACY_SOCKET_FILENAME_RE = /^mcp-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:-([0-9a-f]{12}))?(?:-(cursor|jetbrains|copilot-vscode))?\.sock$/i;
+var LEGACY_SOCKET_PROJECT_ID_RE = LEGACY_SOCKET_FILENAME_RE;
+function getMcpBaseDir() {
+  return BASE_DIR;
+}
+var IDE_TYPES = ["cursor", "copilot-vscode", "jetbrains"];
+var IDE_TYPE_SET = new Set(IDE_TYPES);
+function parseIdeType(value) {
+  if (value === void 0 || value.trim() === "" || !IDE_TYPE_SET.has(value)) {
     return void 0;
   }
-  return parseIdeTypeFromCommandLine(commandLine);
+  return value;
 }
-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 resolveIdeTypeFromEnv(env = process.env) {
+  return parseIdeType(env.MEMORAONE_IDE_TYPE);
 }
-function normalizeCleanupProjectId(projectId) {
-  const trimmed = projectId.trim();
-  if (!PROJECT_ID_RE.test(trimmed)) {
-    return { error: `Invalid project id: ${projectId}` };
+function parseIdeTypeFromCommandLine(commandLine) {
+  const match = commandLine.match(/--ide\s+(cursor|copilot-vscode|jetbrains)(?:\s|$)/);
+  return match ? match[1] : void 0;
+}
+function buildDaemonSpawnArgs(scriptPath, projectId, env = process.env) {
+  const args2 = [scriptPath, "--daemon", "--project-id", projectId];
+  const ideType = resolveIdeTypeFromEnv(env);
+  if (ideType) {
+    args2.push("--ide", ideType);
   }
-  return trimmed.toLowerCase();
+  return args2;
 }
-async function defaultListDaemonProcesses() {
-  const { stdout } = await execFileAsync("ps", ["-eo", "pid=,args="], {
-    maxBuffer: 10 * 1024 * 1024
-  });
-  return parseDaemonProcessLines(stdout.split("\n"));
+function resolveBindingIdeType(env = process.env) {
+  return resolveIdeTypeFromEnv(env) ?? "";
 }
-async function defaultListSocketPaths(projectId) {
-  const baseDir = getMcpBaseDir();
-  let entries;
-  try {
-    entries = await fs3.readdir(baseDir);
-  } catch (err) {
-    const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
-    if (code === "ENOENT") {
-      return [];
-    }
-    throw err;
-  }
-  const paths = [];
-  for (const name of entries) {
-    if (projectId === null) {
-      if (isMemoraoneSocketFilename(name)) {
-        paths.push(path3.join(baseDir, name));
-      }
-    } else if (isSocketFilenameForProject(name, projectId)) {
-      paths.push(path3.join(baseDir, name));
-    }
-  }
-  return paths.sort();
+function getBindingSocketFilename(binding, env = process.env) {
+  const ideType = resolveBindingIdeType(env);
+  const hash = hashBindingIdentity(binding.projectId, binding.workspaceRoot, ideType);
+  return `mcp-${hash}.sock`;
 }
-function filterSocketPathsByIde(socketPaths, projectId, ide) {
-  if (ide === void 0) return socketPaths;
-  return socketPaths.filter(
-    (socketPath) => isSocketFilenameForProjectAndIde(path3.basename(socketPath), projectId, ide)
-  );
+function getBindingSocketPath(binding, env = process.env) {
+  return path3.join(BASE_DIR, getBindingSocketFilename(binding, env));
 }
-async function defaultKillProcess(pid) {
-  process.kill(pid, "SIGTERM");
+function ensureBaseDir() {
+  fs2.mkdirSync(BASE_DIR, { recursive: true });
+  return BASE_DIR;
 }
-async function defaultRemoveSocket(socketPath) {
-  await fs3.unlink(socketPath);
+function isHashSocketFilename(filename) {
+  return HASH_SOCKET_FILENAME_RE.test(path3.basename(filename));
 }
-async function defaultConfirm(message) {
-  if (!import_node_process.stdin.isTTY) {
-    return false;
+function isLegacySocketFilename(filename) {
+  return LEGACY_SOCKET_FILENAME_RE.test(path3.basename(filename));
+}
+function isMemoraoneSocketFilename(filename) {
+  const base = path3.basename(filename);
+  return HASH_SOCKET_FILENAME_RE.test(base) || LEGACY_SOCKET_PROJECT_ID_RE.test(base);
+}
+function extractProjectIdFromSocketFilename(filename) {
+  const match = path3.basename(filename).match(LEGACY_SOCKET_PROJECT_ID_RE);
+  return match ? match[1].toLowerCase() : null;
+}
+function isSocketFilenameForProject(filename, projectId) {
+  const extracted = extractProjectIdFromSocketFilename(filename);
+  return extracted !== null && extracted === projectId.trim().toLowerCase();
+}
+function extractIdeTypeFromSocketFilename(filename) {
+  const match = path3.basename(filename).match(LEGACY_SOCKET_FILENAME_RE);
+  if (!match) return null;
+  const ide = match[3];
+  if (ide === void 0) return "legacy";
+  if (IDE_TYPE_SET.has(ide)) return ide;
+  return null;
+}
+function isSocketFilenameForProjectAndIde(filename, projectId, ide) {
+  if (!isSocketFilenameForProject(filename, projectId)) return false;
+  if (ide === void 0) return true;
+  const socketIde = extractIdeTypeFromSocketFilename(filename);
+  if (socketIde === null) return false;
+  if (ide === "cursor") {
+    return socketIde === "cursor" || socketIde === "legacy";
   }
-  const rl = readline.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();
+  return socketIde === ide;
+}
+
+// src/bindingSidecar.ts
+function bindingSidecarPath(socketPath) {
+  if (socketPath.endsWith(".sock")) {
+    return `${socketPath.slice(0, -".sock".length)}.binding.json`;
   }
+  return `${socketPath}.binding.json`;
 }
-async function resolveCleanupTarget(cwd) {
+function parseSidecarRecord(raw) {
   try {
-    const binding = await resolveAuthoritativeBinding([path3.resolve(cwd)]);
+    const parsed = JSON.parse(raw);
+    if (!parsed?.binding) {
+      return null;
+    }
+    const binding = decodeResolvedBinding(parsed.binding);
     return {
-      workspaceRoot: binding.workspaceRoot,
-      m1Path: binding.m1Path,
-      projectId: binding.projectId
+      v: typeof parsed.v === "number" ? parsed.v : 1,
+      ...parsed.ideType ? { ideType: parsed.ideType } : {},
+      projectId: parsed.projectId ?? binding.projectId,
+      workspaceRoot: parsed.workspaceRoot ?? binding.workspaceRoot,
+      m1Path: parsed.m1Path ?? binding.m1Path,
+      binding: parsed.binding
     };
   } catch {
-    return { error: CLEANUP_PROJECT_ID_REQUIRED_ERROR };
+    return null;
   }
 }
-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);
-    }
+function readBindingSidecarRecord(socketPath) {
+  try {
+    const raw = fs3.readFileSync(bindingSidecarPath(socketPath), "utf8");
+    return parseSidecarRecord(raw);
+  } catch {
+    return null;
   }
-  return { matching, skipped };
+}
+function formatBindingMismatchError(socketPath, sidecar, expected, detail) {
+  const lines = [
+    `[memoraone-mcp] Daemon socket binding mismatch at ${path4.basename(socketPath)}.`,
+    `  socket: project=${sidecar.projectId} workspace=${sidecar.workspaceRoot} m1=${sidecar.m1Path}`,
+    `  session: project=${expected.projectId} workspace=${expected.workspaceRoot} m1=${expected.m1Path}`
+  ];
+  if (detail) {
+    lines.push(`  ${detail}`);
+  }
+  lines.push("Reload MCP in this IDE window or run memoraone-mcp cleanup for the stale socket.");
+  return lines.join("\n");
+}
+function verifyDaemonSidecarBinding(socketPath, expected, env = process.env) {
+  const record = readBindingSidecarRecord(socketPath);
+  if (!record) {
+    return null;
+  }
+  const sidecar = decodeResolvedBinding(record.binding);
+  if (!bindingsMatch(sidecar, expected)) {
+    throw new Error(formatBindingMismatchError(socketPath, sidecar, expected));
+  }
+  const expectedIdeType = resolveBindingIdeType(env);
+  if (record.ideType !== void 0 && record.ideType !== expectedIdeType) {
+    throw new Error(
+      formatBindingMismatchError(
+        socketPath,
+        sidecar,
+        expected,
+        `ideType: socket=${record.ideType} session=${expectedIdeType || "(none)"}`
+      )
+    );
+  }
+  return sidecar;
+}
+
+// src/bridgeClientRoots.ts
+var readline = __toESM(require("readline"), 1);
+var TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+function isInitializeDebugEnabled(env = process.env) {
+  return TRUTHY.has(String(env.MEMORAONE_DEBUG_INIT ?? "").trim().toLowerCase());
+}
+function logInitializeDebug(log, env, msg) {
+  if (isInitializeDebugEnabled(env)) {
+    log(`[init-debug] ${msg}`);
+  }
+}
+function clientDeclaresRootsCapability(params) {
+  const capabilities = params?.capabilities;
+  if (capabilities === null || typeof capabilities !== "object") {
+    return false;
+  }
+  return Object.prototype.hasOwnProperty.call(capabilities, "roots");
+}
+function summarizeInitializeParamsForDebug(params) {
+  if (!params) {
+    return "(no params)";
+  }
+  const folders = Array.isArray(params.workspaceFolders) ? params.workspaceFolders.map((folder) => {
+    if (folder && typeof folder === "object") {
+      const entry = folder;
+      return { name: entry.name, uri: entry.uri };
+    }
+    return folder;
+  }) : params.workspaceFolders;
+  const capabilityKeys = params.capabilities && typeof params.capabilities === "object" ? Object.keys(params.capabilities) : [];
+  return JSON.stringify({
+    rootUri: params.rootUri,
+    workspaceFolders: folders,
+    clientInfo: params.clientInfo,
+    capabilityKeys
+  });
+}
+function extractRootsUrisFromListResult(result) {
+  if (result === null || typeof result !== "object") {
+    return [];
+  }
+  const roots = result.roots;
+  if (!Array.isArray(roots)) {
+    return [];
+  }
+  const uris = [];
+  for (const root of roots) {
+    if (root && typeof root === "object") {
+      const uri = root.uri;
+      if (typeof uri === "string" && uri.trim() !== "") {
+        uris.push(uri);
+      }
+    }
+  }
+  return uris;
+}
+var StdioLineReader = class {
+  constructor(input2) {
+    this.queue = [];
+    this.waiters = [];
+    this.closed = false;
+    this.rl = readline.createInterface({ input: input2, crlfDelay: Infinity });
+    this.rl.on("line", (line) => {
+      if (this.waiters.length > 0) {
+        this.waiters.shift()(line);
+        return;
+      }
+      this.queue.push(line);
+    });
+    this.rl.on("close", () => {
+      this.closed = true;
+      while (this.waiters.length > 0) {
+        this.waiters.shift()(null);
+      }
+    });
+  }
+  async readLine() {
+    if (this.queue.length > 0) {
+      return this.queue.shift() ?? null;
+    }
+    if (this.closed) {
+      return null;
+    }
+    return new Promise((resolve8) => {
+      this.waiters.push(resolve8);
+    });
+  }
+  /** Re-queue lines read during an intermediate protocol step (e.g. roots/list) for the main bridge loop. */
+  prependLines(lines) {
+    if (lines.length === 0) {
+      return;
+    }
+    for (let i = lines.length - 1; i >= 0; i--) {
+      this.queue.unshift(lines[i]);
+    }
+  }
+  close() {
+    this.rl.close();
+  }
+};
+var nextBridgeRequestId = 1e5;
+async function requestClientRootsListUris(options) {
+  const env = options.env ?? process.env;
+  const log = options.log ?? (() => {
+  });
+  const requestId = nextBridgeRequestId++;
+  const deferredLines = [];
+  const request = {
+    jsonrpc: "2.0",
+    id: requestId,
+    method: "roots/list",
+    params: {}
+  };
+  logInitializeDebug(
+    log,
+    env,
+    `sending roots/list id=${requestId} clientDeclaresRoots=${clientDeclaresRootsCapability(options.initializeParams)}`
+  );
+  options.stdout.write(`${JSON.stringify(request)}
+`);
+  while (true) {
+    const line = await options.lineReader.readLine();
+    if (line === null) {
+      throw new Error("[memoraone-mcp] Client closed stdin before roots/list response");
+    }
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      continue;
+    }
+    let message;
+    try {
+      message = JSON.parse(trimmed);
+    } catch (err) {
+      logInitializeDebug(log, env, `ignored non-JSON line while waiting for roots/list: ${String(err)}`);
+      continue;
+    }
+    if (message.id !== requestId) {
+      logInitializeDebug(
+        log,
+        env,
+        `deferred JSON-RPC while waiting for roots/list id=${requestId}: ${trimmed.slice(0, 200)}`
+      );
+      deferredLines.push(trimmed);
+      continue;
+    }
+    if (message.error) {
+      throw new Error(
+        `[memoraone-mcp] roots/list failed: ${JSON.stringify(message.error)}`
+      );
+    }
+    const uris = extractRootsUrisFromListResult(message.result);
+    logInitializeDebug(log, env, `roots/list id=${requestId} returned ${uris.length}: ${JSON.stringify(uris)}`);
+    return { uris, deferredLines };
+  }
+}
+
+// src/initializeBinding.ts
+var path5 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var MEMORAONE_WORKSPACE_ROOT_ENV = "MEMORAONE_WORKSPACE_ROOT";
+function getBridgeBindingResolveOptions(env = process.env) {
+  const ideType = resolveIdeTypeFromEnv(env);
+  if (ideType === "cursor") {
+    return { respectExplicitM1Path: false, allowEnvWorkspaceFallback: false };
+  }
+  return { respectExplicitM1Path: true, allowEnvWorkspaceFallback: true };
+}
+function uriToPath(uri) {
+  if (uri.startsWith("file://")) {
+    return (0, import_node_url.fileURLToPath)(uri);
+  }
+  return uri;
+}
+function getEnvWorkspaceRootCandidates() {
+  const raw = process.env.WORKSPACE_FOLDER_PATHS;
+  const parts = [];
+  if (raw !== void 0 && raw.trim() !== "") {
+    for (const p of raw.split(path5.delimiter).map((s) => s.trim()).filter(Boolean)) {
+      parts.push(path5.resolve(p));
+    }
+  }
+  parts.push(process.cwd());
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const p of parts) {
+    if (!seen.has(p)) {
+      seen.add(p);
+      deduped.push(p);
+    }
+  }
+  return deduped;
+}
+function extractWorkspaceRootsFromInitialize(params) {
+  if (!params) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const roots = [];
+  const addRoot = (uri) => {
+    if (uri === void 0 || uri.trim() === "") {
+      return;
+    }
+    const resolved = path5.resolve(uriToPath(uri));
+    if (!seen.has(resolved)) {
+      seen.add(resolved);
+      roots.push(resolved);
+    }
+  };
+  if (Array.isArray(params.workspaceFolders) && params.workspaceFolders.length > 0) {
+    for (const folder of params.workspaceFolders) {
+      addRoot(folder?.uri);
+    }
+    return roots;
+  }
+  if (params.rootUri) {
+    addRoot(params.rootUri);
+  }
+  return roots;
+}
+function getRepoScopedWorkspaceHint(env = process.env) {
+  const raw = env[MEMORAONE_WORKSPACE_ROOT_ENV];
+  if (raw === void 0 || raw.trim() === "") {
+    return null;
+  }
+  return path5.resolve(raw.trim());
+}
+function formatWorkspaceAmbiguityError(bindings) {
+  const lines = bindings.map(
+    (b) => `  - workspace=${b.workspaceRoot} project=${b.projectId} m1=${b.m1Path}`
+  );
+  return "[memoraone-mcp] Ambiguous workspace binding: multiple open roots map to different MemoraOne projects.\n" + lines.join("\n") + `
+Open one repo per Cursor window, or ensure this repo's managed .cursor/mcp.json includes ${MEMORAONE_WORKSPACE_ROOT_ENV} from setup-ide-files --cursor.`;
+}
+function formatRepoHintInitializeMismatchError(repoHintRoot, initializeBinding) {
+  return `[memoraone-mcp] Repo-scoped workspace hint conflicts with MCP initialize workspace.
+  ${MEMORAONE_WORKSPACE_ROOT_ENV}: ${repoHintRoot}
+  initialize: project=${initializeBinding.projectId} workspace=${initializeBinding.workspaceRoot} m1=${initializeBinding.m1Path}
+Reload MCP in the Cursor window for this repo, or re-run setup-ide-files --cursor here if the hint is stale.`;
+}
+function formatRepoHintNotInRootsListError(repoHintRoot, rootsListPaths) {
+  return `[memoraone-mcp] Repo-scoped workspace hint does not match any Cursor roots/list entry.
+  ${MEMORAONE_WORKSPACE_ROOT_ENV}: ${repoHintRoot}
+  roots/list paths: ${rootsListPaths.join(", ")}
+Reload MCP in the Cursor window for this repo, or re-run setup-ide-files --cursor if the hint is stale.`;
+}
+async function resolveBindingFromWorkspaceRoots(workspaceRoots, options = {}) {
+  if (workspaceRoots.length === 0) {
+    throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
+  }
+  const bindings = [];
+  for (const root of workspaceRoots) {
+    try {
+      bindings.push(
+        await resolveAuthoritativeBinding(root, {
+          respectExplicitM1Path: options.respectExplicitM1Path
+        })
+      );
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("Could not find memoraone.m1")) {
+        continue;
+      }
+      throw err;
+    }
+  }
+  if (bindings.length === 0) {
+    throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
+  }
+  const distinctProjectIds = new Set(bindings.map((b) => b.projectId));
+  if (distinctProjectIds.size > 1) {
+    throw new Error(formatWorkspaceAmbiguityError(bindings));
+  }
+  return bindings[0];
+}
+async function resolveBindingFromInitializeParams(params, options = {}) {
+  const env = options.env ?? process.env;
+  const resolveOpts = {
+    respectExplicitM1Path: options.respectExplicitM1Path,
+    allowEnvWorkspaceFallback: options.allowEnvWorkspaceFallback
+  };
+  const repoHint = getRepoScopedWorkspaceHint(env);
+  const initializeRoots = extractWorkspaceRootsFromInitialize(params);
+  if (initializeRoots.length > 0) {
+    const binding = await resolveBindingFromWorkspaceRoots(initializeRoots, resolveOpts);
+    if (repoHint !== null) {
+      const hintBinding = await resolveAuthoritativeBinding(repoHint, {
+        respectExplicitM1Path: false
+      });
+      if (!bindingsMatch(binding, hintBinding)) {
+        throw new Error(formatRepoHintInitializeMismatchError(repoHint, binding));
+      }
+    }
+    return binding;
+  }
+  const rootsListUris = options.rootsListUris ?? [];
+  const rootsListPaths = rootsListUris.map((uri) => uriToPath(uri)).filter(Boolean);
+  if (rootsListPaths.length > 1 && repoHint !== null) {
+    const hintResolved = path5.resolve(repoHint);
+    const matchingRoot = rootsListPaths.find((root) => path5.resolve(root) === hintResolved);
+    if (!matchingRoot) {
+      throw new Error(formatRepoHintNotInRootsListError(repoHint, rootsListPaths));
+    }
+    return resolveAuthoritativeBinding(repoHint, { respectExplicitM1Path: false });
+  }
+  if (rootsListPaths.length > 0) {
+    return resolveBindingFromWorkspaceRoots(rootsListPaths, resolveOpts);
+  }
+  if (repoHint !== null) {
+    return resolveAuthoritativeBinding(repoHint, { respectExplicitM1Path: false });
+  }
+  if (options.allowEnvWorkspaceFallback === false) {
+    throw new Error(
+      formatMissingInitializeWorkspaceError({
+        rootsListAttempted: options.rootsListAttempted === true,
+        rootsListUris
+      })
+    );
+  }
+  const fallbackRoots = options.fallbackWorkspaceRoots ?? getEnvWorkspaceRootCandidates();
+  return resolveAuthoritativeBinding(fallbackRoots, {
+    respectExplicitM1Path: options.respectExplicitM1Path
+  });
+}
+
+// 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)}`;
+    }
+    return "jsonrpc";
+  } catch {
+    return "invalid-json";
+  }
+}
+function connectWithRetry(socketPath, log, maxRetries, retryDelayMs, connect2) {
+  return new Promise((resolve8, reject) => {
+    const tryConnect = (attempt) => {
+      connect2(socketPath).then(resolve8).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 connectOrSpawnDaemonForBinding(binding, opts) {
+  const socketPath = getBindingSocketPath(binding, opts.env);
+  opts.log(
+    `target daemon socket=${socketPath} project=${binding.projectId} workspace=${binding.workspaceRoot}`
+  );
+  let socket;
+  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;
+    }
+  }
+  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((resolve8, reject) => {
+      const socket = net.connect(socketPath, () => resolve8(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;
+  }
+  hasClientInitialize() {
+    return this.clientInitializeSeen;
+  }
+  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");
+  }
+  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;
+    }
+    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 writeToDaemon(line) {
+    await this.ensureActiveDaemonSocket();
+    this.activeSocket.write(`${line}
+`);
+  }
+  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 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);
+  }
+  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");
+    }
+    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}
+`);
+      }
+    }
+  }
+  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;
+    }
+  }
+};
+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);
+  }
+}
+
+// src/setupIdeFiles.ts
+var fs7 = __toESM(require("fs/promises"), 1);
+var os4 = __toESM(require("os"), 1);
+var path9 = __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);
+function buildMemoraoneCursorMcpServer(npxPath, workspaceRoot) {
+  const env = {
+    MEMORAONE_API_URL: "https://api.memoraone.com",
+    MEMORAONE_IDE_TYPE: "cursor"
+  };
+  if (workspaceRoot !== void 0) {
+    env[MEMORAONE_WORKSPACE_ROOT_ENV] = path6.resolve(workspaceRoot);
+  }
+  return {
+    command: npxPath,
+    args: ["-y", "@memoraone/mcp@latest"],
+    env
+  };
+}
+async function pathExists(filePath) {
+  try {
+    await fs4.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+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
+    };
+  }
+  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 };
+}
+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 isWorkingNpx(npxPath) {
+  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;
+  } 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");
+  }
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  for (const dir of (process.env.PATH ?? "").split(pathSep)) {
+    if (!dir) continue;
+    candidates.push(path6.join(dir, npxName));
+  }
+  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 {
+  }
+  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, npxPath, repoRoot) {
+  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(npxPath, repoRoot);
+  return { ...base, mcpServers };
+}
+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 memoraoneEnvMatchesBase(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 memoraoneEnvMatchesBase(env) {
+  return env.MEMORAONE_API_URL === "https://api.memoraone.com" && env.MEMORAONE_IDE_TYPE === "cursor";
+}
+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 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 };
+  }
+  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;
+  }
+  let globalHasManagedMemoraone = false;
+  if (globalDetection.ok) {
+    try {
+      const globalParsed = await readCursorMcpConfigObject(globalConfigPath);
+      globalHasManagedMemoraone = cursorConfigHasManagedMemoraone(globalParsed);
+    } catch {
+      globalHasManagedMemoraone = false;
+    }
+  }
+  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) {
+  const { repoConfigPath, repoOutcome, npxPath, repoBackupPath, globalConfigPath, globalMemoraoneRemoved, globalBackupPath } = info;
+  console.log(`[setup-ide-files] Cursor repo MCP config: ${repoConfigPath}`);
+  console.log(`[setup-ide-files] Resolved npx: ${npxPath}`);
+  if (repoBackupPath) {
+    console.log(`[setup-ide-files] Cursor repo MCP config backup: ${repoBackupPath}`);
+  }
+  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}`
+    );
+  } 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}`);
+    }
+  } else if (globalConfigPath) {
+    console.log(
+      `[setup-ide-files] Cursor global MCP config unchanged (no managed memoraone to remove): ${globalConfigPath}`
+    );
+  }
+  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;
+  }
+  const match = commandLine.match(DAEMON_PROJECT_ID_RE);
+  return match ? match[1].toLowerCase() : null;
+}
+function parseDaemonIdeFromCommandLine(commandLine) {
+  if (!commandLine.includes("--daemon")) {
+    return void 0;
+  }
+  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 } : {} });
+  }
+  return processes;
+}
+function normalizeCleanupProjectId(projectId) {
+  const trimmed = projectId.trim();
+  if (!PROJECT_ID_RE.test(trimmed)) {
+    return { error: `Invalid project id: ${projectId}` };
+  }
+  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 [];
+    }
+    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);
+      }
+    }
+  }
+  return paths.sort();
+}
+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);
+      }
+      continue;
+    }
+    if (isHashSocketFilename(basename4)) {
+      const record = readBindingSidecarRecord(socketPath);
+      if (record?.projectId.trim().toLowerCase() === normalizedProjectId && record.ideType === ide) {
+        filtered.push(socketPath);
+      }
+    }
+  }
+  return filtered;
+}
+async function defaultKillProcess(pid) {
+  process.kill(pid, "SIGTERM");
+}
+async function defaultRemoveSocket(socketPath) {
+  await fs5.unlink(socketPath);
+  try {
+    await fs5.unlink(bindingSidecarPath(socketPath));
+  } catch {
+  }
+}
+async function defaultConfirm(message) {
+  if (!import_node_process.stdin.isTTY) {
+    return false;
+  }
+  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();
+  }
+}
+async function resolveCleanupTarget(cwd) {
+  try {
+    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 };
+  }
+}
+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 logPrefix(dryRun) {
   return dryRun ? "[cleanup][dry-run]" : "[cleanup]";
 }
-function logReconnectNotice(prefix, ide) {
+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.`
@@ -445,6 +1598,16 @@ function logReconnectNotice(prefix, ide) {
     );
   }
 }
+function cleanupLog(opts, message) {
+  if (!opts.quiet) {
+    console.log(message);
+  }
+}
+function cleanupWarn(opts, message) {
+  if (!opts.quiet) {
+    console.warn(message);
+  }
+}
 async function runCleanup(opts) {
   const listProcesses = opts.listProcesses ?? defaultListDaemonProcesses;
   const listSocketPaths = opts.listSocketPaths ?? defaultListSocketPaths;
@@ -465,8 +1628,9 @@ async function runCleanup(opts) {
         error: "Cannot combine --all-projects with --project-id."
       };
     }
-    console.log(`${prefix} Mode: all projects (--all-projects)`);
-    console.warn(
+    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) {
@@ -475,9 +1639,9 @@ async function runCleanup(opts) {
       return { exitCode: 1, killedPids: [], removedSockets: [], skippedProcesses: [], error: normalized.error };
     }
     targetProjectId = normalized;
-    console.log(`${prefix} Project id: ${targetProjectId}`);
+    cleanupLog(opts, `${prefix} Project id: ${targetProjectId}`);
     if (opts.ide) {
-      console.log(`${prefix} IDE filter: ${opts.ide}`);
+      cleanupLog(opts, `${prefix} IDE filter: ${opts.ide}`);
     }
   } else {
     const target = await resolveCleanupTarget(opts.cwd);
@@ -487,15 +1651,23 @@ async function runCleanup(opts) {
     targetProjectId = target.projectId;
     workspaceRoot = target.workspaceRoot;
     m1Path = target.m1Path;
-    console.log(`${prefix} Workspace root: ${workspaceRoot}`);
-    console.log(`${prefix} memoraone.m1: ${m1Path}`);
-    console.log(`${prefix} Project id: ${targetProjectId}`);
+    cleanupLog(opts, `${prefix} Workspace root: ${workspaceRoot}`);
+    cleanupLog(opts, `${prefix} memoraone.m1: ${m1Path}`);
+    cleanupLog(opts, `${prefix} Project id: ${targetProjectId}`);
     if (opts.ide) {
-      console.log(`${prefix} IDE filter: ${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)}`);
+      }
     }
   }
   if (targetProjectId !== null || opts.ide) {
-    logReconnectNotice(prefix, opts.ide);
+    logReconnectNotice(opts, prefix, opts.ide);
   }
   const allDaemonProcesses = await listProcesses();
   const { matching: projectProcesses, skipped: skippedProcesses } = filterProcessesForScope(
@@ -511,392 +1683,198 @@ async function runCleanup(opts) {
         processesToStop.push(proc);
       } else if (proc.ide === void 0) {
         ideSkippedProcesses.push(proc);
-        console.log(
+        cleanupLog(
+          opts,
           `${prefix} Skipped daemon pid=${proc.pid} because IDE could not be safely determined.`
         );
       } else {
         ideSkippedProcesses.push(proc);
-        console.log(
+        cleanupLog(
+          opts,
           `${prefix} Skipped daemon pid=${proc.pid} (IDE ${proc.ide} does not match filter ${opts.ide}).`
         );
       }
     }
   }
   const allSocketPaths = await listSocketPaths(targetProjectId);
-  const socketPaths = targetProjectId === null ? allSocketPaths : filterSocketPathsByIde(allSocketPaths, targetProjectId, opts.ide);
+  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);
     }
     for (const socketPath of socketPaths) {
-      const id = extractProjectIdFromSocketFilename(path3.basename(socketPath));
-      if (id) projectIds.add(id);
+      const id = extractProjectIdFromSocketFilename(path7.basename(socketPath));
+      if (id) {
+        projectIds.add(id);
+        continue;
+      }
+      const record = readBindingSidecarRecord(socketPath);
+      if (record) {
+        projectIds.add(record.projectId.trim().toLowerCase());
+      }
     }
-    console.log(`${prefix} Projects affected: ${projectIds.size ? [...projectIds].sort().join(", ") : "(none found)"}`);
+    cleanupLog(
+      opts,
+      `${prefix} Projects affected: ${projectIds.size ? [...projectIds].sort().join(", ") : "(none found)"}`
+    );
   }
   if (processesToStop.length) {
-    console.log(`${prefix} Daemon processes to stop:`);
+    cleanupLog(opts, `${prefix} Daemon processes to stop:`);
     for (const proc of processesToStop) {
       const ideLabel = proc.ide ? ` ide=${proc.ide}` : "";
-      console.log(`${prefix}   pid=${proc.pid} project=${proc.projectId}${ideLabel}`);
-    }
-  } else if (ideSkippedProcesses.length) {
-    console.log(`${prefix} No matching daemon processes for IDE filter ${opts.ide}.`);
-  } else {
-    console.log(`${prefix} No matching daemon processes found.`);
-  }
-  if (socketPaths.length) {
-    console.log(`${prefix} Sockets to remove:`);
-    for (const socketPath of socketPaths) {
-      console.log(`${prefix}   ${socketPath}`);
-    }
-  } else {
-    console.log(`${prefix} No matching sockets found under ${getMcpBaseDir()}.`);
-  }
-  if (skippedProcesses.length) {
-    console.log(`${prefix} Skipped unrelated daemon processes:`);
-    for (const proc of skippedProcesses) {
-      console.log(`${prefix}   pid=${proc.pid} project=${proc.projectId}`);
-    }
-  }
-  if (opts.allProjects && !opts.dryRun) {
-    const ok = opts.assumeYes ? true : await confirm(`${prefix} Proceed with cleanup for ALL projects?`);
-    if (!ok) {
-      console.log(`${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 killedPids = [];
-  const removedSockets = [];
-  if (opts.dryRun) {
-    console.log(`${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) {
-    try {
-      await killProcess(proc.pid);
-      killedPids.push(proc.pid);
-      console.log(`${prefix} Stopped daemon pid=${proc.pid} project=${proc.projectId}`);
-    } catch (err) {
-      console.warn(`${prefix} Could not stop pid=${proc.pid}: ${String(err)}`);
-    }
-  }
-  if (killedPids.length) {
-    await new Promise((r) => setTimeout(r, 300));
-  }
-  for (const socketPath of socketPaths) {
-    try {
-      await removeSocket(socketPath);
-      removedSockets.push(socketPath);
-      console.log(`${prefix} Removed socket ${socketPath}`);
-    } catch (err) {
-      const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
-      if (code !== "ENOENT") {
-        console.warn(`${prefix} Could not remove socket ${socketPath}: ${String(err)}`);
-      }
-    }
-  }
-  console.log(`${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/cursorGlobalMcpConfig.ts
-var fs4 = __toESM(require("fs/promises"), 1);
-var os2 = __toESM(require("os"), 1);
-var path4 = __toESM(require("path"), 1);
-var import_node_child_process2 = require("child_process");
-var import_node_util2 = require("util");
-var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
-function buildMemoraoneCursorMcpServer(npxPath) {
-  return {
-    command: npxPath,
-    args: ["-y", "@memoraone/mcp@latest"],
-    env: {
-      MEMORAONE_API_URL: "https://api.memoraone.com",
-      MEMORAONE_IDE_TYPE: "cursor"
-    }
-  };
-}
-async function pathExists(filePath) {
-  try {
-    await fs4.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function stripLeadingLineComments(text) {
-  return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
-}
-function getKnownCursorGlobalMcpConfigCandidates(homeDir) {
-  return [path4.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
-    };
-  }
-  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 };
-}
-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 isWorkingNpx(npxPath) {
-  try {
-    if (!await pathExists(npxPath)) return false;
-    if (process.platform !== "win32") {
-      try {
-        await fs4.access(npxPath, fs4.constants.X_OK);
-      } catch {
-        return false;
-      }
-    }
-    await execFileAsync2(npxPath, ["--version"], { timeout: 1e4 });
-    return true;
-  } 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");
-  }
-  const pathSep = process.platform === "win32" ? ";" : ":";
-  for (const dir of (process.env.PATH ?? "").split(pathSep)) {
-    if (!dir) continue;
-    candidates.push(path4.join(dir, npxName));
-  }
-  try {
-    const lookupCmd = process.platform === "win32" ? "where" : "which";
-    const { stdout } = await execFileAsync2(lookupCmd, [npxName], { timeout: 5e3 });
-    const first = stdout.trim().split(/\r?\n/).map((line) => line.trim()).find(Boolean);
-    if (first) candidates.unshift(first);
-  } catch {
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const candidate of candidates) {
-    const abs = path4.isAbsolute(candidate) ? candidate : path4.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 mergeCursorGlobalMcpConfigObject(existing, npxPath) {
-  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(npxPath);
-  return { ...base, mcpServers };
-}
-function memoraoneServerMatches(server, npxPath) {
-  if (!server || typeof server !== "object") return false;
-  const s = server;
-  if (s.command !== npxPath) return false;
-  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;
-  const e = env;
-  return e.MEMORAONE_API_URL === "https://api.memoraone.com" && e.MEMORAONE_IDE_TYPE === "cursor";
-}
-function validateCursorGlobalMcpConfig(parsed, npxPath) {
-  if (!parsed || typeof parsed !== "object") {
-    throw new Error("[setup-ide-files] Cursor global MCP config must be a JSON object.");
+      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.`);
   }
-  const mcpServers = parsed.mcpServers;
-  if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
-    throw new Error("[setup-ide-files] Cursor global MCP config missing mcpServers object.");
+  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 memoraone = mcpServers.memoraone;
-  if (!memoraoneServerMatches(memoraone, npxPath)) {
-    throw new Error(
-      "[setup-ide-files] Cursor global MCP config mcpServers.memoraone is missing or invalid."
-    );
+  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 setupCursorGlobalMcpConfig(options) {
-  const { configPath, npxPath, dryRun } = options;
-  const existed = await pathExists(configPath);
-  let existing = null;
-  if (existed) {
-    const raw = await fs4.readFile(configPath, "utf8");
-    try {
-      existing = JSON.parse(stripLeadingLineComments(raw));
-    } catch {
-      throw new Error(
-        `[setup-ide-files] Invalid JSON in Cursor global MCP config: ${configPath}`
-      );
+  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 merged = mergeCursorGlobalMcpConfigObject(existing, npxPath);
-  const body = JSON.stringify(merged, null, 2) + "\n";
-  if (existed) {
-    const currentMemoraone = existing && typeof existing.mcpServers === "object" && existing.mcpServers !== null && !Array.isArray(existing.mcpServers) ? existing.mcpServers.memoraone : void 0;
-    if (memoraoneServerMatches(currentMemoraone, npxPath)) {
-      return { outcome: "skipped" };
+  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) {
+    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)}`);
     }
   }
-  if (dryRun) {
-    return { outcome: existed ? "updated" : "created" };
+  if (killedPids.length) {
+    await new Promise((r) => setTimeout(r, 300));
   }
-  let backupPath;
-  if (existed) {
-    backupPath = `${configPath}.backup-${formatBackupTimestamp()}`;
-    await fs4.copyFile(configPath, backupPath);
-  }
-  await fs4.mkdir(path4.dirname(configPath), { recursive: true });
-  await fs4.writeFile(configPath, body, "utf8");
-  const verifyRaw = await fs4.readFile(configPath, "utf8");
-  const verifyParsed = JSON.parse(stripLeadingLineComments(verifyRaw));
-  validateCursorGlobalMcpConfig(verifyParsed, npxPath);
-  return { outcome: existed ? "updated" : "created", backupPath };
-}
-function logCursorGlobalMcpCliSummary(info, dryRun) {
-  const { configPath, npxPath, backupPath, outcome } = info;
-  console.log(`[setup-ide-files] Cursor global MCP config: ${configPath}`);
-  console.log(`[setup-ide-files] Resolved npx: ${npxPath}`);
-  if (backupPath) {
-    console.log(`[setup-ide-files] Cursor global MCP config backup: ${backupPath}`);
+  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 (outcome === "created") {
-    console.log(
-      dryRun ? `[setup-ide-files] Cursor global MCP config would be created: ${configPath}` : `[setup-ide-files] Cursor global MCP config created: ${configPath}`
-    );
-  } else if (outcome === "updated") {
-    console.log(
-      dryRun ? `[setup-ide-files] Cursor global MCP config would be updated: ${configPath}` : `[setup-ide-files] Cursor global MCP config updated: ${configPath}`
+  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(", ")}.`
     );
-  } else if (outcome === "skipped") {
-    console.log(`[setup-ide-files] Cursor global MCP config unchanged: ${configPath}`);
+    return 1;
   }
-  console.log(
-    "[setup-ide-files] Repo-level .cursor/mcp.json was not created or modified."
-  );
-  console.log(
-    "[setup-ide-files] Fully quit Cursor and reopen this repo for MCP changes to take effect."
-  );
+  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/jetbrainsMcpConfig.ts
-var fs5 = __toESM(require("fs/promises"), 1);
+var fs6 = __toESM(require("fs/promises"), 1);
 var os3 = __toESM(require("os"), 1);
-var path5 = __toESM(require("path"), 1);
-var import_node_child_process3 = require("child_process");
+var path8 = __toESM(require("path"), 1);
+var import_node_child_process4 = require("child_process");
 
 // src/configUtils.ts
 var DEV_API_URL = "http://localhost:3001";
@@ -914,7 +1892,7 @@ function stripLeadingLineComments2(text) {
 }
 async function pathExists2(filePath) {
   try {
-    await fs5.access(filePath);
+    await fs6.access(filePath);
     return true;
   } catch {
     return false;
@@ -925,12 +1903,12 @@ function formatJetBrainsBackupTimestamp(d = /* @__PURE__ */ new Date()) {
   return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
 }
 function getJetBrainsGlobalMcpConfigPath(homeDir) {
-  return path5.join(homeDir, ".ai", "mcp", "mcp.json");
+  return path8.join(homeDir, ".ai", "mcp", "mcp.json");
 }
 function getJetBrainsProjectMcpConfigPaths(repoRoot) {
   return [
-    { kind: "project-ai", path: path5.join(repoRoot, ".ai", "mcp", "mcp.json") },
-    { kind: "project-ij", path: path5.join(repoRoot, ".ij", "mcp", "mcp.json") }
+    { kind: "project-ai", path: path8.join(repoRoot, ".ai", "mcp", "mcp.json") },
+    { kind: "project-ij", path: path8.join(repoRoot, ".ij", "mcp", "mcp.json") }
   ];
 }
 function getKnownJetBrainsMcpConfigLocations(homeDir, repoRoot) {
@@ -941,7 +1919,7 @@ function getKnownJetBrainsMcpConfigLocations(homeDir, repoRoot) {
 }
 async function isZeroByteConfigFile(filePath) {
   if (!await pathExists2(filePath)) return false;
-  const stat2 = await fs5.stat(filePath);
+  const stat2 = await fs6.stat(filePath);
   return stat2.size === 0;
 }
 function buildMemoraoneJetBrainsMcpServer(options) {
@@ -965,7 +1943,7 @@ function mergeJetBrainsMcpConfigObject(existing, memoraone) {
   mcpServers.memoraone = memoraone;
   return { ...base, mcpServers };
 }
-function memoraoneServerMatches2(server, expected) {
+function memoraoneServerMatches(server, expected) {
   if (!server || typeof server !== "object") return false;
   const s = server;
   if (s.command !== expected.command) return false;
@@ -993,20 +1971,20 @@ function validateJetBrainsMcpConfig(parsed, expected) {
     throw new Error("[setup-ide-files] JetBrains MCP config missing mcpServers object.");
   }
   const memoraone = mcpServers.memoraone;
-  if (!memoraoneServerMatches2(memoraone, expected)) {
+  if (!memoraoneServerMatches(memoraone, expected)) {
     throw new Error(
       "[setup-ide-files] JetBrains MCP config mcpServers.memoraone is missing or invalid."
     );
   }
 }
 async function readJsonConfig(filePath) {
-  const raw = await fs5.readFile(filePath, "utf8");
+  const raw = await fs6.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments2(raw));
 }
 async function backupConfigFile(filePath) {
   const backupPath = `${filePath}.bak-${formatJetBrainsBackupTimestamp()}`;
-  await fs5.copyFile(filePath, backupPath);
+  await fs6.copyFile(filePath, backupPath);
   return backupPath;
 }
 async function repairZeroByteConfigFile(filePath, dryRun) {
@@ -1017,7 +1995,7 @@ async function repairZeroByteConfigFile(filePath, dryRun) {
     return { repaired: true, backupPath: `${filePath}.bak-<timestamp>` };
   }
   const backupPath = await backupConfigFile(filePath);
-  await fs5.unlink(filePath);
+  await fs6.unlink(filePath);
   return { repaired: true, backupPath };
 }
 function configHasMemoraone(parsed) {
@@ -1048,24 +2026,24 @@ async function removeMemoraoneFromProjectConfig(options) {
   delete mcpServers.memoraone;
   const hasOtherServers = Object.keys(mcpServers).length > 0;
   if (!hasOtherServers) {
-    await fs5.unlink(configPath);
+    await fs6.unlink(configPath);
     return { changed: true, backupPath };
   }
   const next = { ...parsed, mcpServers };
-  await fs5.mkdir(path5.dirname(configPath), { recursive: true });
-  await fs5.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
+  await fs6.mkdir(path8.dirname(configPath), { recursive: true });
+  await fs6.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
   return { changed: true, backupPath };
 }
 async function resolveLocalCliPathAsync() {
-  const here = process.argv[1] ? path5.dirname(path5.resolve(process.argv[1])) : process.cwd();
+  const here = process.argv[1] ? path8.dirname(path8.resolve(process.argv[1])) : process.cwd();
   const candidates = [
-    path5.join(here, "cli.cjs"),
-    path5.join(here, "..", "dist", "cli.cjs"),
-    path5.join(here, "..", "..", "dist", "cli.cjs")
+    path8.join(here, "cli.cjs"),
+    path8.join(here, "..", "dist", "cli.cjs"),
+    path8.join(here, "..", "..", "dist", "cli.cjs")
   ];
   for (const candidate of candidates) {
     if (await pathExists2(candidate)) {
-      return path5.resolve(candidate);
+      return path8.resolve(candidate);
     }
   }
   return null;
@@ -1107,7 +2085,7 @@ async function buildJetBrainsMemoraoneServer(options) {
 async function verifyJetBrainsMcpHandshake(options) {
   const timeoutMs = options.timeoutMs ?? 15e3;
   const { server } = options;
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     let settled = false;
     const finish = (ok, detail) => {
       if (settled) return;
@@ -1117,9 +2095,9 @@ async function verifyJetBrainsMcpHandshake(options) {
         child.kill();
       } catch {
       }
-      resolve7({ ok, detail });
+      resolve8({ ok, detail });
     };
-    const child = (0, import_node_child_process3.spawn)(server.command, [...server.args], {
+    const child = (0, import_node_child_process4.spawn)(server.command, [...server.args], {
       env: { ...process.env, ...server.env },
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -1186,7 +2164,7 @@ async function verifyJetBrainsMcpHandshake(options) {
 async function setupJetBrainsMcpConfig(options) {
   const homeDir = options.homeDir ?? os3.homedir();
   const globalPath = options.globalConfigPath ?? getJetBrainsGlobalMcpConfigPath(homeDir);
-  const m1Path = path5.join(path5.resolve(options.repoRoot), "memoraone.m1");
+  const m1Path = path8.join(path8.resolve(options.repoRoot), "memoraone.m1");
   const repairActions = [];
   const allLocations = getKnownJetBrainsMcpConfigLocations(homeDir, options.repoRoot);
   for (const location of allLocations) {
@@ -1241,7 +2219,7 @@ async function setupJetBrainsMcpConfig(options) {
           path: globalPath,
           backupPath: backupPath2
         });
-        await fs5.unlink(globalPath);
+        await fs6.unlink(globalPath);
         existing = null;
       }
     }
@@ -1250,7 +2228,7 @@ async function setupJetBrainsMcpConfig(options) {
   const body = JSON.stringify(merged, null, 2) + "\n";
   if (existed && existing) {
     const currentMemoraone = existing.mcpServers && typeof existing.mcpServers === "object" && !Array.isArray(existing.mcpServers) ? existing.mcpServers.memoraone : void 0;
-    if (memoraoneServerMatches2(currentMemoraone, memoraone)) {
+    if (memoraoneServerMatches(currentMemoraone, memoraone)) {
       repairActions.push({ type: "wrote-global-config", path: globalPath, outcome: "skipped" });
       return { outcome: "skipped", repairActions, memoraone };
     }
@@ -1264,9 +2242,9 @@ async function setupJetBrainsMcpConfig(options) {
   if (existed) {
     backupPath = await backupConfigFile(globalPath);
   }
-  await fs5.mkdir(path5.dirname(globalPath), { recursive: true });
-  await fs5.writeFile(globalPath, body, "utf8");
-  const verifyRaw = await fs5.readFile(globalPath, "utf8");
+  await fs6.mkdir(path8.dirname(globalPath), { recursive: true });
+  await fs6.writeFile(globalPath, body, "utf8");
+  const verifyRaw = await fs6.readFile(globalPath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments2(verifyRaw));
   validateJetBrainsMcpConfig(verifyParsed, memoraone);
   const outcome = existed ? "updated" : "created";
@@ -1336,15 +2314,15 @@ function buildMemoraoneMcpServer(ideType, command = "npx") {
   };
 }
 function assertUnderRepoRoot(repoRoot, absPath) {
-  const normRoot = path6.resolve(repoRoot) + path6.sep;
-  const normPath = path6.resolve(absPath);
-  if (normPath !== path6.resolve(repoRoot) && !normPath.startsWith(normRoot)) {
+  const normRoot = path9.resolve(repoRoot) + path9.sep;
+  const normPath = path9.resolve(absPath);
+  if (normPath !== path9.resolve(repoRoot) && !normPath.startsWith(normRoot)) {
     throw new Error(`[setup-ide-files] Refusing to write outside repo root: ${absPath}`);
   }
 }
 async function pathExists3(filePath) {
   try {
-    await fs6.access(filePath);
+    await fs7.access(filePath);
     return true;
   } catch {
     return false;
@@ -1365,12 +2343,12 @@ ${GITIGNORE_MEMORAONE_ENTRY}
 }
 async function ensureGitignoreMemoraone(repoRoot, opts) {
   if (opts.noGitignore) return "skipped";
-  const abs = path6.join(repoRoot, ".gitignore");
+  const abs = path9.join(repoRoot, ".gitignore");
   assertUnderRepoRoot(repoRoot, abs);
   let prior = "";
   let existed = false;
   try {
-    prior = await fs6.readFile(abs, "utf8");
+    prior = await fs7.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
@@ -1381,22 +2359,22 @@ async function ensureGitignoreMemoraone(repoRoot, opts) {
   const separator = existed && prior.length > 0 ? prior.endsWith("\n") ? "\n" : "\n\n" : "";
   const next = (existed ? prior : "") + separator + block;
   if (opts.dryRun) return existed ? "updated" : "created";
-  await fs6.writeFile(abs, next, "utf8");
+  await fs7.writeFile(abs, next, "utf8");
   return existed ? "updated" : "created";
 }
 async function findRepoRoot(startDir) {
-  let current = path6.resolve(startDir);
-  const root = path6.parse(current).root;
+  let current = path9.resolve(startDir);
+  const root = path9.parse(current).root;
   while (true) {
-    const gitPath = path6.join(current, ".git");
-    const m1Path = path6.join(current, "memoraone.m1");
+    const gitPath = path9.join(current, ".git");
+    const m1Path = path9.join(current, "memoraone.m1");
     if (await pathExists3(gitPath) || await pathExists3(m1Path)) {
       return current;
     }
     if (current === root) {
       return null;
     }
-    current = path6.dirname(current);
+    current = path9.dirname(current);
   }
 }
 function stripLeadingLineComments3(text) {
@@ -1407,7 +2385,7 @@ function cursorRuleBody() {
 
 ## MemoraOne MCP (IDE agent only)
 
-This repository uses **MemoraOne** via the MCP server named **user-memoraone** (Cursor MCP configuration). This guidance applies to the **IDE coding agent** only \u2014 not the MemoraOne Studio runtime path.
+This repository uses **MemoraOne** via the MCP server named **memoraone** (repo-level .cursor/mcp.json). This guidance applies to the **IDE coding agent** only \u2014 not the MemoraOne Studio runtime path.
 
 ### Tools
 
@@ -1449,43 +2427,47 @@ function buildVscodeMcpJsonBody(existing) {
   const merged = { ...base, servers };
   return mcpJsonHeader() + JSON.stringify(merged, null, 2) + "\n";
 }
+function buildCursorMcpJsonBody(existing, npxPath, repoRoot) {
+  const merged = mergeCursorRepoMcpConfigObject(existing, npxPath, repoRoot);
+  return mcpJsonHeader() + JSON.stringify(merged, null, 2) + "\n";
+}
 async function writeManagedMarkdown(repoRoot, relPath, fullContent, opts) {
-  const abs = path6.join(repoRoot, relPath);
+  const abs = path9.join(repoRoot, relPath);
   assertUnderRepoRoot(repoRoot, abs);
   let prior = "";
   let existed = false;
   try {
-    prior = await fs6.readFile(abs, "utf8");
+    prior = await fs7.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
   if (!existed) {
     if (opts.dryRun) return "created";
-    await fs6.mkdir(path6.dirname(abs), { recursive: true });
-    await fs6.writeFile(abs, fullContent, "utf8");
+    await fs7.mkdir(path9.dirname(abs), { recursive: true });
+    await fs7.writeFile(abs, fullContent, "utf8");
     return "created";
   }
   if (prior.includes(MANAGED_MARKER)) {
     if (prior === fullContent) return "skipped";
     if (opts.dryRun) return "updated";
-    await fs6.mkdir(path6.dirname(abs), { recursive: true });
-    await fs6.writeFile(abs, fullContent, "utf8");
+    await fs7.mkdir(path9.dirname(abs), { recursive: true });
+    await fs7.writeFile(abs, fullContent, "utf8");
     return "updated";
   }
   if (!opts.force) return "skipped-untracked";
   if (opts.dryRun) return "updated";
-  await fs6.mkdir(path6.dirname(abs), { recursive: true });
-  await fs6.writeFile(abs, fullContent, "utf8");
+  await fs7.mkdir(path9.dirname(abs), { recursive: true });
+  await fs7.writeFile(abs, fullContent, "utf8");
   return "updated";
 }
 async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
-  const abs = path6.join(repoRoot, relPath);
+  const abs = path9.join(repoRoot, relPath);
   assertUnderRepoRoot(repoRoot, abs);
   let raw = "";
   let existed = false;
   try {
-    raw = await fs6.readFile(abs, "utf8");
+    raw = await fs7.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
@@ -1493,8 +2475,8 @@ async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
   if (!existed) {
     const body = buildBody(null);
     if (opts.dryRun) return "created";
-    await fs6.mkdir(path6.dirname(abs), { recursive: true });
-    await fs6.writeFile(abs, body, "utf8");
+    await fs7.mkdir(path9.dirname(abs), { recursive: true });
+    await fs7.writeFile(abs, body, "utf8");
     return "created";
   }
   const managed = raw.includes(MANAGED_MARKER);
@@ -1509,8 +2491,8 @@ async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
   const next = buildBody(parsed);
   if (managed && next === raw) return "skipped";
   if (opts.dryRun) return "updated";
-  await fs6.mkdir(path6.dirname(abs), { recursive: true });
-  await fs6.writeFile(abs, next, "utf8");
+  await fs7.mkdir(path9.dirname(abs), { recursive: true });
+  await fs7.writeFile(abs, next, "utf8");
   return "updated";
 }
 function parseSetupIdeFlags(argv) {
@@ -1567,9 +2549,144 @@ function summarizeOutcomes(outcomes) {
   }
   console.log(lines.join("\n"));
 }
+function ideTypesFromSetupTargets(targets) {
+  const ides = [];
+  if (targets.cursor) ides.push("cursor");
+  if (targets.vscode) ides.push("copilot-vscode");
+  if (targets.jetbrains) ides.push("jetbrains");
+  return ides;
+}
+function setupTargetsAllIdes(targets) {
+  return targets.cursor && targets.vscode && targets.jetbrains;
+}
+function aggregateCleanupResults(results) {
+  const killedPids = /* @__PURE__ */ new Set();
+  const removedSockets = /* @__PURE__ */ new Set();
+  const skippedUnrelated = /* @__PURE__ */ new Map();
+  let foundDaemonCount = 0;
+  let error;
+  for (const result of results) {
+    if (result.error) error = result.error;
+    for (const pid of result.killedPids) {
+      killedPids.add(pid);
+      foundDaemonCount += 1;
+    }
+    for (const socketPath of result.removedSockets) {
+      removedSockets.add(socketPath);
+    }
+    for (const proc of result.skippedProcesses) {
+      if (proc.projectId !== result.projectId) {
+        skippedUnrelated.set(proc.pid, proc);
+      }
+    }
+  }
+  return {
+    foundDaemonCount,
+    stoppedDaemonCount: killedPids.size,
+    removedSocketCount: removedSockets.size,
+    skippedUnrelatedDaemonCount: skippedUnrelated.size,
+    error
+  };
+}
+function logSetupIdeCleanupSummary(cleanup) {
+  if (cleanup.skipped) return;
+  console.log(`[setup-ide-files] Project id: ${cleanup.projectId}`);
+  if (cleanup.foundDaemonCount > 0) {
+    console.log(`[setup-ide-files] Found ${cleanup.foundDaemonCount} stale daemon(s)`);
+    if (cleanup.dryRun) {
+      console.log(`[setup-ide-files] Would stop ${cleanup.foundDaemonCount} stale daemon(s)`);
+    } else if (cleanup.stoppedDaemonCount > 0) {
+      console.log(`[setup-ide-files] Stopped ${cleanup.stoppedDaemonCount} stale daemon(s)`);
+    }
+  } else {
+    console.log("[setup-ide-files] No stale daemons found for this project and IDE target(s).");
+  }
+  if (cleanup.removedSocketCount > 0) {
+    if (cleanup.dryRun) {
+      console.log(`[setup-ide-files] Would remove ${cleanup.removedSocketCount} stale socket(s)`);
+    } else {
+      console.log(`[setup-ide-files] Removed ${cleanup.removedSocketCount} stale socket(s)`);
+    }
+  }
+  if (cleanup.skippedUnrelatedDaemonCount > 0) {
+    console.log(
+      `[setup-ide-files] Skipped ${cleanup.skippedUnrelatedDaemonCount} unrelated project daemon(s)`
+    );
+  }
+}
+async function runSetupIdeDaemonCleanup(opts) {
+  const ides = ideTypesFromSetupTargets(opts.targets);
+  if (ides.length === 0) {
+    return {
+      skipped: true,
+      skipReason: "no-targets",
+      foundDaemonCount: 0,
+      stoppedDaemonCount: 0,
+      removedSocketCount: 0,
+      skippedUnrelatedDaemonCount: 0,
+      dryRun: opts.dryRun
+    };
+  }
+  const target = await resolveCleanupTarget(opts.repoRoot);
+  if ("error" in target) {
+    return {
+      skipped: true,
+      skipReason: "no-m1",
+      foundDaemonCount: 0,
+      stoppedDaemonCount: 0,
+      removedSocketCount: 0,
+      skippedUnrelatedDaemonCount: 0,
+      dryRun: opts.dryRun
+    };
+  }
+  const baseCleanupOpts = {
+    cwd: opts.repoRoot,
+    dryRun: opts.dryRun,
+    allProjects: false,
+    assumeYes: true,
+    projectId: target.projectId,
+    quiet: true,
+    listProcesses: opts.listProcesses,
+    listSocketPaths: opts.listSocketPaths,
+    killProcess: opts.killProcess,
+    removeSocket: opts.removeSocket
+  };
+  const results = [];
+  if (setupTargetsAllIdes(opts.targets)) {
+    results.push(await runCleanup(baseCleanupOpts));
+  } else {
+    for (const ide of ides) {
+      results.push(await runCleanup({ ...baseCleanupOpts, ide }));
+    }
+  }
+  const aggregated = aggregateCleanupResults(results);
+  const exitError = results.find((r) => r.exitCode !== 0)?.error ?? aggregated.error;
+  return {
+    skipped: false,
+    projectId: target.projectId,
+    foundDaemonCount: aggregated.foundDaemonCount,
+    stoppedDaemonCount: opts.dryRun ? 0 : aggregated.stoppedDaemonCount,
+    removedSocketCount: aggregated.removedSocketCount,
+    skippedUnrelatedDaemonCount: aggregated.skippedUnrelatedDaemonCount,
+    dryRun: opts.dryRun,
+    error: exitError
+  };
+}
+function restartIdeInstruction(targets) {
+  const names = [];
+  if (targets.cursor) names.push("Cursor");
+  if (targets.vscode) names.push("VS Code");
+  if (targets.jetbrains) names.push("JetBrains IDE");
+  if (names.length === 0) return "Fully quit your IDE and reopen this repo for MCP changes to take effect.";
+  if (names.length === 1) {
+    return `Fully quit ${names[0]} and reopen this repo for MCP changes to take effect.`;
+  }
+  const last = names.pop();
+  return `Fully quit ${names.join(", ")} and ${last}, then reopen this repo for MCP changes to take effect.`;
+}
 async function runSetupIdeFiles(o) {
   const outcomes = {};
-  let cursorGlobalMcp;
+  let cursorMcp;
   let jetbrainsMcp;
   const repoRoot = await findRepoRoot(o.cwd);
   if (!repoRoot) {
@@ -1580,6 +2697,27 @@ async function runSetupIdeFiles(o) {
       error: "[setup-ide-files] No repo root found (looked for .git or memoraone.m1)."
     };
   }
+  let daemonCleanup;
+  if (!o.skipDaemonCleanup) {
+    daemonCleanup = await runSetupIdeDaemonCleanup({
+      repoRoot,
+      targets: o.targets,
+      dryRun: o.dryRun,
+      listProcesses: o.listDaemonProcesses,
+      listSocketPaths: o.listCleanupSocketPaths,
+      killProcess: o.killDaemonProcess,
+      removeSocket: o.removeCleanupSocket
+    });
+    if (daemonCleanup.error && !daemonCleanup.skipped) {
+      return {
+        exitCode: 1,
+        repoRoot,
+        outcomes,
+        daemonCleanup,
+        error: `[setup-ide-files] Daemon cleanup failed: ${daemonCleanup.error}`
+      };
+    }
+  }
   outcomes[".gitignore"] = await ensureGitignoreMemoraone(repoRoot, {
     dryRun: o.dryRun,
     noGitignore: o.noGitignore ?? false
@@ -1590,19 +2728,6 @@ description: MemoraOne MCP \u2014 IDE agent instructions
 
 ` + cursorRuleBody();
   if (o.targets.cursor) {
-    const detection = await detectCursorGlobalMcpConfig({
-      homeDir: o.homeDir,
-      explicitPath: o.cursorGlobalMcpConfigPath
-    });
-    if (!detection.ok) {
-      return {
-        exitCode: 1,
-        repoRoot,
-        outcomes,
-        error: `${detection.error}
-  ${detection.candidates.join("\n  ")}`
-      };
-    }
     let npxPath;
     if (o.npxPathOverride !== void 0) {
       npxPath = o.npxPathOverride;
@@ -1614,7 +2739,7 @@ description: MemoraOne MCP \u2014 IDE agent instructions
         exitCode: 1,
         repoRoot,
         outcomes,
-        error: "[setup-ide-files] Could not resolve a working npx executable. Install Node.js/npm or ensure npx is on PATH before configuring Cursor global MCP."
+        error: "[setup-ide-files] Could not resolve a working npx executable. Install Node.js/npm or ensure npx is on PATH before configuring Cursor MCP."
       };
     }
     outcomes[".cursor/rules/memoraone-mcp.mdc"] = await writeManagedMarkdown(
@@ -1623,29 +2748,58 @@ description: MemoraOne MCP \u2014 IDE agent instructions
       cursorContent,
       { force: o.force, dryRun: o.dryRun }
     );
+    outcomes[".cursor/mcp.json"] = await writeIdeMcpJson(
+      repoRoot,
+      ".cursor/mcp.json",
+      (existing) => buildCursorMcpJsonBody(existing, npxPath, repoRoot),
+      { force: o.force, dryRun: o.dryRun }
+    );
+    const repoConfigPath = getCursorRepoMcpConfigPath(repoRoot);
+    const repoOutcome = outcomes[".cursor/mcp.json"] ?? "skipped";
+    let globalConfigPath;
+    let globalMemoraoneRemoved = false;
+    let globalBackupPath;
+    const globalDetection = await detectCursorGlobalMcpConfig({
+      homeDir: o.homeDir,
+      explicitPath: o.cursorGlobalMcpConfigPath
+    });
+    if (!globalDetection.ok) {
+      return {
+        exitCode: 1,
+        repoRoot,
+        outcomes,
+        error: `${globalDetection.error}
+  ${globalDetection.candidates.join("\n  ")}`
+      };
+    }
+    globalConfigPath = globalDetection.path;
     try {
-      const globalSetup = await setupCursorGlobalMcpConfig({
-        configPath: detection.path,
-        npxPath,
+      const removal = await removeMemoraoneFromCursorGlobalConfig({
+        configPath: globalDetection.path,
         dryRun: o.dryRun
       });
-      cursorGlobalMcp = {
-        configPath: detection.path,
-        outcome: globalSetup.outcome,
-        npxPath,
-        backupPath: globalSetup.backupPath
-      };
-      outcomes[`cursor-global:${detection.path}`] = globalSetup.outcome;
+      if (removal.changed) {
+        globalMemoraoneRemoved = true;
+        globalBackupPath = removal.backupPath;
+        outcomes[`cursor-global-removed:${globalDetection.path}`] = o.dryRun ? "updated" : "updated";
+      }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       return {
         exitCode: 1,
         repoRoot,
         outcomes,
-        cursorGlobalMcp: { configPath: detection.path, outcome: "skipped", npxPath },
         error: message
       };
     }
+    cursorMcp = {
+      repoConfigPath,
+      repoOutcome,
+      npxPath,
+      globalConfigPath,
+      globalMemoraoneRemoved,
+      globalBackupPath
+    };
   }
   if (o.targets.vscode) {
     outcomes[".vscode/mcp.json"] = await writeIdeMcpJson(
@@ -1701,12 +2855,12 @@ description: MemoraOne MCP \u2014 IDE agent instructions
         exitCode: 1,
         repoRoot,
         outcomes,
-        cursorGlobalMcp,
+        cursorMcp,
         error: message
       };
     }
   }
-  return { exitCode: 0, repoRoot, outcomes, cursorGlobalMcp, jetbrainsMcp };
+  return { exitCode: 0, repoRoot, outcomes, cursorMcp, jetbrainsMcp, daemonCleanup };
 }
 async function cliSetupIdeFiles(argv) {
   const { targets, force, dryRun, noGitignore, cleanup, devMode, repair, unknown } = parseSetupIdeFlags(argv);
@@ -1734,8 +2888,11 @@ async function cliSetupIdeFiles(argv) {
   if (result.repoRoot) {
     console.log(`[setup-ide-files] Repo root: ${result.repoRoot}`);
   }
-  if (targets.cursor && result.cursorGlobalMcp) {
-    logCursorGlobalMcpCliSummary(result.cursorGlobalMcp, dryRun);
+  if (result.daemonCleanup && !result.daemonCleanup.skipped) {
+    logSetupIdeCleanupSummary(result.daemonCleanup);
+  }
+  if (targets.cursor && result.cursorMcp) {
+    logCursorMcpCliSummary(result.cursorMcp, dryRun);
   }
   if (targets.jetbrains && result.jetbrainsMcp) {
     logJetBrainsMcpCliSummary(result.jetbrainsMcp, dryRun);
@@ -1743,9 +2900,13 @@ async function cliSetupIdeFiles(argv) {
   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)}`);
   if (cleanup) {
-    console.log("[setup-ide-files] Running project-scoped cleanup...");
+    console.log("[setup-ide-files] Running additional full-project cleanup (--cleanup)...");
     const cleanupResult = await runCleanup({
       cwd: process.cwd(),
       dryRun,
@@ -1756,13 +2917,6 @@ async function cliSetupIdeFiles(argv) {
       console.error(`[setup-ide-files] cleanup failed: ${cleanupResult.error}`);
       return cleanupResult.exitCode;
     }
-  } else {
-    console.log(
-      "[setup-ide-files] If Studio shows stale connections, run: npx -y @memoraone/mcp@latest cleanup --project-id <projectId>"
-    );
-    console.log(
-      "[setup-ide-files] From this repo (uses memoraone.m1): npx -y @memoraone/mcp@latest cleanup"
-    );
   }
   return 0;
 }
@@ -1799,92 +2953,9 @@ if (args[0] === "cleanup") {
     process.exit(1);
   });
 } else {
-  let getWorkspaceRootCandidates = function() {
-    const raw = process.env.WORKSPACE_FOLDER_PATHS;
-    const parts = [];
-    if (raw !== void 0 && raw.trim() !== "") {
-      for (const p of raw.split(path7.delimiter).map((s) => s.trim()).filter(Boolean)) {
-        parts.push(path7.resolve(p));
-      }
-    }
-    parts.push(process.cwd());
-    const seen = /* @__PURE__ */ new Set();
-    const deduped = [];
-    for (const p of parts) {
-      if (!seen.has(p)) {
-        seen.add(p);
-        deduped.push(p);
-      }
-    }
-    return deduped;
-  }, connectWithRetry = function(socketPath) {
-    return new Promise((resolve7, reject) => {
-      const tryConnect = (attempt) => {
-        const socket = net.connect(socketPath, () => {
-          resolve7(socket);
-        });
-        socket.on("error", (err) => {
-          if (attempt >= MAX_RETRIES) {
-            reject(err);
-            return;
-          }
-          log(`connect attempt ${attempt + 1} failed, retrying in ${RETRY_DELAY_MS}ms: ${String(err)}`);
-          setTimeout(() => tryConnect(attempt + 1), RETRY_DELAY_MS);
-        });
-      };
-      tryConnect(0);
-    });
-  };
-  const log = (msg) => {
-    process.stderr.write(`[memoraone-mcp][bridge] ${msg}
+  runBridgeProxy({ cliPath: process.argv[1] }).catch((err) => {
+    process.stderr.write(`[memoraone-mcp][bridge] fatal: ${String(err)}
 `);
-  };
-  const MAX_RETRIES = 5;
-  const RETRY_DELAY_MS = 200;
-  async function resolveBinding() {
-    return resolveAuthoritativeBinding(getWorkspaceRootCandidates());
-  }
-  async function runBridge() {
-    ensureBaseDir();
-    const binding = await resolveBinding();
-    const socketPath = getDaemonSocketPath(binding.projectId);
-    const environmentLog = binding.environment !== void 0 ? ` environment=${binding.environment}` : "";
-    log(
-      `authoritative binding project=${binding.projectId} workspace=${binding.workspaceRoot} m1=${binding.m1Path} source=${binding.bindingSource} apiKeySource=${binding.apiKeySource}${environmentLog}`
-    );
-    let socket;
-    try {
-      socket = await connectWithRetry(socketPath);
-    } catch {
-      log("daemon not running, spawning...");
-      const child = (0, import_node_child_process4.spawn)(
-        process.execPath,
-        buildDaemonSpawnArgs(process.argv[1], binding.projectId),
-        {
-          detached: true,
-          stdio: "ignore",
-          env: {
-            ...process.env,
-            MEMORAONE_DAEMON_BINDING_B64: encodeResolvedBinding(binding)
-          }
-        }
-      );
-      child.unref();
-      await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
-      socket = await connectWithRetry(socketPath);
-    }
-    log("bridge connected");
-    log("forwarding active");
-    process.stdin.pipe(socket);
-    socket.pipe(process.stdout);
-    socket.on("close", () => process.exit(0));
-    socket.on("error", (err) => {
-      log(`socket error: ${String(err)}`);
-      process.exit(1);
-    });
-  }
-  runBridge().catch((err) => {
-    log(`fatal: ${String(err)}`);
     process.exit(1);
   });
 }