@memoraone/mcp 0.1.29 → 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.29",
+      version: "0.1.31",
       type: "module",
       main: "dist/index.cjs",
       bin: {
@@ -66,17 +66,272 @@ var require_package = __commonJS({
   }
 });
 
-// src/cli.ts
-var path6 = __toESM(require("path"), 1);
+// src/bridgeProxy.ts
 var net = __toESM(require("net"), 1);
-var import_node_child_process3 = require("child_process");
+var readline2 = __toESM(require("readline"), 1);
+var import_node_child_process = require("child_process");
+
+// src/bindingIdentity.ts
+var crypto = __toESM(require("crypto"), 1);
+var path = __toESM(require("path"), 1);
+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");
+  }
+  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 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) {
+  if (raw === void 0 || raw === null || typeof raw !== "string") {
+    return void 0;
+  }
+  const trimmed = raw.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function parseAndValidateM1(content, markerPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new Error(`[memoraone-mcp] Invalid memoraone.m1 JSON at ${markerPath}`);
+  }
+  const projectId = parsed?.projectId ?? parsed?.project_id;
+  if (!projectId || typeof projectId !== "string") {
+    throw new Error(`[memoraone-mcp] memoraone.m1 missing projectId at ${markerPath}`);
+  }
+  if (!uuidRegex.test(projectId.trim())) {
+    throw new Error(`[memoraone-mcp] memoraone.m1 projectId is not a UUID at ${markerPath}`);
+  }
+  const apiKeyRaw = parsed?.MEMORAONE_API_KEY ?? parsed?.api_key;
+  const apiKey = apiKeyRaw !== void 0 && apiKeyRaw !== null && typeof apiKeyRaw === "string" && apiKeyRaw.trim() !== "" ? apiKeyRaw.trim() : null;
+  const environment = normalizeEnvironment(parsed?.environment);
+  return environment === void 0 ? { projectId: projectId.trim(), apiKey } : { projectId: projectId.trim(), apiKey, environment };
+}
+async function resolveProjectIdFromExplicitM1Path() {
+  const raw = process.env.MEMORAONE_M1_PATH;
+  if (raw === void 0 || raw.trim() === "") {
+    return null;
+  }
+  const markerPath = path2.resolve(raw);
+  try {
+    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) {
+    if (err?.code === "ENOENT") {
+      return null;
+    }
+    throw err;
+  }
+}
+async function findM1WalkingUp(workspaceRoot) {
+  let current = path2.resolve(workspaceRoot);
+  while (true) {
+    const markerPath = path2.join(current, "memoraone.m1");
+    try {
+      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 };
+    } catch (err) {
+      if (err?.code !== "ENOENT") {
+        throw err;
+      }
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
+function normalizeWorkspaceSearchRoots(workspaceRoot) {
+  if (workspaceRoot === void 0) {
+    return [];
+  }
+  const list = Array.isArray(workspaceRoot) ? workspaceRoot : [workspaceRoot];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of list) {
+    if (raw === void 0) {
+      continue;
+    }
+    const trimmed = String(raw).trim();
+    if (trimmed === "") {
+      continue;
+    }
+    const resolved = path2.resolve(trimmed);
+    if (!seen.has(resolved)) {
+      seen.add(resolved);
+      out.push(resolved);
+    }
+  }
+  return out;
+}
+function resolveApiKeyWithSource(fileApiKey) {
+  const envApiKey = process.env.MEMORAONE_API_KEY?.trim();
+  if (envApiKey) {
+    return { apiKey: envApiKey, apiKeySource: "env" };
+  }
+  const aliasEnvApiKey = process.env.MEMORA_API_KEY?.trim();
+  if (aliasEnvApiKey) {
+    return { apiKey: aliasEnvApiKey, apiKeySource: "env" };
+  }
+  if (fileApiKey) {
+    return { apiKey: fileApiKey, apiKeySource: "memoraone.m1" };
+  }
+  return { apiKey: null, apiKeySource: "none" };
+}
+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);
+      bindings.push({
+        projectId: binding.projectId,
+        workspaceRoot: binding.repoRoot,
+        m1Path: binding.markerPath,
+        apiKey: resolved.apiKey,
+        ...binding.environment !== void 0 ? { environment: binding.environment } : {},
+        bindingSource: "workspace-search",
+        apiKeySource: resolved.apiKeySource
+      });
+    }
+  }
+  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");
+}
+function decodeResolvedBinding(value) {
+  if (!value) {
+    return 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
+  };
+}
 
 // src/socketPaths.ts
 var os = __toESM(require("os"), 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;
+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;
 }
@@ -103,24 +358,33 @@ function buildDaemonSpawnArgs(scriptPath, projectId, env = process.env) {
   }
   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 resolveBindingIdeType(env = process.env) {
+  return resolveIdeTypeFromEnv(env) ?? "";
+}
+function getBindingSocketFilename(binding, env = process.env) {
+  const ideType = resolveBindingIdeType(env);
+  const hash = hashBindingIdentity(binding.projectId, binding.workspaceRoot, ideType);
+  return `mcp-${hash}.sock`;
 }
