@memoraone/mcp 0.1.29 → 0.1.31

package/dist/daemon.cjs

@@ -32,15 +32,61 @@ __export(daemon_exports, {
   runDaemon: () => runDaemon
 });
 module.exports = __toCommonJS(daemon_exports);
-var fs6 = __toESM(require("fs"), 1);
+var fs7 = __toESM(require("fs"), 1);
 var net = __toESM(require("net"), 1);
 var import_stdio2 = require("@modelcontextprotocol/sdk/server/stdio.js");
 
 // src/socketPaths.ts
 var os = __toESM(require("os"), 1);
-var path = __toESM(require("path"), 1);
+var path2 = __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");
+
+// 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 input = [
+    projectId.trim().toLowerCase(),
+    path.resolve(workspaceRoot),
+    ideType
+  ].join("|");
+  return crypto.createHash("sha256").update(input).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/socketPaths.ts
+var BASE_DIR = process.env.MEMORAONE_MCP_LOCK_DIR || path2.join(os.homedir(), ".memoraone-mcp");
+var HASH_SOCKET_FILENAME_RE = new RegExp(
+  `^mcp-[0-9a-f]{${BINDING_SOCKET_HASH_LENGTH}}\\.sock$`,
+  "i"
+);
 var IDE_TYPES = ["cursor", "copilot-vscode", "jetbrains"];
 var IDE_TYPE_SET = new Set(IDE_TYPES);
 function parseIdeType(value) {
@@ -59,11 +105,16 @@ function parseIdeTypeFromArgv(args) {
   }
   return parseIdeType(args[idx + 1]);
 }
