@memoraone/mcp 0.1.33 → 0.1.35

package/dist/index.cjs

@@ -200,12 +200,12 @@ var MemoraClient = class {
       ...options?.headers ?? {}
     };
   }
-  async post(path9, body, options) {
+  async post(path11, body, options) {
     console.error(
-      `[memoraone-mcp][info] MemoraClient.post ENTER path=${path9}`
+      `[memoraone-mcp][info] MemoraClient.post ENTER path=${path11}`
     );
     const nonce = crypto.randomBytes(8).toString("hex");
-    const url = `${this.baseUrl}${path9.startsWith("/") ? path9 : `/${path9}`}`;
+    const url = `${this.baseUrl}${path11.startsWith("/") ? path11 : `/${path11}`}`;
     this.resolveProjectId();
     console.error(
       `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=POST url=${url}`
@@ -238,13 +238,13 @@ var MemoraClient = class {
       throw new MemoraOneHttpError(res.status, res.statusText, res.text);
     }
     console.error(
-      `[memoraone-mcp][info] MemoraClient.post EXIT path=${path9}`
+      `[memoraone-mcp][info] MemoraClient.post EXIT path=${path11}`
     );
     return res.text ? JSON.parse(res.text) : null;
   }
-  async get(path9, options) {
+  async get(path11, options) {
     const nonce = crypto.randomBytes(8).toString("hex");
-    const url = `${this.baseUrl}${path9.startsWith("/") ? path9 : `/${path9}`}`;
+    const url = `${this.baseUrl}${path11.startsWith("/") ? path11 : `/${path11}`}`;
     this.resolveProjectId();
     console.error(
       `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=GET url=${url}`
@@ -274,46 +274,14 @@ 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 path3 = __toESM(require("path"), 1);
+var path2 = __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;
+var CANONICAL_M1_FILENAME = "memoraone.m1";
+function isCanonicalM1Path(m1Path) {
+  return path2.basename(m1Path) === CANONICAL_M1_FILENAME;
+}
 function normalizeEnvironment(raw) {
   if (raw === void 0 || raw === null || typeof raw !== "string") {
     return void 0;
@@ -345,7 +313,7 @@ async function resolveProjectIdFromExplicitM1Path() {
   if (raw === void 0 || raw.trim() === "") {
     return null;
   }
-  const markerPath = path3.resolve(raw);
+  const markerPath = path2.resolve(raw);
   try {
     const content = await fs2.readFile(markerPath, "utf8");
     const { projectId, apiKey, environment } = parseAndValidateM1(content, markerPath);
@@ -358,20 +326,20 @@ async function resolveProjectIdFromExplicitM1Path() {
   }
 }
 async function findM1WalkingUp(workspaceRoot) {
-  let current = path3.resolve(workspaceRoot);
+  let current = path2.resolve(workspaceRoot);
   while (true) {
-    const markerPath = path3.join(current, "memoraone.m1");
+    const markerPath = path2.join(current, CANONICAL_M1_FILENAME);
     try {
       const content = await fs2.readFile(markerPath, "utf8");
       const { projectId, apiKey, environment } = parseAndValidateM1(content, markerPath);
-      const repoRoot = path3.dirname(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 = path3.dirname(current);
+    const parent = path2.dirname(current);
     if (parent === current) {
       break;
     }
@@ -394,7 +362,7 @@ function normalizeWorkspaceSearchRoots(workspaceRoot) {
     if (trimmed === "") {
       continue;
     }
-    const resolved = path3.resolve(trimmed);
+    const resolved = path2.resolve(trimmed);
     if (!seen.has(resolved)) {
       seen.add(resolved);
       out.push(resolved);
@@ -424,7 +392,7 @@ async function resolveAuthoritativeBinding(workspaceRoot, options = {}) {
       const resolved = resolveApiKeyWithSource(explicitBinding.apiKey);
       return {
         projectId: explicitBinding.projectId,
-        workspaceRoot: path3.dirname(explicitBinding.foundAt),
+        workspaceRoot: path2.dirname(explicitBinding.foundAt),
         m1Path: explicitBinding.foundAt,
         apiKey: resolved.apiKey,
         ...explicitBinding.environment !== void 0 ? { environment: explicitBinding.environment } : {},
@@ -467,6 +435,94 @@ async function resolveAuthoritativeBinding(workspaceRoot, options = {}) {
   }
   return bindings[0];
 }
+function bindingRelevantValuesMatch(a, b) {
+  const envA = a.environment ?? void 0;
+  const envB = b.environment ?? void 0;
+  return a.projectId.trim().toLowerCase() === b.projectId.trim().toLowerCase() && path2.resolve(a.workspaceRoot) === path2.resolve(b.workspaceRoot) && path2.resolve(a.m1Path) === path2.resolve(b.m1Path) && (a.apiKey ?? null) === (b.apiKey ?? null) && envA === envB;
+}
+async function reconcileResolvedBindingWithDisk(cached) {
+  const m1Path = path2.resolve(cached.m1Path);
+  if (cached.bindingSource !== "explicit-m1-path" && !isCanonicalM1Path(m1Path)) {
+    throw new Error(
+      `[memoraone-mcp] Cached binding m1Path is not the canonical ${CANONICAL_M1_FILENAME}: ${m1Path}`
+    );
+  }
+  let content;
+  try {
+    content = await fs2.readFile(m1Path, "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      throw new Error(
+        `[memoraone-mcp] Cached binding file missing at ${m1Path}. Open a folder containing ${CANONICAL_M1_FILENAME}.`
+      );
+    }
+    throw err;
+  }
+  const parsed2 = parseAndValidateM1(content, m1Path);
+  const resolved = resolveApiKeyWithSource(parsed2.apiKey);
+  const fresh = {
+    projectId: parsed2.projectId,
+    workspaceRoot: path2.resolve(path2.dirname(m1Path)),
+    m1Path,
+    apiKey: resolved.apiKey,
+    ...parsed2.environment !== void 0 ? { environment: parsed2.environment } : {},
+    bindingSource: cached.bindingSource,
+    apiKeySource: resolved.apiKeySource
+  };
+  if (bindingRelevantValuesMatch(cached, fresh)) {
+    return { binding: fresh, cacheRefreshed: false };
+  }
+  return { binding: fresh, cacheRefreshed: true };
+}
+function encodeResolvedBinding(binding) {
+  return Buffer.from(JSON.stringify(binding), "utf8").toString("base64");
+}
+
+// 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 path3 = __toESM(require("path"), 1);
+var BINDING_SOCKET_HASH_LENGTH = 16;
+function hashBindingIdentity(projectId, workspaceRoot, ideType) {
+  const input = [
+    projectId.trim().toLowerCase(),
+    path3.resolve(workspaceRoot),
+    ideType
+  ].join("|");
+  return crypto2.createHash("sha256").update(input).digest("hex").slice(0, BINDING_SOCKET_HASH_LENGTH);
+}
+function bindingsMatch(a, b) {
+  const envA = a.environment ?? void 0;
+  const envB = b.environment ?? void 0;
+  return a.projectId.trim().toLowerCase() === b.projectId.trim().toLowerCase() && path3.resolve(a.workspaceRoot) === path3.resolve(b.workspaceRoot) && path3.resolve(a.m1Path) === path3.resolve(b.m1Path) && (a.apiKey ?? null) === (b.apiKey ?? null) && envA === envB;
+}
+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 os = __toESM(require("os"), 1);
@@ -488,6 +544,17 @@ function parseIdeType(value) {
 function resolveIdeTypeFromEnv(env2 = process.env) {
   return parseIdeType(env2.MEMORAONE_IDE_TYPE);
 }
+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 path4.join(BASE_DIR, getBindingSocketFilename(binding, env2));
+}
 
 // src/initializeBinding.ts
 var MEMORAONE_WORKSPACE_ROOT_ENV = "MEMORAONE_WORKSPACE_ROOT";
@@ -660,6 +727,31 @@ async function resolveBindingFromInitializeParams(params, options = {}) {
   });
 }
 
+// src/bindingSidecar.ts
+var fs4 = __toESM(require("fs"), 1);
+var path6 = __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
+  };
+  fs4.writeFileSync(bindingSidecarPath(socketPath), JSON.stringify(record), "utf8");
+}
+
+// src/index.ts
+var path10 = __toESM(require("path"), 1);
+
 // src/bridgeClientRoots.ts
 var readline = __toESM(require("readline"), 1);
 var TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
@@ -668,13 +760,13 @@ function isInitializeDebugEnabled(env2 = process.env) {
 }
 
 // src/sourceRegistration.ts
-var path6 = __toESM(require("path"), 1);
+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: path6.basename(normalizedRepoPath),
+    label: path7.basename(normalizedRepoPath),
     uri: (0, import_node_url2.pathToFileURL)(normalizedRepoPath).href
   };
   if (ideType) {
@@ -693,7 +785,7 @@ async function registerRepoSource(client, projectId, repoPath, ideType) {
       );
       return;
     }
-    const normalizedRepoPath = path6.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`;
@@ -1105,9 +1197,9 @@ function buildPersonalContextPath(parsed2) {
 }
 async function handleGetPersonalContext(client, args) {
   const parsed2 = getPersonalContextInputSchema.parse(args ?? {});
-  const path9 = buildPersonalContextPath(parsed2);
+  const path11 = buildPersonalContextPath(parsed2);
   try {
-    const result = await client.get(path9);
+    const result = await client.get(path11);
     return { ok: true, result };
   } catch (err) {
     if (err instanceof MemoraOneHttpError) {
@@ -1348,8 +1440,8 @@ async function handleListProjects(client) {
 var import_v421 = require("zod/v4");
 
 // src/repoFingerprint.ts
-var fs4 = __toESM(require("fs"), 1);
-var path7 = __toESM(require("path"), 1);
+var fs5 = __toESM(require("fs"), 1);
+var path8 = __toESM(require("path"), 1);
 var crypto5 = __toESM(require("crypto"), 1);
 var parseBooleanFlag3 = (value) => {
   if (!value) {
@@ -1379,16 +1471,16 @@ var sha256 = (value) => {
 };
 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 path7.resolve(path7.dirname(gitPath), gitDir);
+        return path8.resolve(path8.dirname(gitPath), gitDir);
       }
     }
   } catch {
@@ -1397,16 +1489,16 @@ var resolveGitDir = (gitPath) => {
   return null;
 };
 var findGitRoot = (start) => {
-  let current = path7.resolve(start);
+  let current = path8.resolve(start);
   while (true) {
-    const gitPath = path7.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 = path7.dirname(current);
+    const parent = path8.dirname(current);
     if (parent === current) {
       break;
     }
@@ -1415,9 +1507,9 @@ var findGitRoot = (start) => {
   return null;
 };
 var readOriginRemote = (gitDir) => {
-  const configPath = path7.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) {
@@ -1441,7 +1533,7 @@ var readOriginRemote = (gitDir) => {
 function resolveRepoFingerprint(cwd2) {
   const found = findGitRoot(cwd2);
   if (!found) {
-    const fallbackPath = path7.resolve(cwd2);
+    const fallbackPath = path8.resolve(cwd2);
     const fingerprint2 = sha256(fallbackPath);
     debugLog(`repo fingerprint=${fingerprint2} source=path-fallback`);
     return {
@@ -1463,7 +1555,7 @@ function resolveRepoFingerprint(cwd2) {
       source: "git-remote"
     };
   }
-  const fingerprint = sha256(path7.resolve(gitRoot));
+  const fingerprint = sha256(path8.resolve(gitRoot));
   debugLog(`repo fingerprint=${fingerprint} source=path-fallback`);
   return {
     fingerprint,
@@ -1473,8 +1565,8 @@ function resolveRepoFingerprint(cwd2) {
 }
 
 // src/workspaceMap.ts
-var fs5 = __toESM(require("fs/promises"), 1);
-var path8 = __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) {
@@ -1493,11 +1585,11 @@ var debugLog2 = (message) => {
 };
 var fingerprintRegex = /^[0-9a-f]{64}$/i;
 function getWorkspaceMapPath() {
-  return path8.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 = path8.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();
@@ -1511,10 +1603,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) {
@@ -1522,14 +1614,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((resolve7) => setTimeout(resolve7, retryDelayMs));
+          await new Promise((resolve8) => setTimeout(resolve8, retryDelayMs));
           continue;
         }
         throw new Error(
@@ -1541,7 +1633,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)}`);
@@ -1597,7 +1689,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;
@@ -1642,8 +1734,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;
@@ -1702,24 +1794,25 @@ async function handleSetProject(args) {
 }
 
 // src/tools/handlers/bindingStatus.ts
-function buildBindingStatus(binding) {
+function buildBindingStatus(binding, options = {}) {
   const status = {
     projectId: binding.projectId,
     workspaceRoot: binding.workspaceRoot,
     m1Path: binding.m1Path,
     bindingSource: binding.bindingSource,
-    apiKeySource: binding.apiKeySource
+    apiKeySource: binding.apiKeySource,
+    cacheRefreshed: options.cacheRefreshed === true
   };
   if (binding.environment !== void 0) {
     status.environment = binding.environment;
   }
   return status;
 }
-function handleBindingStatus(binding) {
+function handleBindingStatus(binding, options = {}) {
   if (!binding) {
     throw new Error("[memoraone-mcp] Binding status unavailable (not initialized)");
   }
-  return buildBindingStatus(binding);
+  return buildBindingStatus(binding, options);
 }
 
 // src/heartbeat.ts
@@ -1888,8 +1981,8 @@ function registerToolWithWorklog(server, runtime, sessionContext, toolName, desc
 async function main(opts = {}) {
   let bindingReadyResolve = null;
   let bindingReadyReject = null;
-  const bindingReady = new Promise((resolve7, reject) => {
-    bindingReadyResolve = resolve7;
+  const bindingReady = new Promise((resolve8, reject) => {
+    bindingReadyResolve = resolve8;
     bindingReadyReject = reject;
   });
   const devMode = Boolean(config2.devMode);
@@ -1901,6 +1994,7 @@ async function main(opts = {}) {
     apiKeySource: null,
     apiKeyFingerprint: null,
     authoritativeBinding: null,
+    bindingCacheRefreshed: false,
     ideType: void 0
   };
   let workspaceRoot;
@@ -1913,10 +2007,25 @@ async function main(opts = {}) {
     if (initializeRoots.length === 0 && opts.daemonBindingHint) {
       if (isInitializeDebugEnabled()) {
         console.error(
-          "[memoraone-mcp][init-debug] Workspace resolution strategy: daemonBindingHint (bridge pre-resolved)"
+          "[memoraone-mcp][init-debug] Workspace resolution strategy: daemonBindingHint (bridge pre-resolved, reconciled from disk)"
         );
       }
-      return opts.daemonBindingHint;
+      const reconciled = await reconcileResolvedBindingWithDisk(opts.daemonBindingHint);
+      runtime.bindingCacheRefreshed = reconciled.cacheRefreshed;
+      if (reconciled.cacheRefreshed) {
+        console.error(
+          `[memoraone-mcp] refreshed stale cached binding from ${reconciled.binding.m1Path}: project=${reconciled.binding.projectId}`
+        );
+        try {
+          const socketPath = getBindingSocketPath(opts.daemonBindingHint);
+          writeBindingSidecar(socketPath, reconciled.binding, runtime.ideType ?? "");
+        } catch (err) {
+          console.error(
+            `[memoraone-mcp] warning: could not rewrite binding sidecar after refresh: ${String(err)}`
+          );
+        }
+      }
+      return reconciled.binding;
     }
     let rootsListUris;
     let rootsListAttempted = false;
@@ -2043,7 +2152,9 @@ async function main(opts = {}) {
     bindingStatusShape,
     async () => runWithSessionContext(sessionContext, async () => {
       if (!runtime.authoritativeBinding) return notInitializedResult;
-      const result = handleBindingStatus(runtime.authoritativeBinding);
+      const result = handleBindingStatus(runtime.authoritativeBinding, {
+        cacheRefreshed: runtime.bindingCacheRefreshed
+      });
       return {
         content: [{ type: "text", text: JSON.stringify(result) }]
       };
@@ -2167,7 +2278,7 @@ async function main(opts = {}) {
         );
         const debugLog3 = config2.devMode || debugAuth;
         const binding = await resolveSessionBindingFromInitialize(params);
-        if (opts.daemonBindingHint && !bindingsMatch(opts.daemonBindingHint, binding)) {
+        if (opts.daemonBindingHint && path10.resolve(opts.daemonBindingHint.m1Path) !== path10.resolve(binding.m1Path)) {
           const errMsg = formatBindingMismatchError(opts.daemonBindingHint, binding);
           console.error(`[memoraone-mcp][ERROR] ${errMsg}`);
           bindingReadyReject?.(new Error(errMsg));
@@ -2187,15 +2298,23 @@ async function main(opts = {}) {
         const projectId = binding.projectId;
         const existing = getBoundProjectId();
         if (existing !== null && existing !== projectId) {
-          const requestedRoot = binding.workspaceRoot ?? workspaceRoot ?? process.cwd();
-          const action = "Open this repo in a separate window or configure a separate MCP server instance per root.";
-          const errMsg = `[memoraone-mcp] This MCP process is already bound to project ${existing}. Open a new IDE window or start a separate MCP instance for a different project.`;
-          console.error(
-            `[memoraone-mcp][ERROR] Option A conflict: boundProjectId=${existing} requestedProjectId=${projectId} workspaceRoot=${requestedRoot}. ${action}`
-          );
-          bindingReadyReject?.(new Error(errMsg));
-          setImmediate(() => process.exit(1));
-          throw new Error(errMsg);
+          if (runtime.bindingCacheRefreshed) {
+            setBoundProjectId(projectId);
+            setBoundApiKey(apiKeyToUse);
+            console.error(
+              `[memoraone-mcp] ${sessionLabel} rebound to project ${projectId} after stale memoraone.m1 cache refresh (was ${existing})`
+            );
+          } else {
+            const requestedRoot = binding.workspaceRoot ?? workspaceRoot ?? process.cwd();
+            const action = "Open this repo in a separate window or configure a separate MCP server instance per root.";
+            const errMsg = `[memoraone-mcp] This MCP process is already bound to project ${existing}. Open a new IDE window or start a separate MCP instance for a different project.`;
+            console.error(
+              `[memoraone-mcp][ERROR] Option A conflict: boundProjectId=${existing} requestedProjectId=${projectId} workspaceRoot=${requestedRoot}. ${action}`
+            );
+            bindingReadyReject?.(new Error(errMsg));
+            setImmediate(() => process.exit(1));
+            throw new Error(errMsg);
+          }
         }
         if (existing === null) {
           setBoundProjectId(projectId);
@@ -2296,10 +2415,10 @@ async function main(opts = {}) {
     console.error("[memoraone-mcp] MCP server ready");
   }
   if (opts.sessionSocket) {
-    await new Promise((resolve7) => {
+    await new Promise((resolve8) => {
       opts.sessionSocket.once("close", () => {
         shutdown("session closed", false);
-        resolve7();
+        resolve8();
       });
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoraone/mcp",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "type": "module",
   "main": "dist/index.cjs",
   "bin": {
@@ -13,23 +13,22 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsup && node scripts/writeBinWrapper.cjs",
-    "prepublishOnly": "pnpm run build",
-    "dev": "tsx src/cli.ts",
-    "lint": "eslint .",
-    "lint:contracts": "node scripts/lint-contracts.cjs",
-    "test": "pnpm run lint:contracts && node --import=tsx --test test/*.test.js",
-    "validate:auth": "node --import=tsx --test test/memoraClient.test.js"
-  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
     "dotenv": "^16.4.5",
     "zod": "^4.0.0"
   },
   "devDependencies": {
-    "tsx": "^4.21.0",
     "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "build": "tsup && node scripts/writeBinWrapper.cjs",
+    "dev": "tsx src/cli.ts",
+    "lint": "eslint .",
+    "lint:contracts": "node scripts/lint-contracts.cjs",
+    "test": "pnpm run lint:contracts && node --import=tsx --test test/*.test.js",
+    "validate:auth": "node --import=tsx --test test/memoraClient.test.js"
   }
-}
+}