-function getDaemonSocketPath(projectId, env = process.env) {
-  return getSocketPath(projectId, resolveIdeTypeFromEnv(env));
+function getBindingSocketPath(binding, env = process.env) {
+  return path3.join(BASE_DIR, getBindingSocketFilename(binding, env));
 }
 function ensureBaseDir() {
-  fs.mkdirSync(BASE_DIR, { recursive: true });
+  fs2.mkdirSync(BASE_DIR, { recursive: true });
   return BASE_DIR;
 }
+function isHashSocketFilename(filename) {
+  return HASH_SOCKET_FILENAME_RE.test(path3.basename(filename));
+}
+function isLegacySocketFilename(filename) {
+  return LEGACY_SOCKET_FILENAME_RE.test(path3.basename(filename));
+}
 function isMemoraoneSocketFilename(filename) {
-  return SOCKET_PROJECT_ID_RE.test(path.basename(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 = path.basename(filename).match(SOCKET_PROJECT_ID_RE);
+  const match = path3.basename(filename).match(LEGACY_SOCKET_PROJECT_ID_RE);
   return match ? match[1].toLowerCase() : null;
 }
 function isSocketFilenameForProject(filename, projectId) {
@@ -128,11 +392,11 @@ function isSocketFilenameForProject(filename, projectId) {
   return extracted !== null && extracted === projectId.trim().toLowerCase();
 }
 function extractIdeTypeFromSocketFilename(filename) {
-  const match = path.basename(filename).match(SOCKET_PROJECT_ID_RE);
+  const match = path3.basename(filename).match(LEGACY_SOCKET_FILENAME_RE);
   if (!match) return null;
-  const suffix = match[2];
-  if (suffix === void 0) return "legacy";
-  if (IDE_TYPE_SET.has(suffix)) return suffix;
+  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) {
@@ -146,163 +410,1021 @@ function isSocketFilenameForProjectAndIde(filename, projectId, ide) {
   return socketIde === ide;
 }
 
-// src/projectBinding.ts
-var fs2 = __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) {
-  if (raw === void 0 || raw === null || typeof raw !== "string") {
-    return void 0;
+// src/bindingSidecar.ts
+function bindingSidecarPath(socketPath) {
+  if (socketPath.endsWith(".sock")) {
+    return `${socketPath.slice(0, -".sock".length)}.binding.json`;
+  }
+  return `${socketPath}.binding.json`;
+}
+function parseSidecarRecord(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed?.binding) {
+      return null;
+    }
+    const binding = decodeResolvedBinding(parsed.binding);
+    return {
+      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 null;
+  }
+}
+function readBindingSidecarRecord(socketPath) {
+  try {
+    const raw = fs3.readFileSync(bindingSidecarPath(socketPath), "utf8");
+    return parseSidecarRecord(raw);
+  } catch {
+    return null;
+  }
+}
+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));
   }
-  const trimmed = raw.trim();
-  return trimmed === "" ? void 0 : trimmed;
-}
-function parseAndValidateM1(content, markerPath) {
-  let parsed;
   try {
-    parsed = JSON.parse(content);
+    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 {
-    throw new Error(`[memoraone-mcp] Invalid memoraone.m1 JSON at ${markerPath}`);
-  }
-  const projectId = parsed?.projectId ?? parsed?.project_id;
-  if (!projectId || typeof projectId !== "string") {
-    throw new Error(`[memoraone-mcp] memoraone.m1 missing projectId at ${markerPath}`);
   }
-  if (!uuidRegex.test(projectId.trim())) {
-    throw new Error(`[memoraone-mcp] memoraone.m1 projectId is not a UUID at ${markerPath}`);
+  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;
   }
-  const apiKeyRaw = parsed?.MEMORAONE_API_KEY ?? parsed?.api_key;
-  const apiKey = apiKeyRaw !== void 0 && apiKeyRaw !== null && typeof apiKeyRaw === "string" && apiKeyRaw.trim() !== "" ? apiKeyRaw.trim() : null;
-  const environment = normalizeEnvironment(parsed?.environment);
-  return environment === void 0 ? { projectId: projectId.trim(), apiKey } : { projectId: projectId.trim(), apiKey, environment };
+  return null;
 }
-async function resolveProjectIdFromExplicitM1Path() {
-  const raw = process.env.MEMORAONE_M1_PATH;
-  if (raw === void 0 || raw.trim() === "") {
-    return null;
-  }
-  const markerPath = path2.resolve(raw);
+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 content = await fs2.readFile(markerPath, "utf8");
-    const { projectId, apiKey, environment } = parseAndValidateM1(content, markerPath);
-    return environment === void 0 ? { projectId, apiKey, foundAt: markerPath } : { projectId, apiKey, environment, foundAt: markerPath };
+    const raw = await fs4.readFile(configPath, "utf8");
+    return JSON.parse(stripLeadingLineComments(raw));
   } catch (err) {
-    if (err?.code === "ENOENT") {
-      return null;
-    }
+    const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+    if (code === "ENOENT") return null;
     throw err;
   }
 }
-async function findM1WalkingUp(workspaceRoot) {
-  let current = path2.resolve(workspaceRoot);
-  while (true) {
-    const markerPath = path2.join(current, "memoraone.m1");
-    try {
-      const content = await fs2.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 };
-    } catch (err) {
-      if (err?.code !== "ENOENT") {
-        throw err;
-      }
-    }
-    const parent = path2.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
+async function removeMemoraoneFromCursorGlobalConfig(options) {
+  const { configPath, dryRun } = options;
+  const parsed = await readCursorMcpConfigObject(configPath);
+  if (!parsed || !cursorConfigHasManagedMemoraone(parsed)) {
+    return { changed: false };
   }
-  return null;
-}
-function normalizeWorkspaceSearchRoots(workspaceRoot) {
-  if (workspaceRoot === void 0) {
-    return [];
+  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;
   }
-  const list = Array.isArray(workspaceRoot) ? workspaceRoot : [workspaceRoot];
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const raw of list) {
-    if (raw === void 0) {
-      continue;
-    }
-    const trimmed = String(raw).trim();
-    if (trimmed === "") {
-      continue;
-    }
-    const resolved = path2.resolve(trimmed);
-    if (!seen.has(resolved)) {
-      seen.add(resolved);
-      out.push(resolved);
+  let globalHasManagedMemoraone = false;
+  if (globalDetection.ok) {
+    try {
+      const globalParsed = await readCursorMcpConfigObject(globalConfigPath);
+      globalHasManagedMemoraone = cursorConfigHasManagedMemoraone(globalParsed);
+    } catch {
+      globalHasManagedMemoraone = false;
     }
   }
-  return out;
+  return {
+    repoConfigPath,
+    repoHasManagedMemoraone,
+    globalConfigPath,
+    globalHasManagedMemoraone,
+    conflict: repoHasManagedMemoraone && globalHasManagedMemoraone
+  };
 }
-function resolveApiKeyWithSource(fileApiKey) {
-  const envApiKey = process.env.MEMORAONE_API_KEY?.trim();
-  if (envApiKey) {
-    return { apiKey: envApiKey, apiKeySource: "env" };
-  }
-  const aliasEnvApiKey = process.env.MEMORA_API_KEY?.trim();
-  if (aliasEnvApiKey) {
-    return { apiKey: aliasEnvApiKey, apiKeySource: "env" };
-  }
-  if (fileApiKey) {
-    return { apiKey: fileApiKey, apiKeySource: "memoraone.m1" };
+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).`
+    );
   }
-  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
-    };
+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}`);
   }
-  const candidates = normalizeWorkspaceSearchRoots(workspaceRoot);
-  if (candidates.length === 0) {
-    throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
+  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}`);
   }
-  for (const root of candidates) {
-    const binding = await findM1WalkingUp(root);
-    if (binding) {
-      const resolved = resolveApiKeyWithSource(binding.apiKey);
-      return {
-        projectId: binding.projectId,
-        workspaceRoot: binding.repoRoot,
-        m1Path: binding.markerPath,
-        apiKey: resolved.apiKey,
-        ...binding.environment !== void 0 ? { environment: binding.environment } : {},
-        bindingSource: "workspace-search",
-        apiKeySource: resolved.apiKeySource
-      };
+  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}`
+    );
   }