-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(env2 = process.env) {
+  return resolveIdeTypeFromEnv(env2) ?? "";
+}
+function getBindingSocketFilename(binding, env2 = process.env) {
+  const ideType = resolveBindingIdeType(env2);
+  const hash = hashBindingIdentity(binding.projectId, binding.workspaceRoot, ideType);
+  return `mcp-${hash}.sock`;
+}
+function getBindingSocketPath(binding, env2 = process.env) {
+  return path2.join(BASE_DIR, getBindingSocketFilename(binding, env2));
 }
 function ensureBaseDir() {
   fs.mkdirSync(BASE_DIR, { recursive: true });
@@ -72,7 +123,7 @@ function ensureBaseDir() {
 
 // src/projectBinding.ts
 var fs2 = __toESM(require("fs/promises"), 1);
-var path2 = __toESM(require("path"), 1);
+var path3 = __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") {
@@ -105,7 +156,7 @@ async function resolveProjectIdFromExplicitM1Path() {
   if (raw === void 0 || raw.trim() === "") {
     return null;
   }
-  const markerPath = path2.resolve(raw);
+  const markerPath = path3.resolve(raw);
   try {
     const content = await fs2.readFile(markerPath, "utf8");
     const { projectId, apiKey, environment } = parseAndValidateM1(content, markerPath);
@@ -118,20 +169,20 @@ async function resolveProjectIdFromExplicitM1Path() {
   }
 }
 async function findM1WalkingUp(workspaceRoot) {
-  let current = path2.resolve(workspaceRoot);
+  let current = path3.resolve(workspaceRoot);
   while (true) {
-    const markerPath = path2.join(current, "memoraone.m1");
+    const markerPath = path3.join(current, "memoraone.m1");
     try {
       const content = await fs2.readFile(markerPath, "utf8");
       const { projectId, apiKey, environment } = parseAndValidateM1(content, markerPath);
-      const repoRoot = path2.dirname(markerPath);
+      const repoRoot = path3.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);
+    const parent = path3.dirname(current);
     if (parent === current) {
       break;
     }
@@ -154,7 +205,7 @@ function normalizeWorkspaceSearchRoots(workspaceRoot) {
     if (trimmed === "") {
       continue;
     }
-    const resolved = path2.resolve(trimmed);
+    const resolved = path3.resolve(trimmed);
     if (!seen.has(resolved)) {
       seen.add(resolved);
       out.push(resolved);
@@ -176,29 +227,33 @@ function resolveApiKeyWithSource(fileApiKey) {
   }
   return { apiKey: null, apiKeySource: "none" };
 }
-async function resolveAuthoritativeBinding(workspaceRoot) {
-  const explicitBinding = await resolveProjectIdFromExplicitM1Path();
-  if (explicitBinding) {
-    const resolved = resolveApiKeyWithSource(explicitBinding.apiKey);
-    return {
-      projectId: explicitBinding.projectId,
-      workspaceRoot: path2.dirname(explicitBinding.foundAt),
-      m1Path: explicitBinding.foundAt,
-      apiKey: resolved.apiKey,
-      ...explicitBinding.environment !== void 0 ? { environment: explicitBinding.environment } : {},
-      bindingSource: "explicit-m1-path",
-      apiKeySource: resolved.apiKeySource
-    };
+async function resolveAuthoritativeBinding(workspaceRoot, options = {}) {
+  const respectExplicitM1Path = options.respectExplicitM1Path !== false;
+  if (respectExplicitM1Path) {
+    const explicitBinding = await resolveProjectIdFromExplicitM1Path();
+    if (explicitBinding) {
+      const resolved = resolveApiKeyWithSource(explicitBinding.apiKey);
+      return {
+        projectId: explicitBinding.projectId,
+        workspaceRoot: path3.dirname(explicitBinding.foundAt),
+        m1Path: explicitBinding.foundAt,
+        apiKey: resolved.apiKey,
+        ...explicitBinding.environment !== void 0 ? { environment: explicitBinding.environment } : {},
+        bindingSource: "explicit-m1-path",
+        apiKeySource: resolved.apiKeySource
+      };
+    }
   }
   const candidates = normalizeWorkspaceSearchRoots(workspaceRoot);
   if (candidates.length === 0) {
     throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
   }
+  const bindings = [];
   for (const root of candidates) {
     const binding = await findM1WalkingUp(root);
     if (binding) {
       const resolved = resolveApiKeyWithSource(binding.apiKey);
-      return {
+      bindings.push({
         projectId: binding.projectId,
         workspaceRoot: binding.repoRoot,
         m1Path: binding.markerPath,
@@ -206,10 +261,25 @@ async function resolveAuthoritativeBinding(workspaceRoot) {
         ...binding.environment !== void 0 ? { environment: binding.environment } : {},
         bindingSource: "workspace-search",
         apiKeySource: resolved.apiKeySource
-      };
+      });
     }
   }
-  throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
+  if (bindings.length === 0) {
+    throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
+  }
+  const distinctProjectIds = new Set(bindings.map((b) => b.projectId));
+  if (distinctProjectIds.size > 1) {
+    const lines = bindings.map(
+      (b) => `  - workspace=${b.workspaceRoot} project=${b.projectId} m1=${b.m1Path}`
+    );
+    throw new Error(
+      "[memoraone-mcp] Ambiguous workspace binding: multiple open roots map to different MemoraOne projects.\n" + lines.join("\n") + "\nOpen one repo per Cursor window, or use repo-scoped .cursor/mcp.json from setup-ide-files --cursor."
+    );
+  }
+  return bindings[0];
+}
+function encodeResolvedBinding(binding) {
+  return Buffer.from(JSON.stringify(binding), "utf8").toString("base64");
 }
 function decodeResolvedBinding(value) {
   if (!value) {
@@ -257,17 +327,43 @@ function decodeResolvedBinding(value) {
   };
 }
 
+// src/bindingSidecar.ts
+var fs3 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+function bindingSidecarPath(socketPath) {
+  if (socketPath.endsWith(".sock")) {
+    return `${socketPath.slice(0, -".sock".length)}.binding.json`;
+  }
+  return `${socketPath}.binding.json`;
+}
+function writeBindingSidecar(socketPath, binding, ideType = resolveBindingIdeType()) {
+  const payload = encodeResolvedBinding(binding);
+  const record = {
+    v: 2,
+    ...ideType ? { ideType } : {},
+    projectId: binding.projectId,
+    workspaceRoot: binding.workspaceRoot,
+    m1Path: binding.m1Path,
+    binding: payload
+  };
+  fs3.writeFileSync(bindingSidecarPath(socketPath), JSON.stringify(record), "utf8");
+}
+function removeBindingSidecar(socketPath) {
+  try {
+    fs3.unlinkSync(bindingSidecarPath(socketPath));
+  } catch {
+  }
+}
+
 // src/index.ts
-var path7 = __toESM(require("path"), 1);
-var import_node_url2 = require("url");
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_types = require("@modelcontextprotocol/sdk/types.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 
 // src/config.ts
 var process2 = __toESM(require("process"), 1);
-var fs3 = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
+var fs4 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
 var dotenv = __toESM(require("dotenv"), 1);
 var import_v4 = require("zod/v4");
 
@@ -290,8 +386,8 @@ function resolveApiUrl(env2) {
 }
 
 // src/config.ts
-var dotenvPath = path3.resolve(process2.cwd(), ".env");
-if (fs3.existsSync(dotenvPath)) {
+var dotenvPath = path5.resolve(process2.cwd(), ".env");
+if (fs4.existsSync(dotenvPath)) {
   try {
     dotenv.config({ path: dotenvPath });
   } catch (err) {
@@ -358,7 +454,7 @@ var config2 = {
 };
 
 // src/client/memoraClient.ts
-var crypto = __toESM(require("crypto"), 1);
+var crypto2 = __toESM(require("crypto"), 1);
 var PROJECT_ID_HEADER = "x-project-id";
 var uuidRegex2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var parseBooleanFlag2 = (value) => {
@@ -427,12 +523,12 @@ var MemoraClient = class {
       ...options?.headers ?? {}
     };
   }
-  async post(path8, body, options) {
+  async post(path10, body, options) {
     console.error(
-      `[memoraone-mcp][info] MemoraClient.post ENTER path=${path8}`
+      `[memoraone-mcp][info] MemoraClient.post ENTER path=${path10}`
     );
-    const nonce = crypto.randomBytes(8).toString("hex");
-    const url = `${this.baseUrl}${path8.startsWith("/") ? path8 : `/${path8}`}`;
+    const nonce = crypto2.randomBytes(8).toString("hex");
+    const url = `${this.baseUrl}${path10.startsWith("/") ? path10 : `/${path10}`}`;
     this.resolveProjectId();
     console.error(
       `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=POST url=${url}`
@@ -465,13 +561,13 @@ var MemoraClient = class {
       throw new MemoraOneHttpError(res.status, res.statusText, res.text);
     }
     console.error(
-      `[memoraone-mcp][info] MemoraClient.post EXIT path=${path8}`
+      `[memoraone-mcp][info] MemoraClient.post EXIT path=${path10}`
     );
     return res.text ? JSON.parse(res.text) : null;
   }
-  async get(path8, options) {
-    const nonce = crypto.randomBytes(8).toString("hex");
-    const url = `${this.baseUrl}${path8.startsWith("/") ? path8 : `/${path8}`}`;
+  async get(path10, options) {
+    const nonce = crypto2.randomBytes(8).toString("hex");
+    const url = `${this.baseUrl}${path10.startsWith("/") ? path10 : `/${path10}`}`;
     this.resolveProjectId();
     console.error(
       `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=GET url=${url}`
@@ -501,15 +597,195 @@ var MemoraClient = class {
 };
 var memoraClient_default = MemoraClient;
 
-// src/sourceRegistration.ts
-var path4 = __toESM(require("path"), 1);
+// src/initializeBinding.ts
+var path6 = __toESM(require("path"), 1);
 var import_node_url = require("url");
+var MEMORAONE_WORKSPACE_ROOT_ENV = "MEMORAONE_WORKSPACE_ROOT";
+function getBridgeBindingResolveOptions(env2 = process.env) {
+  const ideType = resolveIdeTypeFromEnv(env2);
+  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(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;
+}
+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 = path6.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(env2 = process.env) {
+  const raw = env2[MEMORAONE_WORKSPACE_ROOT_ENV];
+  if (raw === void 0 || raw.trim() === "") {
+    return null;
+  }
+  return path6.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.`;
+}
+function formatBindingMismatchError(daemonHint, sessionBinding) {
+  return `[memoraone-mcp] Project binding mismatch between daemon and MCP initialize workspace.
+  daemon: project=${daemonHint.projectId} workspace=${daemonHint.workspaceRoot} m1=${daemonHint.m1Path}
+  initialize: project=${sessionBinding.projectId} workspace=${sessionBinding.workspaceRoot} m1=${sessionBinding.m1Path}
+Reconnect or reload the MCP server in this IDE window so the bridge can bind to the correct project.`;
+}
+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 env2 = options.env ?? process.env;
+  const resolveOpts = {
+    respectExplicitM1Path: options.respectExplicitM1Path,
+    allowEnvWorkspaceFallback: options.allowEnvWorkspaceFallback
+  };
+  const repoHint = getRepoScopedWorkspaceHint(env2);
+  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 = path6.resolve(repoHint);
+    const matchingRoot = rootsListPaths.find((root) => path6.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/bridgeClientRoots.ts
+var readline = __toESM(require("readline"), 1);
+var TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+function isInitializeDebugEnabled(env2 = process.env) {
+  return TRUTHY.has(String(env2.MEMORAONE_DEBUG_INIT ?? "").trim().toLowerCase());
+}
+
+// src/sourceRegistration.ts
+var path7 = __toESM(require("path"), 1);
+var import_node_url2 = require("url");
 var LOG_PREFIX = "[memoraone-mcp][source-registration]";
 function buildRepoSourcePayload(normalizedRepoPath, ideType) {
   const body = {
     kind: "repo",
-    label: path4.basename(normalizedRepoPath),
-    uri: (0, import_node_url.pathToFileURL)(normalizedRepoPath).href
+    label: path7.basename(normalizedRepoPath),
+    uri: (0, import_node_url2.pathToFileURL)(normalizedRepoPath).href
   };
   if (ideType) {
     body.metadata = {
@@ -527,7 +803,7 @@ async function registerRepoSource(client, projectId, repoPath, ideType) {
       );
       return;
     }
-    const normalizedRepoPath = path4.resolve(String(repoPath));
+    const normalizedRepoPath = path7.resolve(String(repoPath));
     const body = buildRepoSourcePayload(normalizedRepoPath, ideType);
     const primaryPath = `/v1/projects/${projectId}/sources`;
     const alternatePath = `/v1/projects/${projectId}/sources/register`;
@@ -687,11 +963,11 @@ var bindingStatusShape = {};
 
 // src/tools/handlers/postEvent.ts
 var import_v412 = require("zod/v4");
-var crypto3 = __toESM(require("crypto"), 1);
+var crypto4 = __toESM(require("crypto"), 1);
 
 // src/runContext.ts
 var import_node_async_hooks = require("async_hooks");
-var crypto2 = __toESM(require("crypto"), 1);
+var crypto3 = __toESM(require("crypto"), 1);
 var sessionContextStorage = new import_node_async_hooks.AsyncLocalStorage();
 function createSessionRunContext(initial = {}) {
   return {
@@ -744,7 +1020,7 @@ function resolveRunId(passed) {
   return getCurrentRunId();
 }
 function generateRunId() {
-  return crypto2.randomBytes(16).toString("hex");
+  return crypto3.randomBytes(16).toString("hex");
 }
 
 // src/tools/handlers/postEvent.ts
@@ -784,7 +1060,7 @@ function buildPostEventContentFields(content) {
   return { message: JSON.stringify(content) };
 }
 async function handlePostEvent(client, args) {
-  const nonce = crypto3.randomBytes(8).toString("hex");
+  const nonce = crypto4.randomBytes(8).toString("hex");
   console.error(
     `[memoraone-mcp][debug] tool=memora_post_event toolCallId=unknown nonce=${nonce} stage=before_post`
   );
@@ -939,9 +1215,9 @@ function buildPersonalContextPath(parsed2) {
 }
 async function handleGetPersonalContext(client, args) {
   const parsed2 = getPersonalContextInputSchema.parse(args ?? {});
-  const path8 = buildPersonalContextPath(parsed2);
+  const path10 = buildPersonalContextPath(parsed2);
   try {
-    const result = await client.get(path8);
+    const result = await client.get(path10);
     return { ok: true, result };
   } catch (err) {
     if (err instanceof MemoraOneHttpError) {
@@ -1182,9 +1458,9 @@ async function handleListProjects(client) {
 var import_v421 = require("zod/v4");
 
 // src/repoFingerprint.ts
-var fs4 = __toESM(require("fs"), 1);
-var path5 = __toESM(require("path"), 1);
-var crypto4 = __toESM(require("crypto"), 1);
+var fs5 = __toESM(require("fs"), 1);
+var path8 = __toESM(require("path"), 1);
+var crypto5 = __toESM(require("crypto"), 1);
 var parseBooleanFlag3 = (value) => {
   if (!value) {
     return false;
@@ -1209,20 +1485,20 @@ var normalizeRemoteUrl = (remoteUrl) => {
   return normalized.toLowerCase();
 };
 var sha256 = (value) => {
-  return crypto4.createHash("sha256").update(value).digest("hex");
+  return crypto5.createHash("sha256").update(value).digest("hex");
 };
 var resolveGitDir = (gitPath) => {
   try {
-    const stat2 = fs4.statSync(gitPath);
+    const stat2 = fs5.statSync(gitPath);
     if (stat2.isDirectory()) {
       return gitPath;
     }
     if (stat2.isFile()) {
-      const content = fs4.readFileSync(gitPath, "utf8");
+      const content = fs5.readFileSync(gitPath, "utf8");
       const match = content.match(/^gitdir:\s*(.+)$/m);
       if (match) {
         const gitDir = match[1].trim();
-        return path5.resolve(path5.dirname(gitPath), gitDir);
+        return path8.resolve(path8.dirname(gitPath), gitDir);
       }
     }
   } catch {
@@ -1231,16 +1507,16 @@ var resolveGitDir = (gitPath) => {
   return null;
 };
 var findGitRoot = (start) => {
-  let current = path5.resolve(start);
+  let current = path8.resolve(start);
   while (true) {
-    const gitPath = path5.join(current, ".git");
-    if (fs4.existsSync(gitPath)) {
+    const gitPath = path8.join(current, ".git");
+    if (fs5.existsSync(gitPath)) {
       const gitDir = resolveGitDir(gitPath);
       if (gitDir) {
         return { gitRoot: current, gitDir };
       }
     }
-    const parent = path5.dirname(current);
+    const parent = path8.dirname(current);
     if (parent === current) {
       break;
     }
@@ -1249,9 +1525,9 @@ var findGitRoot = (start) => {
   return null;
 };
 var readOriginRemote = (gitDir) => {
-  const configPath = path5.join(gitDir, "config");
+  const configPath = path8.join(gitDir, "config");
   try {
-    const content = fs4.readFileSync(configPath, "utf8");
+    const content = fs5.readFileSync(configPath, "utf8");
     const lines = content.split(/\r?\n/);
     let inOrigin = false;
     for (const line of lines) {
@@ -1275,7 +1551,7 @@ var readOriginRemote = (gitDir) => {
 function resolveRepoFingerprint(cwd2) {
   const found = findGitRoot(cwd2);
   if (!found) {
-    const fallbackPath = path5.resolve(cwd2);
+    const fallbackPath = path8.resolve(cwd2);
     const fingerprint2 = sha256(fallbackPath);
     debugLog(`repo fingerprint=${fingerprint2} source=path-fallback`);
     return {
@@ -1297,7 +1573,7 @@ function resolveRepoFingerprint(cwd2) {
       source: "git-remote"
     };
   }
-  const fingerprint = sha256(path5.resolve(gitRoot));
+  const fingerprint = sha256(path8.resolve(gitRoot));
   debugLog(`repo fingerprint=${fingerprint} source=path-fallback`);
   return {
     fingerprint,
@@ -1307,8 +1583,8 @@ function resolveRepoFingerprint(cwd2) {
 }
 
 // src/workspaceMap.ts
-var fs5 = __toESM(require("fs/promises"), 1);
-var path6 = __toESM(require("path"), 1);
+var fs6 = __toESM(require("fs/promises"), 1);
+var path9 = __toESM(require("path"), 1);
 var import_node_os = __toESM(require("os"), 1);
 var parseBooleanFlag4 = (value) => {
   if (!value) {
@@ -1327,11 +1603,11 @@ var debugLog2 = (message) => {
 };
 var fingerprintRegex = /^[0-9a-f]{64}$/i;
 function getWorkspaceMapPath() {
-  return path6.join(import_node_os.default.homedir(), ".memoraone", "workspaces.json");
+  return path9.join(import_node_os.default.homedir(), ".memoraone", "workspaces.json");
 }
 var ensureWorkspaceDir = async () => {
-  const dir = path6.dirname(getWorkspaceMapPath());
-  await fs5.mkdir(dir, { recursive: true });
+  const dir = path9.dirname(getWorkspaceMapPath());
+  await fs6.mkdir(dir, { recursive: true });
 };
 async function acquireWorkspaceMapLock() {
   const filePath = getWorkspaceMapPath();
@@ -1345,10 +1621,10 @@ async function acquireWorkspaceMapLock() {
   while (!lockAcquired && retries < maxRetries) {
     try {
       try {
-        const stat2 = await fs5.stat(lockPath);
+        const stat2 = await fs6.stat(lockPath);
         const ageMs = Date.now() - stat2.mtimeMs;
         if (ageMs > maxLockAgeMs) {
-          await fs5.unlink(lockPath);
+          await fs6.unlink(lockPath);
           debugLog2(`removed stale workspace map lock (age: ${ageMs}ms)`);
         }
       } catch (err) {
@@ -1356,14 +1632,14 @@ async function acquireWorkspaceMapLock() {
           throw err;
         }
       }
-      const fd = await fs5.open(lockPath, "wx");
+      const fd = await fs6.open(lockPath, "wx");
       await fd.close();
       lockAcquired = true;
     } catch (err) {
       if (err?.code === "EEXIST") {
         retries++;
         if (retries < maxRetries) {
-          await new Promise((resolve6) => setTimeout(resolve6, retryDelayMs));
+          await new Promise((resolve7) => setTimeout(resolve7, retryDelayMs));
           continue;
         }
         throw new Error(
@@ -1375,7 +1651,7 @@ async function acquireWorkspaceMapLock() {
   }
   return async () => {
     try {
-      await fs5.unlink(lockPath);
+      await fs6.unlink(lockPath);
     } catch (err) {
       if (err?.code !== "ENOENT") {
         debugLog2(`failed to release workspace map lock: ${String(err)}`);
@@ -1431,7 +1707,7 @@ var validateWorkspaceMap = (map, filePath) => {
 async function readWorkspaceMap() {
   const filePath = getWorkspaceMapPath();
   try {
-    const content = await fs5.readFile(filePath, "utf8");
+    const content = await fs6.readFile(filePath, "utf8");
     const parsed2 = JSON.parse(content);
     validateWorkspaceMap(parsed2, filePath);
     const typed = parsed2;
@@ -1476,8 +1752,8 @@ async function writeWorkspaceMap(map) {
   await ensureWorkspaceDir();
   const tempPath = `${filePath}.tmp`;
   const content = JSON.stringify(map, null, 2);
-  await fs5.writeFile(tempPath, content, "utf8");
-  await fs5.rename(tempPath, filePath);
+  await fs6.writeFile(tempPath, content, "utf8");
+  await fs6.rename(tempPath, filePath);
 }
 async function setProjectIdForFingerprint(args) {
   const { fingerprint, projectKey, source, linked_at } = args;
@@ -1557,9 +1833,9 @@ function handleBindingStatus(binding) {
 }
 
 // src/heartbeat.ts
-var crypto5 = __toESM(require("crypto"), 1);
+var crypto6 = __toESM(require("crypto"), 1);
 function fingerprintApiKey(apiKey) {
-  return crypto5.createHash("sha256").update(apiKey).digest("hex").slice(0, 12);
+  return crypto6.createHash("sha256").update(apiKey).digest("hex").slice(0, 12);
 }
 function isHeartbeatDebugEnabled() {
   const value = String(process.env.MEMORAONE_DEBUG_HEARTBEAT ?? "").trim().toLowerCase();
@@ -1709,21 +1985,6 @@ var notInitializedResult = {
   ]
 };
 var initializeDiagDumped = false;
-var uriToPath = (uri) => {
-  if (uri.startsWith("file://")) {
-    return (0, import_node_url2.fileURLToPath)(uri);
-  }
-  return uri;
-};
-function getCursorWorkspaceRootFromEnv() {
-  const raw = process.env.WORKSPACE_FOLDER_PATHS;
-  if (raw === void 0 || raw.trim() === "") {
-    return void 0;
-  }
-  const parts = raw.split(path7.delimiter).map((p) => p.trim()).filter(Boolean);
-  const first = parts[0];
-  return first ? path7.resolve(first) : void 0;
-}
 function redactSensitiveFields(obj) {
   if (obj === null || obj === void 0) return obj;
   if (typeof obj !== "object") return obj;
@@ -1802,8 +2063,8 @@ function registerToolWithWorklog(server, runtime, sessionContext, toolName, desc
 async function main(opts = {}) {
   let bindingReadyResolve = null;
   let bindingReadyReject = null;
-  const bindingReady = new Promise((resolve6, reject) => {
-    bindingReadyResolve = resolve6;
+  const bindingReady = new Promise((resolve7, reject) => {
+    bindingReadyResolve = resolve7;
     bindingReadyReject = reject;
   });
   const devMode = Boolean(config2.devMode);
@@ -1814,7 +2075,7 @@ async function main(opts = {}) {
     projectId: null,
     apiKeySource: null,
     apiKeyFingerprint: null,
-    authoritativeBinding: opts.authoritativeBinding ?? null,
+    authoritativeBinding: null,
     ideType: void 0
   };
   let workspaceRoot;
@@ -1822,42 +2083,53 @@ async function main(opts = {}) {
     name: "memoraone-mcp",
     version: "1.0.0"
   });
-  const resolveFallbackBindingFromInitialize = async (params) => {
-    let fallbackWorkspaceRoot = workspaceRoot;
+  const resolveSessionBindingFromInitialize = async (params) => {
+    const initializeRoots = extractWorkspaceRootsFromInitialize(params);
+    if (initializeRoots.length === 0 && opts.daemonBindingHint) {
+      if (isInitializeDebugEnabled()) {
+        console.error(
+          "[memoraone-mcp][init-debug] Workspace resolution strategy: daemonBindingHint (bridge pre-resolved)"
+        );
+      }
+      return opts.daemonBindingHint;
+    }
+    let rootsListUris;
+    let rootsListAttempted = false;
     try {
       const rootsResult = await server.server.listRoots({});
+      rootsListAttempted = true;
       const roots = Array.isArray(rootsResult?.roots) ? rootsResult.roots : [];
-      console.error(`[memoraone-mcp] roots/list returned ${roots.length}: ${JSON.stringify(roots)}`);
-      if (!fallbackWorkspaceRoot && roots.length > 0 && roots[0]?.uri) {
-        fallbackWorkspaceRoot = uriToPath(roots[0].uri);
-        console.error("[memoraone-mcp] Workspace resolution strategy: roots/list (first root)");
+      if (isInitializeDebugEnabled()) {
+        console.error(`[memoraone-mcp][init-debug] roots/list returned ${roots.length}: ${JSON.stringify(roots)}`);
+      }
+      if (roots.length > 0) {
+        rootsListUris = roots.map((root) => root?.uri).filter((uri) => Boolean(uri));
+        if (rootsListUris.length > 0 && isInitializeDebugEnabled()) {
+          console.error("[memoraone-mcp][init-debug] Workspace resolution strategy: roots/list");
+        }
       }
     } catch (e) {
-      console.error("[memoraone-mcp] roots/list failed:", String(e));
+      if (isInitializeDebugEnabled()) {
+        console.error("[memoraone-mcp][init-debug] roots/list failed:", String(e));
+      }
     }
-    console.error(`[memoraone-mcp] process.cwd(): ${process.cwd()}`);
-    console.error(
-      `[memoraone-mcp] WORKSPACE_FOLDER_PATHS: ${process.env.WORKSPACE_FOLDER_PATHS ?? "(unset)"}`
-    );
-    if (!fallbackWorkspaceRoot) {
+    if (isInitializeDebugEnabled()) {
+      console.error(`[memoraone-mcp][init-debug] process.cwd(): ${process.cwd()}`);
+      console.error(
+        `[memoraone-mcp][init-debug] WORKSPACE_FOLDER_PATHS: ${process.env.WORKSPACE_FOLDER_PATHS ?? "(unset)"}`
+      );
       if (params.workspaceFolders?.length) {
-        fallbackWorkspaceRoot = uriToPath(params.workspaceFolders[0].uri);
-        console.error("[memoraone-mcp] Workspace resolution strategy: initialize.workspaceFolders");
+        console.error("[memoraone-mcp][init-debug] Workspace resolution strategy: initialize.workspaceFolders");
       } else if (params.rootUri) {
-        fallbackWorkspaceRoot = uriToPath(params.rootUri);
-        console.error("[memoraone-mcp] Workspace resolution strategy: initialize.rootUri");
-      } else {
-        const cursorRoot = getCursorWorkspaceRootFromEnv();
-        if (cursorRoot !== void 0) {
-          fallbackWorkspaceRoot = cursorRoot;
-          console.error("[memoraone-mcp] Workspace resolution strategy: env.WORKSPACE_FOLDER_PATHS");
-        } else {
-          fallbackWorkspaceRoot = process.cwd();
-          console.error("[memoraone-mcp] Workspace resolution strategy: process.cwd() fallback");
-        }
+        console.error("[memoraone-mcp][init-debug] Workspace resolution strategy: initialize.rootUri");
       }
     }
-    const binding = await resolveAuthoritativeBinding(fallbackWorkspaceRoot);
+    const binding = await resolveBindingFromInitializeParams(params, {
+      fallbackWorkspaceRoots: getEnvWorkspaceRootCandidates(),
+      rootsListUris,
+      rootsListAttempted,
+      ...getBridgeBindingResolveOptions()
+    });
     workspaceRoot = binding.workspaceRoot;
     return binding;
   };
@@ -2037,7 +2309,7 @@ async function main(opts = {}) {
         if (runtime.ideType && opts.onSessionIdeTypeKnown) {
           opts.onSessionIdeTypeKnown(runtime.ideType);
         }
-        if (!initializeDiagDumped) {
+        if (isInitializeDebugEnabled() && !initializeDiagDumped) {
           initializeDiagDumped = true;
           const folders = Array.isArray(params.workspaceFolders) ? params.workspaceFolders.map((f) => ({ name: f?.name, uri: f?.uri })) : params.workspaceFolders;
           const capKeys = params.capabilities && typeof params.capabilities === "object" ? Object.keys(params.capabilities) : [];
@@ -2069,7 +2341,13 @@ async function main(opts = {}) {
           String(process.env.MEMORAONE_DEBUG_AUTH ?? "").trim().toLowerCase()
         );
         const debugLog3 = config2.devMode || debugAuth;
-        const binding = opts.authoritativeBinding ? opts.authoritativeBinding : await resolveFallbackBindingFromInitialize(params);
+        const binding = await resolveSessionBindingFromInitialize(params);
+        if (opts.daemonBindingHint && !bindingsMatch(opts.daemonBindingHint, binding)) {
+          const errMsg = formatBindingMismatchError(opts.daemonBindingHint, binding);
+          console.error(`[memoraone-mcp][ERROR] ${errMsg}`);
+          bindingReadyReject?.(new Error(errMsg));
+          throw new Error(errMsg);
+        }
         const apiKeyToUse = binding.apiKey;
         if (!apiKeyToUse) {
           throw new Error(
@@ -2193,10 +2471,10 @@ async function main(opts = {}) {
     console.error("[memoraone-mcp] MCP server ready");
   }
   if (opts.sessionSocket) {
-    await new Promise((resolve6) => {
+    await new Promise((resolve7) => {
       opts.sessionSocket.once("close", () => {
         shutdown("session closed", false);
-        resolve6();
+        resolve7();
       });
     });
   }
@@ -2231,11 +2509,11 @@ function parseBindingFromEnv(projectId) {
 }
 async function ensureSocketClean(socketPath) {
   try {
-    fs6.accessSync(socketPath);
+    fs7.accessSync(socketPath);
   } catch {
     return;
   }
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const client = net.createConnection({ path: socketPath }, () => {
       client.destroy();
       log("daemon already running, exiting");
@@ -2243,11 +2521,11 @@ async function ensureSocketClean(socketPath) {
     });
     client.on("error", () => {
       try {
-        fs6.unlinkSync(socketPath);
+        fs7.unlinkSync(socketPath);
         log("stale socket removed");
       } catch {
       }
-      resolve6();
+      resolve7();
     });
   });
 }
@@ -2255,7 +2533,7 @@ async function runDaemon() {
   const projectId = parseProjectIdFromArgv();
   const binding = parseBindingFromEnv(projectId);
   const ideType = parseIdeTypeFromArgv(process.argv.slice(2)) ?? config2.ideType ?? resolveIdeTypeFromEnv();
-  const socketPath = getSocketPath(projectId, ideType);
+  const socketPath = getBindingSocketPath(binding, process.env);
   let nextSessionId = 1;
   let activeSessions = 0;
   let idleTimer = null;
@@ -2263,7 +2541,7 @@ async function runDaemon() {
   const dir = ensureBaseDir();
   log(`directory ensured: ${dir}`);
   log(
-    `authoritative binding project=${binding.projectId} workspace=${binding.workspaceRoot} m1=${binding.m1Path} source=${binding.bindingSource} apiKeySource=${binding.apiKeySource}`
+    `daemon spawn hint project=${binding.projectId} workspace=${binding.workspaceRoot} m1=${binding.m1Path} source=${binding.bindingSource} apiKeySource=${binding.apiKeySource}`
   );
   log("session policy: concurrent bridge sessions allowed per project daemon");
   if (!isDaemonIdleShutdownAllowed()) {
@@ -2277,10 +2555,11 @@ async function runDaemon() {
   await ensureSocketClean(socketPath);
   const cleanupSocketFile = () => {
     try {
-      if (fs6.existsSync(socketPath)) {
-        fs6.unlinkSync(socketPath);
+      if (fs7.existsSync(socketPath)) {
+        fs7.unlinkSync(socketPath);
         log("socket removed");
       }
+      removeBindingSidecar(socketPath);
     } catch (err) {
       log(`socket cleanup warning: ${String(err)}`);
     }
@@ -2323,7 +2602,7 @@ async function runDaemon() {
     const transport = new import_stdio2.StdioServerTransport(socket, socket);
     try {
       await main({
-        authoritativeBinding: binding,
+        daemonBindingHint: binding,
         transport,
         sessionSocket: socket,
         sessionLabel: `daemon-session-${sessionId}`,
@@ -2362,13 +2641,14 @@ async function runDaemon() {
   process.on("SIGINT", () => shutdownNow("SIGINT"));
   process.on("SIGTERM", () => shutdownNow("SIGTERM"));
   process.on("exit", cleanupSocketFile);
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     server.listen(socketPath, () => {
+      writeBindingSidecar(socketPath, binding, ideType ?? "");
       log(`daemon started, listening on ${socketPath}`);
       void daemonHeartbeat.start().catch((err) => {
         log(`daemon heartbeat start error: ${String(err)}`);
       });
-      resolve6();
+      resolve7();
     });
   });
 }