@memoraone/mcp 0.1.29 → 0.1.31

package/dist/index.cjs

@@ -33,8 +33,6 @@ __export(index_exports, {
   main: () => main
 });
 module.exports = __toCommonJS(index_exports);
-var path6 = __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");
@@ -202,12 +200,12 @@ var MemoraClient = class {
       ...options?.headers ?? {}
     };
   }
-  async post(path7, body, options) {
+  async post(path9, body, options) {
     console.error(
-      `[memoraone-mcp][info] MemoraClient.post ENTER path=${path7}`
+      `[memoraone-mcp][info] MemoraClient.post ENTER path=${path9}`
     );
     const nonce = crypto.randomBytes(8).toString("hex");
-    const url = `${this.baseUrl}${path7.startsWith("/") ? path7 : `/${path7}`}`;
+    const url = `${this.baseUrl}${path9.startsWith("/") ? path9 : `/${path9}`}`;
     this.resolveProjectId();
     console.error(
       `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=POST url=${url}`
@@ -240,13 +238,13 @@ var MemoraClient = class {
       throw new MemoraOneHttpError(res.status, res.statusText, res.text);
     }
     console.error(
-      `[memoraone-mcp][info] MemoraClient.post EXIT path=${path7}`
+      `[memoraone-mcp][info] MemoraClient.post EXIT path=${path9}`
     );
     return res.text ? JSON.parse(res.text) : null;
   }
-  async get(path7, options) {
+  async get(path9, options) {
     const nonce = crypto.randomBytes(8).toString("hex");
-    const url = `${this.baseUrl}${path7.startsWith("/") ? path7 : `/${path7}`}`;
+    const url = `${this.baseUrl}${path9.startsWith("/") ? path9 : `/${path9}`}`;
     this.resolveProjectId();
     console.error(
       `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=GET url=${url}`
@@ -276,9 +274,45 @@ var MemoraClient = class {
 };
 var memoraClient_default = MemoraClient;
 
+// src/initializeBinding.ts
+var path5 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+
+// src/bindingIdentity.ts
+var crypto2 = __toESM(require("crypto"), 1);
+var path2 = __toESM(require("path"), 1);
+var BINDING_SOCKET_HASH_LENGTH = 16;
+function bindingsMatch(a, b) {
+  return a.projectId.trim().toLowerCase() === b.projectId.trim().toLowerCase() && path2.resolve(a.workspaceRoot) === path2.resolve(b.workspaceRoot) && path2.resolve(a.m1Path) === path2.resolve(b.m1Path);
+}
+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/projectBinding.ts
 var fs2 = __toESM(require("fs/promises"), 1);
-var path2 = __toESM(require("path"), 1);
+var path3 = __toESM(require("path"), 1);
 var uuidRegex2 = /^[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") {
@@ -311,7 +345,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);
@@ -324,20 +358,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;
     }
@@ -360,7 +394,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);
@@ -382,29 +416,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,
@@ -412,21 +450,232 @@ 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];
+}
+
+// src/socketPaths.ts
+var os = __toESM(require("os"), 1);
+var path4 = __toESM(require("path"), 1);
+var fs3 = __toESM(require("fs"), 1);
+var BASE_DIR = process.env.MEMORAONE_MCP_LOCK_DIR || path4.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) {
+  if (value === void 0 || value.trim() === "" || !IDE_TYPE_SET.has(value)) {
+    return void 0;
+  }
+  return value;
+}
+function resolveIdeTypeFromEnv(env2 = process.env) {
+  return parseIdeType(env2.MEMORAONE_IDE_TYPE);
+}
+
+// src/initializeBinding.ts
+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(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(env2 = process.env) {
+  const raw = env2[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.`;
+}
+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 = 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/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 path3 = __toESM(require("path"), 1);
-var import_node_url = require("url");
+var path6 = __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: path3.basename(normalizedRepoPath),
-    uri: (0, import_node_url.pathToFileURL)(normalizedRepoPath).href
+    label: path6.basename(normalizedRepoPath),
+    uri: (0, import_node_url2.pathToFileURL)(normalizedRepoPath).href
   };
   if (ideType) {
     body.metadata = {
@@ -444,7 +693,7 @@ async function registerRepoSource(client, projectId, repoPath, ideType) {
       );
       return;
     }
-    const normalizedRepoPath = path3.resolve(String(repoPath));
+    const normalizedRepoPath = path6.resolve(String(repoPath));
     const body = buildRepoSourcePayload(normalizedRepoPath, ideType);
     const primaryPath = `/v1/projects/${projectId}/sources`;
     const alternatePath = `/v1/projects/${projectId}/sources/register`;
@@ -604,11 +853,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 {
@@ -661,7 +910,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
@@ -701,7 +950,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`
   );
@@ -856,9 +1105,9 @@ function buildPersonalContextPath(parsed2) {
 }
 async function handleGetPersonalContext(client, args) {
   const parsed2 = getPersonalContextInputSchema.parse(args ?? {});
-  const path7 = buildPersonalContextPath(parsed2);
+  const path9 = buildPersonalContextPath(parsed2);
   try {
-    const result = await client.get(path7);
+    const result = await client.get(path9);
     return { ok: true, result };
   } catch (err) {
     if (err instanceof MemoraOneHttpError) {
@@ -1099,9 +1348,9 @@ async function handleListProjects(client) {
 var import_v421 = require("zod/v4");
 
 // src/repoFingerprint.ts
-var fs3 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
-var crypto4 = __toESM(require("crypto"), 1);
+var fs4 = __toESM(require("fs"), 1);
+var path7 = __toESM(require("path"), 1);
+var crypto5 = __toESM(require("crypto"), 1);
 var parseBooleanFlag3 = (value) => {
   if (!value) {
     return false;
@@ -1126,20 +1375,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 = fs3.statSync(gitPath);
+    const stat2 = fs4.statSync(gitPath);
     if (stat2.isDirectory()) {
       return gitPath;
     }
     if (stat2.isFile()) {
-      const content = fs3.readFileSync(gitPath, "utf8");
+      const content = fs4.readFileSync(gitPath, "utf8");
       const match = content.match(/^gitdir:\s*(.+)$/m);
       if (match) {
         const gitDir = match[1].trim();
-        return path4.resolve(path4.dirname(gitPath), gitDir);
+        return path7.resolve(path7.dirname(gitPath), gitDir);
       }
     }
   } catch {
@@ -1148,16 +1397,16 @@ var resolveGitDir = (gitPath) => {
   return null;
 };
 var findGitRoot = (start) => {
-  let current = path4.resolve(start);
+  let current = path7.resolve(start);
   while (true) {
-    const gitPath = path4.join(current, ".git");
-    if (fs3.existsSync(gitPath)) {
+    const gitPath = path7.join(current, ".git");
+    if (fs4.existsSync(gitPath)) {
       const gitDir = resolveGitDir(gitPath);
       if (gitDir) {
         return { gitRoot: current, gitDir };
       }
     }
-    const parent = path4.dirname(current);
+    const parent = path7.dirname(current);
     if (parent === current) {
       break;
     }
@@ -1166,9 +1415,9 @@ var findGitRoot = (start) => {
   return null;
 };
 var readOriginRemote = (gitDir) => {
-  const configPath = path4.join(gitDir, "config");
+  const configPath = path7.join(gitDir, "config");
   try {
-    const content = fs3.readFileSync(configPath, "utf8");
+    const content = fs4.readFileSync(configPath, "utf8");
     const lines = content.split(/\r?\n/);
     let inOrigin = false;
     for (const line of lines) {
@@ -1192,7 +1441,7 @@ var readOriginRemote = (gitDir) => {
 function resolveRepoFingerprint(cwd2) {
   const found = findGitRoot(cwd2);
   if (!found) {
-    const fallbackPath = path4.resolve(cwd2);
+    const fallbackPath = path7.resolve(cwd2);
     const fingerprint2 = sha256(fallbackPath);
     debugLog(`repo fingerprint=${fingerprint2} source=path-fallback`);
     return {
@@ -1214,7 +1463,7 @@ function resolveRepoFingerprint(cwd2) {
       source: "git-remote"
     };
   }
-  const fingerprint = sha256(path4.resolve(gitRoot));
+  const fingerprint = sha256(path7.resolve(gitRoot));
   debugLog(`repo fingerprint=${fingerprint} source=path-fallback`);
   return {
     fingerprint,
@@ -1224,8 +1473,8 @@ function resolveRepoFingerprint(cwd2) {
 }
 
 // src/workspaceMap.ts
-var fs4 = __toESM(require("fs/promises"), 1);
-var path5 = __toESM(require("path"), 1);
+var fs5 = __toESM(require("fs/promises"), 1);
+var path8 = __toESM(require("path"), 1);
 var import_node_os = __toESM(require("os"), 1);
 var parseBooleanFlag4 = (value) => {
   if (!value) {
@@ -1244,11 +1493,11 @@ var debugLog2 = (message) => {
 };
 var fingerprintRegex = /^[0-9a-f]{64}$/i;
 function getWorkspaceMapPath() {
-  return path5.join(import_node_os.default.homedir(), ".memoraone", "workspaces.json");
+  return path8.join(import_node_os.default.homedir(), ".memoraone", "workspaces.json");
 }
 var ensureWorkspaceDir = async () => {
-  const dir = path5.dirname(getWorkspaceMapPath());
-  await fs4.mkdir(dir, { recursive: true });
+  const dir = path8.dirname(getWorkspaceMapPath());
+  await fs5.mkdir(dir, { recursive: true });
 };
 async function acquireWorkspaceMapLock() {
   const filePath = getWorkspaceMapPath();
@@ -1262,10 +1511,10 @@ async function acquireWorkspaceMapLock() {
   while (!lockAcquired && retries < maxRetries) {
     try {
       try {
-        const stat2 = await fs4.stat(lockPath);
+        const stat2 = await fs5.stat(lockPath);
         const ageMs = Date.now() - stat2.mtimeMs;
         if (ageMs > maxLockAgeMs) {
-          await fs4.unlink(lockPath);
+          await fs5.unlink(lockPath);
           debugLog2(`removed stale workspace map lock (age: ${ageMs}ms)`);
         }
       } catch (err) {
@@ -1273,14 +1522,14 @@ async function acquireWorkspaceMapLock() {
           throw err;
         }
       }
-      const fd = await fs4.open(lockPath, "wx");
+      const fd = await fs5.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(
@@ -1292,7 +1541,7 @@ async function acquireWorkspaceMapLock() {
   }
   return async () => {
     try {
-      await fs4.unlink(lockPath);
+      await fs5.unlink(lockPath);
     } catch (err) {
       if (err?.code !== "ENOENT") {
         debugLog2(`failed to release workspace map lock: ${String(err)}`);
@@ -1348,7 +1597,7 @@ var validateWorkspaceMap = (map, filePath) => {
 async function readWorkspaceMap() {
   const filePath = getWorkspaceMapPath();
   try {
-    const content = await fs4.readFile(filePath, "utf8");
+    const content = await fs5.readFile(filePath, "utf8");
     const parsed2 = JSON.parse(content);
     validateWorkspaceMap(parsed2, filePath);
     const typed = parsed2;
@@ -1393,8 +1642,8 @@ async function writeWorkspaceMap(map) {
   await ensureWorkspaceDir();
   const tempPath = `${filePath}.tmp`;
   const content = JSON.stringify(map, null, 2);
-  await fs4.writeFile(tempPath, content, "utf8");
-  await fs4.rename(tempPath, filePath);
+  await fs5.writeFile(tempPath, content, "utf8");
+  await fs5.rename(tempPath, filePath);
 }
 async function setProjectIdForFingerprint(args) {
   const { fingerprint, projectKey, source, linked_at } = args;
@@ -1474,9 +1723,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();
@@ -1561,21 +1810,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(path6.delimiter).map((p) => p.trim()).filter(Boolean);
-  const first = parts[0];
-  return first ? path6.resolve(first) : void 0;
-}
 function redactSensitiveFields(obj) {
   if (obj === null || obj === void 0) return obj;
   if (typeof obj !== "object") return obj;
@@ -1654,8 +1888,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);
@@ -1666,7 +1900,7 @@ async function main(opts = {}) {
     projectId: null,
     apiKeySource: null,
     apiKeyFingerprint: null,
-    authoritativeBinding: opts.authoritativeBinding ?? null,
+    authoritativeBinding: null,
     ideType: void 0
   };
   let workspaceRoot;
@@ -1674,42 +1908,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;
   };
@@ -1889,7 +2134,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) : [];
@@ -1921,7 +2166,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(
@@ -2045,10 +2296,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();
       });
     });
   }