-  throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
-}
-function encodeResolvedBinding(binding) {
-  return Buffer.from(JSON.stringify(binding), "utf8").toString("base64");
+  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/setupIdeFiles.ts
-var fs5 = __toESM(require("fs/promises"), 1);
-var path5 = __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 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/;
@@ -349,7 +1471,7 @@ function normalizeCleanupProjectId(projectId) {
   return trimmed.toLowerCase();
 }
 async function defaultListDaemonProcesses() {
-  const { stdout } = await execFileAsync("ps", ["-eo", "pid=,args="], {
+  const { stdout } = await execFileAsync2("ps", ["-eo", "pid=,args="], {
     maxBuffer: 10 * 1024 * 1024
   });
   return parseDaemonProcessLines(stdout.split("\n"));
@@ -358,7 +1480,7 @@ async function defaultListSocketPaths(projectId) {
   const baseDir = getMcpBaseDir();
   let entries;
   try {
-    entries = await fs3.readdir(baseDir);
+    entries = await fs5.readdir(baseDir);
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
     if (code === "ENOENT") {
@@ -368,33 +1490,64 @@ async function defaultListSocketPaths(projectId) {
   }
   const paths = [];
   for (const name of entries) {
+    if (!name.endsWith(".sock") || !isMemoraoneSocketFilename(name)) {
+      continue;
+    }
+    const socketPath = path7.join(baseDir, name);
     if (projectId === null) {
-      if (isMemoraoneSocketFilename(name)) {
-        paths.push(path3.join(baseDir, name));
+      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);
       }
-    } else if (isSocketFilenameForProject(name, projectId)) {
-      paths.push(path3.join(baseDir, name));
     }
   }
   return paths.sort();
 }
-function filterSocketPathsByIde(socketPaths, projectId, ide) {
+async function filterSocketPathsByIde(socketPaths, projectId, ide) {
   if (ide === void 0) return socketPaths;
-  return socketPaths.filter(
-    (socketPath) => isSocketFilenameForProjectAndIde(path3.basename(socketPath), projectId, ide)
-  );
+  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 fs3.unlink(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 = readline.createInterface({ input: import_node_process.stdin, output: import_node_process.stdout });
+  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());
@@ -404,7 +1557,7 @@ async function defaultConfirm(message) {
 }
 async function resolveCleanupTarget(cwd) {
   try {
-    const binding = await resolveAuthoritativeBinding([path3.resolve(cwd)]);
+    const binding = await resolveAuthoritativeBinding([path7.resolve(cwd)]);
     return {
       workspaceRoot: binding.workspaceRoot,
       m1Path: binding.m1Path,
@@ -433,7 +1586,8 @@ function filterProcessesForScope(processes, projectId) {
 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.`
@@ -444,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;
@@ -464,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) {
@@ -474,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);
@@ -486,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(
@@ -510,59 +1683,71 @@ 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}`);
+      cleanupLog(opts, `${prefix}   pid=${proc.pid} project=${proc.projectId}${ideLabel}`);
     }
   } else if (ideSkippedProcesses.length) {
-    console.log(`${prefix} No matching daemon processes for IDE filter ${opts.ide}.`);
+    cleanupLog(opts, `${prefix} No matching daemon processes for IDE filter ${opts.ide}.`);
   } else {
-    console.log(`${prefix} No matching daemon processes found.`);
+    cleanupLog(opts, `${prefix} No matching daemon processes found.`);
   }
   if (socketPaths.length) {
-    console.log(`${prefix} Sockets to remove:`);
+    cleanupLog(opts, `${prefix} Sockets to remove:`);
     for (const socketPath of socketPaths) {
-      console.log(`${prefix}   ${socketPath}`);
+      cleanupLog(opts, `${prefix}   ${socketPath}`);
     }
   } else {
-    console.log(`${prefix} No matching sockets found under ${getMcpBaseDir()}.`);
+    cleanupLog(opts, `${prefix} No matching sockets found under ${getMcpBaseDir()}.`);
   }
   if (skippedProcesses.length) {
-    console.log(`${prefix} Skipped unrelated daemon processes:`);
+    cleanupLog(opts, `${prefix} Skipped unrelated daemon processes:`);
     for (const proc of skippedProcesses) {
-      console.log(`${prefix}   pid=${proc.pid} project=${proc.projectId}`);
+      cleanupLog(opts, `${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.`);
+      cleanupLog(opts, `${prefix} Aborted.`);
       return {
         exitCode: 1,
         workspaceRoot,
@@ -578,7 +1763,7 @@ async function runCleanup(opts) {
   const killedPids = [];
   const removedSockets = [];
   if (opts.dryRun) {
-    console.log(`${prefix} Dry run complete \u2014 no processes stopped, no sockets removed.`);
+    cleanupLog(opts, `${prefix} Dry run complete \u2014 no processes stopped, no sockets removed.`);
     return {
       exitCode: 0,
       workspaceRoot,
@@ -593,9 +1778,9 @@ async function runCleanup(opts) {
     try {
       await killProcess(proc.pid);
       killedPids.push(proc.pid);
-      console.log(`${prefix} Stopped daemon pid=${proc.pid} project=${proc.projectId}`);
+      cleanupLog(opts, `${prefix} Stopped daemon pid=${proc.pid} project=${proc.projectId}`);
     } catch (err) {
-      console.warn(`${prefix} Could not stop pid=${proc.pid}: ${String(err)}`);
+      cleanupWarn(opts, `${prefix} Could not stop pid=${proc.pid}: ${String(err)}`);
     }
   }
   if (killedPids.length) {
@@ -605,15 +1790,15 @@ async function runCleanup(opts) {
     try {
       await removeSocket(socketPath);
       removedSockets.push(socketPath);
-      console.log(`${prefix} Removed socket ${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") {
-        console.warn(`${prefix} Could not remove socket ${socketPath}: ${String(err)}`);
+        cleanupWarn(opts, `${prefix} Could not remove socket ${socketPath}: ${String(err)}`);
       }
     }
   }
-  console.log(`${prefix} Done. stopped=${killedPids.length} socketsRemoved=${removedSockets.length}`);
+  cleanupLog(opts, `${prefix} Done. stopped=${killedPids.length} socketsRemoved=${removedSockets.length}`);
   return {
     exitCode: 0,
     workspaceRoot,
@@ -685,209 +1870,432 @@ async function cliCleanup(argv) {
   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())}`;
+// src/jetbrainsMcpConfig.ts
+var fs6 = __toESM(require("fs/promises"), 1);
+var os3 = __toESM(require("os"), 1);
+var path8 = __toESM(require("path"), 1);
+var import_node_child_process4 = require("child_process");
+
+// src/configUtils.ts
+var DEV_API_URL = "http://localhost:3001";
+
+// src/jetbrainsMcpConfig.ts
+var PROD_API_URL = "https://api.memoraone.com";
+var JETBRAINS_DEBUG_ENV_VARS = [
+  "MEMORAONE_DEBUG_INIT",
+  "MEMORAONE_DEBUG_MINIMAL_TOOLS",
+  "MEMORAONE_DEBUG_MINIMAL_INITIALIZE",
+  "MEMORAONE_DEBUG_DIRECT_STDIO"
+];
+function stripLeadingLineComments2(text) {
+  return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
 }
-async function isWorkingNpx(npxPath) {
+async function pathExists2(filePath) {
   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 });
+    await fs6.access(filePath);
     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;
+function formatJetBrainsBackupTimestamp(d = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+function getJetBrainsGlobalMcpConfigPath(homeDir) {
+  return path8.join(homeDir, ".ai", "mcp", "mcp.json");
+}
+function getJetBrainsProjectMcpConfigPaths(repoRoot) {
+  return [
+    { 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) {
+  return [
+    { kind: "global", path: getJetBrainsGlobalMcpConfigPath(homeDir) },
+    ...getJetBrainsProjectMcpConfigPaths(repoRoot)
+  ];
+}
+async function isZeroByteConfigFile(filePath) {
+  if (!await pathExists2(filePath)) return false;
+  const stat2 = await fs6.stat(filePath);
+  return stat2.size === 0;
+}
+function buildMemoraoneJetBrainsMcpServer(options) {
+  const env = {
+    MEMORAONE_API_URL: options.devMode ? DEV_API_URL : PROD_API_URL,
+    MEMORAONE_IDE_TYPE: "jetbrains",
+    MEMORAONE_M1_PATH: options.m1Path
+  };
+  if (options.devMode) {
+    env.MEMORAONE_DEV_MODE = "1";
   }
-  return null;
+  return {
+    command: options.command,
+    args: options.args,
+    env
+  };
 }
-function mergeCursorGlobalMcpConfigObject(existing, npxPath) {
+function mergeJetBrainsMcpConfigObject(existing, memoraone) {
   const base = existing && typeof existing === "object" ? { ...existing } : { mcpServers: {} };
   const mcpServers = typeof base.mcpServers === "object" && base.mcpServers !== null && !Array.isArray(base.mcpServers) ? { ...base.mcpServers } : {};
-  mcpServers.memoraone = buildMemoraoneCursorMcpServer(npxPath);
+  mcpServers.memoraone = memoraone;
   return { ...base, mcpServers };
 }
-function memoraoneServerMatches(server, npxPath) {
+function memoraoneServerMatches(server, expected) {
   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;
+  if (s.command !== expected.command) return false;
+  if (!Array.isArray(s.args) || s.args.length !== expected.args.length) return false;
+  for (let i = 0; i < expected.args.length; i += 1) {
+    if (s.args[i] !== expected.args[i]) return false;
+  }
   const 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";
+  for (const [key, value] of Object.entries(expected.env)) {
+    if (e[key] !== value) return false;
+  }
+  for (const debugKey of JETBRAINS_DEBUG_ENV_VARS) {
+    if (debugKey in e) return false;
+  }
+  return true;
 }
-function validateCursorGlobalMcpConfig(parsed, npxPath) {
+function validateJetBrainsMcpConfig(parsed, expected) {
   if (!parsed || typeof parsed !== "object") {
-    throw new Error("[setup-ide-files] Cursor global MCP config must be a JSON object.");
+    throw new Error("[setup-ide-files] JetBrains MCP config must be a JSON object.");
   }
   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.");
+    throw new Error("[setup-ide-files] JetBrains MCP config missing mcpServers object.");
   }
   const memoraone = mcpServers.memoraone;
-  if (!memoraoneServerMatches(memoraone, npxPath)) {
+  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 fs6.readFile(filePath, "utf8");
+  if (raw.trim() === "") return null;
+  return JSON.parse(stripLeadingLineComments2(raw));
+}
+async function backupConfigFile(filePath) {
+  const backupPath = `${filePath}.bak-${formatJetBrainsBackupTimestamp()}`;
+  await fs6.copyFile(filePath, backupPath);
+  return backupPath;
+}
+async function repairZeroByteConfigFile(filePath, dryRun) {
+  if (!await isZeroByteConfigFile(filePath)) {
+    return { repaired: false };
+  }
+  if (dryRun) {
+    return { repaired: true, backupPath: `${filePath}.bak-<timestamp>` };
+  }
+  const backupPath = await backupConfigFile(filePath);
+  await fs6.unlink(filePath);
+  return { repaired: true, backupPath };
+}
+function configHasMemoraone(parsed) {
+  if (!parsed) return false;
+  const mcpServers = parsed.mcpServers;
+  if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) return false;
+  return Boolean(mcpServers.memoraone);
+}
+async function removeMemoraoneFromProjectConfig(options) {
+  const { configPath, dryRun } = options;
+  if (!await pathExists2(configPath)) {
+    return { changed: false };
+  }
+  let parsed = null;
+  try {
+    parsed = await readJsonConfig(configPath);
+  } catch {
+    return { changed: false };
+  }
+  if (!configHasMemoraone(parsed)) {
+    return { changed: false };
+  }
+  if (dryRun) {
+    return { changed: true, backupPath: `${configPath}.bak-<timestamp>` };
+  }
+  const backupPath = await backupConfigFile(configPath);
+  const mcpServers = parsed && 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 fs6.unlink(configPath);
+    return { changed: true, backupPath };
+  }
+  const next = { ...parsed, mcpServers };
+  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] ? path8.dirname(path8.resolve(process.argv[1])) : process.cwd();
+  const candidates = [
+    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 path8.resolve(candidate);
+    }
+  }
+  return null;
+}
+async function buildJetBrainsMemoraoneServer(options) {
+  if (options.devMode) {
+    let cliPath = options.cliPathOverride;
+    if (cliPath === void 0) {
+      cliPath = await resolveLocalCliPathAsync();
+    }
+    if (!cliPath) {
+      throw new Error(
+        "[setup-ide-files] Dev mode requires a built CLI at packages/mcp/dist/cli.cjs. Run pnpm build first."
+      );
+    }
+    return buildMemoraoneJetBrainsMcpServer({
+      command: process.execPath,
+      args: [cliPath],
+      m1Path: options.m1Path,
+      devMode: true
+    });
+  }
+  let npxPath = options.npxPathOverride;
+  if (npxPath === void 0) {
+    npxPath = await resolveNpxPath();
+  }
+  if (!npxPath) {
     throw new Error(
-      "[setup-ide-files] Cursor global MCP config mcpServers.memoraone is missing or invalid."
+      "[setup-ide-files] Could not resolve a working npx executable. Install Node.js/npm or ensure npx is on PATH before configuring JetBrains MCP."
     );
   }
+  return buildMemoraoneJetBrainsMcpServer({
+    command: npxPath,
+    args: ["-y", "@memoraone/mcp@latest"],
+    m1Path: options.m1Path,
+    devMode: false
+  });
+}
+async function verifyJetBrainsMcpHandshake(options) {
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  const { server } = options;
+  return new Promise((resolve8) => {
+    let settled = false;
+    const finish = (ok, detail) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        child.kill();
+      } catch {
+      }
+      resolve8({ ok, detail });
+    };
+    const child = (0, import_node_child_process4.spawn)(server.command, [...server.args], {
+      env: { ...process.env, ...server.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let buffer = "";
+    let initializeOk = false;
+    let toolsListOk = false;
+    let nextId = 1;
+    const send = (method, params) => {
+      const msg = JSON.stringify({ jsonrpc: "2.0", id: nextId, method, params }) + "\n";
+      nextId += 1;
+      child.stdin?.write(msg);
+    };
+    const timer = setTimeout(() => {
+      finish(false, `handshake timed out after ${timeoutMs}ms`);
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (msg.id === 1 && msg.result) {
+          initializeOk = true;
+          send("notifications/initialized", {});
+          send("tools/list", {});
+        }
+        if (msg.id === 2 && msg.result) {
+          toolsListOk = true;
+          finish(true, "initialize OK; tools/list OK");
+        }
+        if (msg.error) {
+          finish(false, `JSON-RPC error: ${JSON.stringify(msg.error)}`);
+        }
+      }
+    });
+    child.on("error", (err) => {
+      finish(false, `spawn error: ${String(err)}`);
+    });
+    child.on("exit", (code) => {
+      if (!settled) {
+        if (initializeOk && toolsListOk) {
+          finish(true, "initialize OK; tools/list OK");
+        } else {
+          finish(
+            false,
+            `process exited code=${code ?? "null"} (initialize=${initializeOk}, tools/list=${toolsListOk})`
+          );
+        }
+      }
+    });
+    send("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "memoraone-setup", version: "1.0.0" }
+    });
+  });
 }
-async function setupCursorGlobalMcpConfig(options) {
-  const { configPath, npxPath, dryRun } = options;
-  const existed = await pathExists(configPath);
+async function setupJetBrainsMcpConfig(options) {
+  const homeDir = options.homeDir ?? os3.homedir();
+  const globalPath = options.globalConfigPath ?? getJetBrainsGlobalMcpConfigPath(homeDir);
+  const m1Path = path8.join(path8.resolve(options.repoRoot), "memoraone.m1");
+  const repairActions = [];
+  const allLocations = getKnownJetBrainsMcpConfigLocations(homeDir, options.repoRoot);
+  for (const location of allLocations) {
+    if (await pathExists2(location.path)) {
+      repairActions.push({ type: "found-config", location });
+    }
+  }
+  for (const location of allLocations) {
+    const zeroByte = await repairZeroByteConfigFile(location.path, options.dryRun);
+    if (zeroByte.repaired) {
+      repairActions.push({
+        type: "repaired-zero-byte",
+        path: location.path,
+        backupPath: zeroByte.backupPath ?? `${location.path}.bak-<timestamp>`
+      });
+    }
+  }
+  const memoraone = await buildJetBrainsMemoraoneServer({
+    m1Path,
+    devMode: options.devMode,
+    npxPathOverride: options.npxPathOverride,
+    cliPathOverride: options.cliPathOverride
+  });
+  for (const location of getJetBrainsProjectMcpConfigPaths(options.repoRoot)) {
+    const removal = await removeMemoraoneFromProjectConfig({
+      configPath: location.path,
+      dryRun: options.dryRun
+    });
+    if (removal.changed) {
+      if (removal.backupPath) {
+        repairActions.push({
+          type: "backed-up-conflicting-project-config",
+          path: location.path,
+          backupPath: removal.backupPath
+        });
+      }
+      repairActions.push({ type: "removed-project-memoraone", path: location.path });
+    }
+  }
+  const existed = await pathExists2(globalPath);
   let existing = null;
   if (existed) {
-    const raw = await fs4.readFile(configPath, "utf8");
     try {
-      existing = JSON.parse(stripLeadingLineComments(raw));
+      existing = await readJsonConfig(globalPath);
     } catch {
-      throw new Error(
-        `[setup-ide-files] Invalid JSON in Cursor global MCP config: ${configPath}`
-      );
+      if (options.dryRun) {
+        existing = null;
+      } else {
+        const backupPath2 = await backupConfigFile(globalPath);
+        repairActions.push({
+          type: "repaired-zero-byte",
+          path: globalPath,
+          backupPath: backupPath2
+        });
+        await fs6.unlink(globalPath);
+        existing = null;
+      }
     }
   }
-  const merged = mergeCursorGlobalMcpConfigObject(existing, npxPath);
+  const merged = mergeJetBrainsMcpConfigObject(existing, memoraone);
   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" };
+  if (existed && existing) {
+    const currentMemoraone = existing.mcpServers && typeof existing.mcpServers === "object" && !Array.isArray(existing.mcpServers) ? existing.mcpServers.memoraone : void 0;
+    if (memoraoneServerMatches(currentMemoraone, memoraone)) {
+      repairActions.push({ type: "wrote-global-config", path: globalPath, outcome: "skipped" });
+      return { outcome: "skipped", repairActions, memoraone };
     }
   }
-  if (dryRun) {
-    return { outcome: existed ? "updated" : "created" };
+  if (options.dryRun) {
+    const outcome2 = existed ? "updated" : "created";
+    repairActions.push({ type: "wrote-global-config", path: globalPath, outcome: outcome2 });
+    return { outcome: outcome2, repairActions, memoraone };
   }
   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}`);
+    backupPath = await backupConfigFile(globalPath);
+  }
+  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";
+  repairActions.push({ type: "wrote-global-config", path: globalPath, outcome });
+  let verifyOk;
+  let verifyDetail;
+  if (options.verify !== false) {
+    const verify = await verifyJetBrainsMcpHandshake({ server: memoraone });
+    verifyOk = verify.ok;
+    verifyDetail = verify.detail;
+    repairActions.push({ type: "verify-handshake", ok: verify.ok, detail: verify.detail });
+  }
+  return { outcome, backupPath, repairActions, verifyOk, verifyDetail, memoraone };
+}
+function logJetBrainsMcpCliSummary(info, dryRun) {
+  for (const action of info.repairActions) {
+    if (action.type === "found-config") {
+      console.log(`[setup-ide-files] Found JetBrains MCP config (${action.location.kind}): ${action.location.path}`);
+    } else if (action.type === "repaired-zero-byte") {
+      console.log(`[setup-ide-files] Repaired zero-byte MCP config: ${action.path}`);
+      console.log(`[setup-ide-files] Backup: ${action.backupPath}`);
+    } else if (action.type === "backed-up-conflicting-project-config") {
+      console.log(`[setup-ide-files] Backed up conflicting project MCP config: ${action.path}`);
+      console.log(`[setup-ide-files] Backup: ${action.backupPath}`);
+    } else if (action.type === "removed-project-memoraone") {
+      console.log(`[setup-ide-files] Removed project-scoped memoraone definition: ${action.path}`);
+    } else if (action.type === "verify-handshake") {
+      if (action.ok) {
+        console.log(`[setup-ide-files] MCP handshake verification: ${action.detail}`);
+      } else {
+        console.log(`[setup-ide-files] MCP handshake verification skipped/failed: ${action.detail}`);
+      }
+    }
   }
-  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}`
-    );
-  } else if (outcome === "skipped") {
-    console.log(`[setup-ide-files] Cursor global MCP config unchanged: ${configPath}`);
+  const prefix = dryRun ? "would be " : "";
+  if (info.outcome === "created") {
+    console.log(`[setup-ide-files] JetBrains global MCP config ${prefix}created: ${info.activeConfigPath}`);
+  } else if (info.outcome === "updated") {
+    console.log(`[setup-ide-files] JetBrains global MCP config ${prefix}updated: ${info.activeConfigPath}`);
+  } else {
+    console.log(`[setup-ide-files] JetBrains global MCP config unchanged: ${info.activeConfigPath}`);
   }
+  if (info.backupPath) {
+    console.log(`[setup-ide-files] JetBrains global MCP config backup: ${info.backupPath}`);
+  }
+  if (info.npxPath) {
+    console.log(`[setup-ide-files] Resolved npx: ${info.npxPath}`);
+  }
+  console.log(`[setup-ide-files] Final active JetBrains MCP config: ${info.activeConfigPath}`);
   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."
+    "[setup-ide-files] Fully quit JetBrains IDE and reopen this repo for MCP changes to take effect."
   );
 }
 
@@ -906,15 +2314,15 @@ function buildMemoraoneMcpServer(ideType, command = "npx") {
   };
 }
 function assertUnderRepoRoot(repoRoot, absPath) {
-  const normRoot = path5.resolve(repoRoot) + path5.sep;
-  const normPath = path5.resolve(absPath);
-  if (normPath !== path5.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 pathExists2(filePath) {
+async function pathExists3(filePath) {
   try {
-    await fs5.access(filePath);
+    await fs7.access(filePath);
     return true;
   } catch {
     return false;
@@ -935,12 +2343,12 @@ ${GITIGNORE_MEMORAONE_ENTRY}
 }
 async function ensureGitignoreMemoraone(repoRoot, opts) {
   if (opts.noGitignore) return "skipped";
-  const abs = path5.join(repoRoot, ".gitignore");
+  const abs = path9.join(repoRoot, ".gitignore");
   assertUnderRepoRoot(repoRoot, abs);
   let prior = "";
   let existed = false;
   try {
-    prior = await fs5.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;
@@ -951,25 +2359,25 @@ 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 fs5.writeFile(abs, next, "utf8");
+  await fs7.writeFile(abs, next, "utf8");
   return existed ? "updated" : "created";
 }
 async function findRepoRoot(startDir) {
-  let current = path5.resolve(startDir);
-  const root = path5.parse(current).root;
+  let current = path9.resolve(startDir);
+  const root = path9.parse(current).root;
   while (true) {
-    const gitPath = path5.join(current, ".git");
-    const m1Path = path5.join(current, "memoraone.m1");
-    if (await pathExists2(gitPath) || await pathExists2(m1Path)) {
+    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 = path5.dirname(current);
+    current = path9.dirname(current);
   }
 }
-function stripLeadingLineComments2(text) {
+function stripLeadingLineComments3(text) {
   return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
 }
 function cursorRuleBody() {
@@ -977,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
 
@@ -1019,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 = path5.join(repoRoot, relPath);
+  const abs = path9.join(repoRoot, relPath);
   assertUnderRepoRoot(repoRoot, abs);
   let prior = "";
   let existed = false;
   try {
-    prior = await fs5.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 fs5.mkdir(path5.dirname(abs), { recursive: true });
-    await fs5.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 fs5.mkdir(path5.dirname(abs), { recursive: true });
-    await fs5.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 fs5.mkdir(path5.dirname(abs), { recursive: true });
-  await fs5.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 = path5.join(repoRoot, relPath);
+  const abs = path9.join(repoRoot, relPath);
   assertUnderRepoRoot(repoRoot, abs);
   let raw = "";
   let existed = false;
   try {
-    raw = await fs5.readFile(abs, "utf8");
+    raw = await fs7.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
@@ -1063,15 +2475,15 @@ async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
   if (!existed) {
     const body = buildBody(null);
     if (opts.dryRun) return "created";
-    await fs5.mkdir(path5.dirname(abs), { recursive: true });
-    await fs5.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);
   if (!managed && !opts.force) return "skipped-untracked";
   let parsed = null;
   try {
-    parsed = JSON.parse(stripLeadingLineComments2(raw));
+    parsed = JSON.parse(stripLeadingLineComments3(raw));
   } catch {
     parsed = null;
   }
@@ -1079,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 fs5.mkdir(path5.dirname(abs), { recursive: true });
-  await fs5.writeFile(abs, next, "utf8");
+  await fs7.mkdir(path9.dirname(abs), { recursive: true });
+  await fs7.writeFile(abs, next, "utf8");
   return "updated";
 }
 function parseSetupIdeFlags(argv) {
@@ -1092,6 +2504,8 @@ function parseSetupIdeFlags(argv) {
   let dryRun = false;
   let noGitignore = false;
   let cleanup = false;
+  let devMode = false;
+  let repair = false;
   const unknown = [];
   for (const a of argv) {
     if (a === "--cursor") cursor = true;
@@ -1102,6 +2516,8 @@ function parseSetupIdeFlags(argv) {
     else if (a === "--dry-run") dryRun = true;
     else if (a === "--no-gitignore") noGitignore = true;
     else if (a === "--cleanup") cleanup = true;
+    else if (a === "--dev") devMode = true;
+    else if (a === "--repair") repair = true;
     else if (a.startsWith("-")) unknown.push(a);
   }
   const specific = cursor || vscode || jetbrains;
@@ -1111,7 +2527,7 @@ function parseSetupIdeFlags(argv) {
   } else {
     targets = { cursor, vscode, jetbrains };
   }
-  return { targets, force, dryRun, noGitignore, cleanup, unknown };
+  return { targets, force, dryRun, noGitignore, cleanup, devMode, repair, unknown };
 }
 function summarizeOutcomes(outcomes) {
   const created = [];
@@ -1133,9 +2549,145 @@ 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) {
     return {
@@ -1145,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
@@ -1155,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;
@@ -1179,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(
@@ -1188,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(
@@ -1236,11 +2825,45 @@ description: MemoraOne MCP \u2014 IDE agent instructions
       copilotAndJetBrainsBody("MemoraOne MCP \u2014 JetBrains AI Assistant"),
       { force: o.force, dryRun: o.dryRun }
     );
+    try {
+      const homeDir = o.jetbrainsHomeDir ?? os4.homedir();
+      const activePath = o.jetbrainsGlobalMcpConfigPath ?? getJetBrainsGlobalMcpConfigPath(homeDir);
+      const jetbrainsSetup = await setupJetBrainsMcpConfig({
+        homeDir,
+        repoRoot,
+        globalConfigPath: activePath,
+        dryRun: o.dryRun,
+        devMode: o.devMode,
+        repair: o.repair ?? false,
+        verify: o.verifyHandshake ?? !o.dryRun,
+        npxPathOverride: o.npxPathOverride,
+        cliPathOverride: o.cliPathOverride
+      });
+      jetbrainsMcp = {
+        activeConfigPath: activePath,
+        outcome: jetbrainsSetup.outcome,
+        npxPath: jetbrainsSetup.memoraone?.command,
+        backupPath: jetbrainsSetup.backupPath,
+        repairActions: jetbrainsSetup.repairActions,
+        verifyOk: jetbrainsSetup.verifyOk,
+        verifyDetail: jetbrainsSetup.verifyDetail
+      };
+      outcomes[`jetbrains-global:${activePath}`] = jetbrainsSetup.outcome;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        exitCode: 1,
+        repoRoot,
+        outcomes,
+        cursorMcp,
+        error: message
+      };
+    }
   }
-  return { exitCode: 0, repoRoot, outcomes, cursorGlobalMcp };
+  return { exitCode: 0, repoRoot, outcomes, cursorMcp, jetbrainsMcp, daemonCleanup };
 }
 async function cliSetupIdeFiles(argv) {
-  const { targets, force, dryRun, noGitignore, cleanup, unknown } = parseSetupIdeFlags(argv);
+  const { targets, force, dryRun, noGitignore, cleanup, devMode, repair, unknown } = parseSetupIdeFlags(argv);
   if (unknown.length) {
     console.error(`[setup-ide-files] Unknown option(s): ${unknown.join(", ")}`);
     return 1;
@@ -1250,7 +2873,9 @@ async function cliSetupIdeFiles(argv) {
     targets,
     force,
     dryRun,
-    noGitignore
+    noGitignore,
+    devMode,
+    repair
   });
   if (result.error) {
     console.error(result.error);
@@ -1263,15 +2888,25 @@ 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);
   }
   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,
@@ -1282,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;
 }
@@ -1302,7 +2930,7 @@ if (args.includes("--version") || args.includes("-v")) {
 }
 if (args.includes("--help") || args.includes("-h")) {
   console.log(
-    "Usage: memoraone-mcp [--version] [--help] [--daemon --project-id <uuid> [--ide cursor|copilot-vscode|jetbrains]]\n       memoraone-mcp setup-ide-files [--all|--cursor|--vscode|--jetbrains] [--force] [--dry-run] [--no-gitignore] [--cleanup]\n       memoraone-mcp cleanup [--project-id <uuid>] [--ide cursor|copilot-vscode|jetbrains] [--dry-run] [--all-projects] [--yes]"
+    "Usage: memoraone-mcp [--version] [--help] [--daemon --project-id <uuid> [--ide cursor|copilot-vscode|jetbrains]]\n       memoraone-mcp setup-ide-files [--all|--cursor|--vscode|--jetbrains] [--force] [--dry-run] [--no-gitignore] [--cleanup] [--dev] [--repair]\n       memoraone-mcp cleanup [--project-id <uuid>] [--ide cursor|copilot-vscode|jetbrains] [--dry-run] [--all-projects] [--yes]"
   );
   process.exit(0);
 }
@@ -1325,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(path6.delimiter).map((s) => s.trim()).filter(Boolean)) {
-        parts.push(path6.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((resolve6, reject) => {
-      const tryConnect = (attempt) => {
-        const socket = net.connect(socketPath, () => {
-          resolve6(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_process3.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);
   });
 }