@memoraone/mcp 0.1.17 → 0.1.19

package/dist/index.cjs

@@ -5,6 +5,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -21,26 +25,40 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(index_exports);
+var path6 = __toESM(require("path"), 1);
+var crypto5 = __toESM(require("crypto"), 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 fs = __toESM(require("fs"), 1);
 var path = __toESM(require("path"), 1);
-var import_dotenv = __toESM(require("dotenv"), 1);
+var dotenv = __toESM(require("dotenv"), 1);
 var import_v4 = require("zod/v4");
 
 // src/configUtils.ts
-var DEFAULT_API_URL = "https://api.memoraone.com";
+var DEFAULT_API_URL = "http://localhost:3001";
 var DEV_API_URL = "http://localhost:3001";
 function resolveApiUrl(env2) {
   const explicitUrl = env2.MEMORAONE_API_URL?.trim();
   if (explicitUrl) {
     return explicitUrl;
   }
+  const aliasUrl = env2.MEMORA_API_URL?.trim();
+  if (aliasUrl) {
+    return aliasUrl;
+  }
   if (env2.MEMORAONE_DEV_MODE === "1") {
     return DEV_API_URL;
   }
@@ -51,23 +69,24 @@ function resolveApiUrl(env2) {
 var dotenvPath = path.resolve(process2.cwd(), ".env");
 if (fs.existsSync(dotenvPath)) {
   try {
-    import_dotenv.default.config({ path: dotenvPath });
+    dotenv.config({ path: dotenvPath });
   } catch (err) {
     process2.stderr.write("[memoraone-mcp] Failed to load .env: " + String(err) + "\n");
   }
 }
 var EnvSchema = import_v4.z.object({
   MEMORAONE_API_URL: import_v4.z.string().url().optional(),
-  MEMORAONE_API_KEY: import_v4.z.string().min(1),
+  MEMORAONE_API_KEY: import_v4.z.string().min(1).optional(),
   MEMORAONE_DEV_MODE: import_v4.z.string().min(1).optional(),
   MEMORAONE_AGENT_NAME: import_v4.z.string().min(1).optional(),
   MEMORAONE_AGENT_TYPE: import_v4.z.string().min(1).optional(),
   MEMORAONE_SOURCE: import_v4.z.string().min(1).optional(),
+  MEMORAONE_IDE_TYPE: import_v4.z.enum(["cursor", "copilot-vscode", "jetbrains"]).optional(),
   MEMORAONE_WORKLOG: import_v4.z.string().min(1).optional(),
   MEMORAONE_HEARTBEAT: import_v4.z.string().min(1).optional(),
   MEMORAONE_HEARTBEAT_INTERVAL_MS: import_v4.z.string().min(1).optional()
 });
-var requiredEnvVars = ["MEMORAONE_API_KEY"];
+var requiredEnvVars = [];
 var missingEnvVars = requiredEnvVars.filter((key) => {
   const value = process2.env[key];
   return value === void 0 || value.trim() === "";
@@ -101,12 +120,13 @@ var parseBooleanFlag = (value, defaultValue) => {
   }
   return defaultValue;
 };
-var config = {
+var config2 = {
   apiUrl: resolvedApiUrl.replace(/\/+$/, ""),
   apiKey: parsed.data.MEMORAONE_API_KEY,
   agentName: parsed.data.MEMORAONE_AGENT_NAME ?? "cursor",
   agentType: parsed.data.MEMORAONE_AGENT_TYPE ?? "agent",
   source: parsed.data.MEMORAONE_SOURCE ?? "cursor",
+  ideType: parsed.data.MEMORAONE_IDE_TYPE,
   devMode: parseBooleanFlag(parsed.data.MEMORAONE_DEV_MODE, false),
   worklogEnabled: parseBooleanFlag(parsed.data.MEMORAONE_WORKLOG, true),
   heartbeatEnabled: parseBooleanFlag(parsed.data.MEMORAONE_HEARTBEAT, true),
@@ -114,32 +134,9 @@ var config = {
 };
 
 // src/client/memoraClient.ts
-var crypto2 = __toESM(require("crypto"), 1);
-
-// src/runContext.ts
 var crypto = __toESM(require("crypto"), 1);
-var currentRunId = null;
-var currentProjectId = null;
-function setCurrentRunId(id) {
-  currentRunId = id;
-}
-function getCurrentProjectId() {
-  return currentProjectId;
-}
-function setCurrentProjectId(id) {
-  currentProjectId = id;
-}
-function resolveRunId(passed) {
-  if (passed) {
-    return passed;
-  }
-  return currentRunId;
-}
-function generateRunId() {
-  return crypto.randomBytes(16).toString("hex");
-}
-
-// src/client/memoraClient.ts
+var PROJECT_ID_HEADER = "x-project-id";
+var uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var parseBooleanFlag2 = (value) => {
   if (!value) {
     return false;
@@ -171,36 +168,48 @@ var MemoraOneHttpError = class extends Error {
   }
 };
 var MemoraClient = class {
-  constructor(cfg, projectKey) {
-    if (!projectKey?.trim()) {
-      throw new Error("[memoraone-mcp] Invalid projectKey for MemoraClient");
+  constructor(cfg, projectId, apiKey) {
+    if (!uuidRegex.test(projectId)) {
+      throw new Error("[memoraone-mcp] Invalid project_id for MemoraClient");
     }
     this.baseUrl = cfg.apiUrl;
-    this.apiKey = cfg.apiKey;
-    this.projectKey = projectKey;
-  }
-  resolveProjectKey() {
-    const selected = getCurrentProjectId();
-    const projectKey = (selected ?? this.projectKey)?.trim();
-    if (!projectKey) {
-      throw new Error("Missing projectKey: select a project first");
+    this.apiKey = apiKey;
+    this.projectId = projectId;
+  }
+  resolveProjectId() {
+    const projectId = this.projectId?.trim();
+    if (!projectId) {
+      throw new Error(`Missing ${PROJECT_ID_HEADER}: select a project first`);
+    }
+    if (!uuidRegex.test(projectId)) {
+      throw new Error("[memoraone-mcp] Invalid project_id for request");
+    }
+    return projectId;
+  }
+  resolveApiKey() {
+    const key = this.apiKey?.trim();
+    if (!key) {
+      throw new Error("[memoraone-mcp] Missing api_key for request");
     }
-    return projectKey;
+    return key;
   }
   buildHeaders(options) {
+    const projectId = this.resolveProjectId();
+    const apiKey = this.resolveApiKey();
     return {
       "content-type": "application/json",
-      "x-api-key": this.apiKey,
+      "x-api-key": apiKey,
+      [PROJECT_ID_HEADER]: projectId,
       ...options?.headers ?? {}
     };
   }
-  async post(path5, body, options) {
+  async post(path7, body, options) {
     console.error(
-      `[memoraone-mcp][info] MemoraClient.post ENTER path=${path5}`
+      `[memoraone-mcp][info] MemoraClient.post ENTER path=${path7}`
     );
-    const nonce = crypto2.randomBytes(8).toString("hex");
-    const url = `${this.baseUrl}${path5.startsWith("/") ? path5 : `/${path5}`}`;
-    this.resolveProjectKey();
+    const nonce = crypto.randomBytes(8).toString("hex");
+    const url = `${this.baseUrl}${path7.startsWith("/") ? path7 : `/${path7}`}`;
+    this.resolveProjectId();
     console.error(
       `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=POST url=${url}`
     );
@@ -217,22 +226,29 @@ var MemoraClient = class {
       );
     }
     if (!res.ok) {
-      const snippet = res.text.length > 200 ? `${res.text.slice(0, 200)}...` : res.text;
-      process.stderr.write(
-        `[memoraone-mcp][error] http error method=POST url=${url} status=${res.status} body=${snippet}
+      const accepted = options?.acceptStatuses?.includes(res.status);
+      if (accepted) {
+        return res.text ? JSON.parse(res.text) : null;
+      }
+      const quiet = options?.quietHttpStatuses?.includes(res.status);
+      if (!quiet) {
+        const snippet = res.text.length > 200 ? `${res.text.slice(0, 200)}...` : res.text;
+        process.stderr.write(
+          `[memoraone-mcp][error] http error method=POST url=${url} status=${res.status} body=${snippet}
 `
-      );
+        );
+      }
       throw new MemoraOneHttpError(res.status, res.statusText, res.text);
     }
     console.error(
-      `[memoraone-mcp][info] MemoraClient.post EXIT path=${path5}`
+      `[memoraone-mcp][info] MemoraClient.post EXIT path=${path7}`
     );
     return res.text ? JSON.parse(res.text) : null;
   }
-  async get(path5, options) {
-    const nonce = crypto2.randomBytes(8).toString("hex");
-    const url = `${this.baseUrl}${path5.startsWith("/") ? path5 : `/${path5}`}`;
-    this.resolveProjectKey();
+  async get(path7, options) {
+    const nonce = crypto.randomBytes(8).toString("hex");
+    const url = `${this.baseUrl}${path7.startsWith("/") ? path7 : `/${path7}`}`;
+    this.resolveProjectId();
     console.error(
       `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=GET url=${url}`
     );
@@ -261,63 +277,57 @@ var MemoraClient = class {
 };
 var memoraClient_default = MemoraClient;
 
-// src/repoFingerprint.ts
-var fs2 = __toESM(require("fs"), 1);
+// src/projectBinding.ts
+var fs2 = __toESM(require("fs/promises"), 1);
 var path2 = __toESM(require("path"), 1);
-var crypto3 = __toESM(require("crypto"), 1);
-var parseBooleanFlag3 = (value) => {
-  if (!value) {
-    return false;
+var uuidRegex2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function parseAndValidateM1(content, markerPath) {
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(content);
+  } catch {
+    throw new Error(`[memoraone-mcp] Invalid memoraone.m1 JSON at ${markerPath}`);
   }
-  const normalized = value.trim().toLowerCase();
-  return ["1", "true", "yes", "on"].includes(normalized);
-};
-var debugEnabled2 = parseBooleanFlag3(process.env.MEMORAONE_DEV_MODE);
-var debugLog = (message) => {
-  if (!debugEnabled2) {
-    return;
+  const projectId = parsed2?.projectId ?? parsed2?.project_id;
+  if (!projectId || typeof projectId !== "string") {
+    throw new Error(`[memoraone-mcp] memoraone.m1 missing projectId at ${markerPath}`);
   }
-  process.stderr.write(`[memoraone-mcp][debug] ${message}
-`);
-};
-var normalizeRemoteUrl = (remoteUrl) => {
-  let normalized = remoteUrl.trim();
-  normalized = normalized.replace(/^[a-z]+:\/\//i, "");
-  normalized = normalized.replace(/^git@([^:]+):/i, "$1/");
-  normalized = normalized.replace(/\.git$/i, "");
-  normalized = normalized.replace(/\/+$/, "");
-  return normalized.toLowerCase();
-};
-var sha256 = (value) => {
-  return crypto3.createHash("sha256").update(value).digest("hex");
-};
-var resolveGitDir = (gitPath) => {
+  if (!uuidRegex2.test(projectId.trim())) {
+    throw new Error(`[memoraone-mcp] memoraone.m1 projectId is not a UUID at ${markerPath}`);
+  }
+  const apiKeyRaw = parsed2?.MEMORAONE_API_KEY ?? parsed2?.api_key;
+  const apiKey = apiKeyRaw !== void 0 && apiKeyRaw !== null && typeof apiKeyRaw === "string" && apiKeyRaw.trim() !== "" ? apiKeyRaw.trim() : null;
+  return { projectId: projectId.trim(), apiKey };
+}
+async function resolveProjectIdFromExplicitM1Path() {
+  const raw = process.env.MEMORAONE_M1_PATH;
+  if (raw === void 0 || raw.trim() === "") {
+    return null;
+  }
+  const markerPath = path2.resolve(raw);
   try {
-    const stat = fs2.statSync(gitPath);
-    if (stat.isDirectory()) {
-      return gitPath;
-    }
-    if (stat.isFile()) {
-      const content = fs2.readFileSync(gitPath, "utf8");
-      const match = content.match(/^gitdir:\s*(.+)$/m);
-      if (match) {
-        const gitDir = match[1].trim();
-        return path2.resolve(path2.dirname(gitPath), gitDir);
-      }
+    const content = await fs2.readFile(markerPath, "utf8");
+    const { projectId, apiKey } = parseAndValidateM1(content, markerPath);
+    return { projectId, apiKey, foundAt: markerPath };
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      return null;
     }
-  } catch {
-    return null;
+    throw err;
   }
-  return null;
-};
-var findGitRoot = (start) => {
-  let current = path2.resolve(start);
+}
+async function findM1WalkingUp(workspaceRoot) {
+  let current = path2.resolve(workspaceRoot);
   while (true) {
-    const gitPath = path2.join(current, ".git");
-    if (fs2.existsSync(gitPath)) {
-      const gitDir = resolveGitDir(gitPath);
-      if (gitDir) {
-        return { gitRoot: current, gitDir };
+    const markerPath = path2.join(current, "memoraone.m1");
+    try {
+      const content = await fs2.readFile(markerPath, "utf8");
+      const { projectId, apiKey } = parseAndValidateM1(content, markerPath);
+      const repoRoot = path2.dirname(markerPath);
+      return { projectId, apiKey, repoRoot, markerPath };
+    } catch (err) {
+      if (err?.code !== "ENOENT") {
+        throw err;
       }
     }
     const parent = path2.dirname(current);
@@ -327,275 +337,158 @@ var findGitRoot = (start) => {
     current = parent;
   }
   return null;
-};
-var readOriginRemote = (gitDir) => {
-  const configPath = path2.join(gitDir, "config");
-  try {
-    const content = fs2.readFileSync(configPath, "utf8");
-    const lines = content.split(/\r?\n/);
-    let inOrigin = false;
-    for (const line of lines) {
-      const sectionMatch = line.match(/^\s*\[(.+)]\s*$/);
-      if (sectionMatch) {
-        inOrigin = sectionMatch[1].trim() === 'remote "origin"';
-        continue;
-      }
-      if (inOrigin) {
-        const urlMatch = line.match(/^\s*url\s*=\s*(.+)\s*$/);
-        if (urlMatch) {
-          return urlMatch[1].trim();
-        }
-      }
+}
+function normalizeWorkspaceSearchRoots(workspaceRoot) {
+  if (workspaceRoot === void 0) {
+    return [];
+  }
+  const list = Array.isArray(workspaceRoot) ? workspaceRoot : [workspaceRoot];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of list) {
+    if (raw === void 0) {
+      continue;
+    }
+    const trimmed = String(raw).trim();
+    if (trimmed === "") {
+      continue;
+    }
+    const resolved = path2.resolve(trimmed);
+    if (!seen.has(resolved)) {
+      seen.add(resolved);
+      out.push(resolved);
     }
-  } catch {
-    return null;
   }
-  return null;
-};
-function resolveRepoFingerprint(cwd2) {
-  const found = findGitRoot(cwd2);
-  if (!found) {
-    const fallbackPath = path2.resolve(cwd2);
-    const fingerprint2 = sha256(fallbackPath);
-    debugLog(`repo fingerprint=${fingerprint2} source=path-fallback`);
-    return {
-      fingerprint: fingerprint2,
-      gitRoot: fallbackPath,
-      source: "path-fallback"
-    };
+  return out;
+}
+function resolveApiKeyWithSource(fileApiKey) {
+  const envApiKey = process.env.MEMORAONE_API_KEY?.trim();
+  if (envApiKey) {
+    return { apiKey: envApiKey, apiKeySource: "env" };
   }
-  const { gitRoot, gitDir } = found;
-  const remoteUrl = readOriginRemote(gitDir);
-  if (remoteUrl) {
-    const normalized = normalizeRemoteUrl(remoteUrl);
-    const fingerprint2 = sha256(normalized);
-    debugLog(`repo fingerprint=${fingerprint2} source=git-remote`);
+  const aliasEnvApiKey = process.env.MEMORA_API_KEY?.trim();
+  if (aliasEnvApiKey) {
+    return { apiKey: aliasEnvApiKey, apiKeySource: "env" };
+  }
+  if (fileApiKey) {
+    return { apiKey: fileApiKey, apiKeySource: "memoraone.m1" };
+  }
+  return { apiKey: null, apiKeySource: "none" };
+}
+async function resolveAuthoritativeBinding(workspaceRoot) {
+  const explicitBinding = await resolveProjectIdFromExplicitM1Path();
+  if (explicitBinding) {
+    const resolved = resolveApiKeyWithSource(explicitBinding.apiKey);
     return {
-      fingerprint: fingerprint2,
-      gitRoot,
-      remoteUrl,
-      source: "git-remote"
+      projectId: explicitBinding.projectId,
+      workspaceRoot: path2.dirname(explicitBinding.foundAt),
+      m1Path: explicitBinding.foundAt,
+      apiKey: resolved.apiKey,
+      bindingSource: "explicit-m1-path",
+      apiKeySource: resolved.apiKeySource
     };
   }
-  const fingerprint = sha256(path2.resolve(gitRoot));
-  debugLog(`repo fingerprint=${fingerprint} source=path-fallback`);
-  return {
-    fingerprint,
-    gitRoot,
-    source: "path-fallback"
-  };
+  const candidates = normalizeWorkspaceSearchRoots(workspaceRoot);
+  if (candidates.length === 0) {
+    throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
+  }
+  for (const root of candidates) {
+    const binding = await findM1WalkingUp(root);
+    if (binding) {
+      const resolved = resolveApiKeyWithSource(binding.apiKey);
+      return {
+        projectId: binding.projectId,
+        workspaceRoot: binding.repoRoot,
+        m1Path: binding.markerPath,
+        apiKey: resolved.apiKey,
+        bindingSource: "workspace-search",
+        apiKeySource: resolved.apiKeySource
+      };
+    }
+  }
+  throw new Error("Could not find memoraone.m1 in workspace.\nOpen a folder containing memoraone.m1.");
 }
 
-// src/workspaceMap.ts
-var fs3 = __toESM(require("fs/promises"), 1);
+// src/sourceRegistration.ts
 var path3 = __toESM(require("path"), 1);
-var import_node_os = __toESM(require("os"), 1);
-var parseBooleanFlag4 = (value) => {
-  if (!value) {
-    return false;
-  }
-  const normalized = value.trim().toLowerCase();
-  return ["1", "true", "yes", "on"].includes(normalized);
-};
-var debugEnabled3 = parseBooleanFlag4(process.env.MEMORAONE_DEV_MODE);
-var debugLog2 = (message) => {
-  if (!debugEnabled3) {
-    return;
+var import_node_url = 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
+  };
+  if (ideType) {
+    body.metadata = {
+      ide_type: ideType
+    };
   }
-  process.stderr.write(`[memoraone-mcp][debug] ${message}
-`);
-};
-var fingerprintRegex = /^[0-9a-f]{64}$/i;
-function getWorkspaceMapPath() {
-  return path3.join(import_node_os.default.homedir(), ".memoraone", "workspaces.json");
+  return body;
 }
-var ensureWorkspaceDir = async () => {
-  const dir = path3.dirname(getWorkspaceMapPath());
-  await fs3.mkdir(dir, { recursive: true });
-};
-var validateWorkspaceMap = (map, filePath) => {
-  if (!map || typeof map !== "object" || Array.isArray(map)) {
-    throw new Error(
-      `[memoraone-mcp] Invalid workspace map schema in ${filePath}`
-    );
-  }
-  for (const [fingerprint, entry] of Object.entries(map)) {
-    if (!fingerprintRegex.test(fingerprint)) {
-      throw new Error(
-        `[memoraone-mcp] Invalid workspace fingerprint in ${filePath}`
+async function registerRepoSource(client, projectId, repoPath, ideType) {
+  try {
+    if (repoPath === void 0 || repoPath === null || String(repoPath).trim() === "") {
+      process.stderr.write(
+        `${LOG_PREFIX} skipped: empty repoPath (cannot register workspace)
+`
       );
+      return;
     }
-    if (typeof entry === "string") {
-      if (!entry.trim()) {
-        throw new Error(
-          `[memoraone-mcp] Invalid workspace projectKey in ${filePath}`
+    const normalizedRepoPath = path3.resolve(String(repoPath));
+    const body = buildRepoSourcePayload(normalizedRepoPath, ideType);
+    const primaryPath = `/v1/projects/${projectId}/sources`;
+    const alternatePath = `/v1/projects/${projectId}/sources/register`;
+    process.stderr.write(
+      `${LOG_PREFIX} registering projectId=${projectId} path=${normalizedRepoPath} ideType=${ideType ?? "(none)"}
+`
+    );
+    try {
+      await client.post(primaryPath, body, {
+        acceptStatuses: [409],
+        log: false,
+        quietHttpStatuses: [404, 405, 501]
+      });
+      process.stderr.write(`${LOG_PREFIX} ok: POST ${primaryPath}
+`);
+      return;
+    } catch (err) {
+      if (err instanceof MemoraOneHttpError && (err.status === 404 || err.status === 405 || err.status === 501)) {
+        process.stderr.write(
+          `${LOG_PREFIX} primary route returned ${err.status}; retrying POST ${alternatePath}
+`
         );
+        await client.post(alternatePath, body, { acceptStatuses: [409], log: false });
+        process.stderr.write(`${LOG_PREFIX} ok: POST ${alternatePath}
+`);
+        return;
       }
-      continue;
-    }
-    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-      throw new Error(
-        `[memoraone-mcp] Invalid workspace projectKey in ${filePath}`
-      );
-    }
-    const projectKey = entry.projectKey ?? entry.project_id;
-    if (!projectKey || !projectKey.trim()) {
-      throw new Error(
-        `[memoraone-mcp] Invalid workspace projectKey in ${filePath}`
-      );
-    }
-    const source = entry.source;
-    if (source !== void 0 && typeof source !== "string") {
-      throw new Error(
-        `[memoraone-mcp] Invalid workspace source in ${filePath}`
-      );
+      throw err;
     }
-    const linkedAt = entry.linked_at;
-    if (linkedAt !== void 0 && typeof linkedAt !== "string") {
-      throw new Error(
-        `[memoraone-mcp] Invalid workspace linked_at in ${filePath}`
+  } catch (err) {
+    const msg = String(err?.message ?? err);
+    process.stderr.write(`${LOG_PREFIX} failed: ${msg}
+`);
+    if (err instanceof MemoraOneHttpError) {
+      const bodyStr = typeof err.body === "string" ? err.body : JSON.stringify(err.body ?? null);
+      process.stderr.write(
+        `${LOG_PREFIX} http status=${err.status} body=${bodyStr.length > 500 ? bodyStr.slice(0, 500) + "..." : bodyStr}
+`
       );
     }
   }
-};
-async function readWorkspaceMap() {
-  const filePath = getWorkspaceMapPath();
-  try {
-    const content = await fs3.readFile(filePath, "utf8");
-    const parsed2 = JSON.parse(content);
-    validateWorkspaceMap(parsed2, filePath);
-    const typed = parsed2;
-    let migrated = false;
-    const normalized = {};
-    for (const [fingerprint, entry] of Object.entries(typed)) {
-      if (typeof entry === "string") {
-        normalized[fingerprint] = entry;
-        continue;
-      }
-      const projectKey = entry.projectKey ?? entry.project_id ?? "";
-      if (entry.project_id && !entry.projectKey) {
-        migrated = true;
-      }
-      normalized[fingerprint] = {
-        ...projectKey ? { projectKey } : {},
-        ...entry.source ? { source: entry.source } : {},
-        ...entry.linked_at ? { linked_at: entry.linked_at } : {}
-      };
-    }
-    if (migrated) {
-      await writeWorkspaceMap(normalized);
-    }
-    debugLog2(
-      `workspace map loaded path=${filePath} entries=${Object.keys(normalized).length}`
-    );
-    return normalized;
-  } catch (err) {
-    if (err?.code === "ENOENT") {
-      const emptyMap = {};
-      debugLog2(`workspace map loaded path=${filePath} entries=0`);
-      return emptyMap;
-    }
-    if (err instanceof SyntaxError) {
-      throw new Error(
-        `[memoraone-mcp] Failed to parse workspace map at ${filePath}`
-      );
-    }
-    throw err;
-  }
-}
-async function writeWorkspaceMap(map) {
-  const filePath = getWorkspaceMapPath();
-  validateWorkspaceMap(map, filePath);
-  await ensureWorkspaceDir();
-  const tempPath = `${filePath}.tmp`;
-  const content = JSON.stringify(map, null, 2);
-  await fs3.writeFile(tempPath, content, "utf8");
-  await fs3.rename(tempPath, filePath);
-}
-async function getProjectIdForFingerprint(fingerprint) {
-  if (!fingerprintRegex.test(fingerprint)) {
-    throw new Error("[memoraone-mcp] Invalid fingerprint");
-  }
-  const map = await readWorkspaceMap();
-  const entry = map[fingerprint];
-  if (!entry) {
-    return { projectKey: null, source: "unknown" };
-  }
-  if (typeof entry === "string") {
-    return { projectKey: entry, source: "unknown" };
-  }
-  return {
-    projectKey: entry.projectKey ?? entry.project_id ?? null,
-    source: entry.source ?? "unknown"
-  };
-}
-async function setProjectIdForFingerprint(args) {
-  const { fingerprint, projectKey, source, linked_at } = args;
-  if (!fingerprintRegex.test(fingerprint)) {
-    throw new Error("[memoraone-mcp] Invalid fingerprint");
-  }
-  if (!projectKey.trim()) {
-    throw new Error("[memoraone-mcp] Invalid projectKey");
-  }
-  const map = await readWorkspaceMap();
-  map[fingerprint] = {
-    projectKey,
-    ...source ? { source } : {},
-    linked_at: linked_at ?? (/* @__PURE__ */ new Date()).toISOString()
-  };
-  await writeWorkspaceMap(map);
-  debugLog2(
-    `workspace map set fingerprint=${fingerprint} projectKey=${projectKey}`
-  );
-}
-
-// src/projectBinding.ts
-var fs4 = __toESM(require("fs/promises"), 1);
-var path4 = __toESM(require("path"), 1);
-function readRepoProjectIdPath(gitRoot) {
-  return path4.join(gitRoot, ".memoraone-project");
-}
-async function readRepoProjectId(gitRoot) {
-  const filePath = readRepoProjectIdPath(gitRoot);
-  try {
-    const content = await fs4.readFile(filePath, "utf8");
-    const value = content.trim();
-    return value ? value : null;
-  } catch (err) {
-    if (err?.code === "ENOENT") {
-      return null;
-    }
-    throw err;
-  }
-}
-function resolveProjectIdOrThrow(args) {
-  const envProjectKey = args.envProjectKey?.trim();
-  if (envProjectKey) {
-    return { projectKey: envProjectKey, source: "env" };
-  }
-  const repoFileProjectKey = args.repoFileProjectKey?.trim();
-  if (repoFileProjectKey) {
-    return { projectKey: repoFileProjectKey, source: "repo-file" };
-  }
-  const workspaceProjectKey = args.workspaceProjectKey?.trim();
-  if (workspaceProjectKey) {
-    return { projectKey: workspaceProjectKey, source: "workspace-map" };
-  }
-  throw new Error(
-    `Repo not linked to a MemoraOne project. Set MEMORAONE_PROJECT_ID or create ${args.repoFilePath} containing a project key.`
-  );
-}
-
-// src/tools/postEvent.ts
-var import_v42 = require("zod/v4");
-var postEventShape = {
-  kind: import_v42.z.string().min(1),
-  actor: import_v42.z.object({
-    identifier: import_v42.z.string().min(1),
-    id: import_v42.z.string().min(1).optional()
-  }),
-  content: import_v42.z.record(import_v42.z.string(), import_v42.z.any()),
-  metadata: import_v42.z.record(import_v42.z.string(), import_v42.z.any()).optional()
+}
+
+// src/tools/postEvent.ts
+var import_v42 = require("zod/v4");
+var postEventShape = {
+  kind: import_v42.z.string().min(1),
+  actor: import_v42.z.object({
+    identifier: import_v42.z.string().min(1),
+    id: import_v42.z.string().min(1).optional()
+  }),
+  content: import_v42.z.record(import_v42.z.string(), import_v42.z.any()),
+  metadata: import_v42.z.record(import_v42.z.string(), import_v42.z.any()).optional()
 };
 
 // src/tools/askWithMemory.ts
@@ -672,7 +565,67 @@ var setProjectShape = {
 
 // src/tools/handlers/postEvent.ts
 var import_v49 = require("zod/v4");
-var crypto4 = __toESM(require("crypto"), 1);
+var crypto3 = __toESM(require("crypto"), 1);
+
+// src/runContext.ts
+var import_node_async_hooks = require("async_hooks");
+var crypto2 = __toESM(require("crypto"), 1);
+var sessionContextStorage = new import_node_async_hooks.AsyncLocalStorage();
+function createSessionRunContext(initial = {}) {
+  return {
+    currentRunId: null,
+    currentProjectId: null,
+    currentApiKey: null,
+    boundProjectId: null,
+    boundApiKey: null,
+    ...initial
+  };
+}
+function runWithSessionContext(context, fn) {
+  return sessionContextStorage.run(context, fn);
+}
+function getSessionContext() {
+  const context = sessionContextStorage.getStore();
+  if (!context) {
+    throw new Error("[memoraone-mcp] Session context not initialized");
+  }
+  return context;
+}
+function getBoundProjectId() {
+  return getSessionContext().boundProjectId;
+}
+function setBoundProjectId(id) {
+  getSessionContext().boundProjectId = id;
+}
+function setBoundApiKey(key) {
+  getSessionContext().boundApiKey = key;
+}
+function getCurrentRunId() {
+  return getSessionContext().currentRunId;
+}
+function setCurrentRunId(id) {
+  getSessionContext().currentRunId = id;
+}
+function getCurrentProjectId() {
+  return getSessionContext().currentProjectId;
+}
+function setCurrentProjectId(id) {
+  getSessionContext().currentProjectId = id;
+}
+function setCurrentApiKey(key) {
+  getSessionContext().currentApiKey = key;
+}
+function resolveRunId(passed) {
+  if (passed) {
+    return passed;
+  }
+  return getCurrentRunId();
+}
+function generateRunId() {
+  return crypto2.randomBytes(16).toString("hex");
+}
+
+// src/tools/handlers/postEvent.ts
 var postEventInputSchema = import_v49.z.object({
   kind: import_v49.z.string().min(1),
   actor: import_v49.z.object({
@@ -683,7 +636,7 @@ var postEventInputSchema = import_v49.z.object({
   metadata: import_v49.z.record(import_v49.z.string(), import_v49.z.any()).optional()
 });
 async function handlePostEvent(client, args) {
-  const nonce = crypto4.randomBytes(8).toString("hex");
+  const nonce = crypto3.randomBytes(8).toString("hex");
   console.error(
     `[memoraone-mcp][debug] tool=memora_post_event toolCallId=unknown nonce=${nonce} stage=before_post`
   );
@@ -700,7 +653,7 @@ async function handlePostEvent(client, args) {
     projectKey,
     actor: {
       type: "agent",
-      identifier: config.agentName,
+      identifier: config2.agentName,
       ...parsed2.actor.id ? { id: parsed2.actor.id } : {}
     },
     ...parsed2.metadata ? { metadata: parsed2.metadata } : {}
@@ -789,13 +742,13 @@ async function handleLogIntent(client, args) {
   setCurrentRunId(run_id);
   const body = {
     kind: "note",
-    actor: { type: config.agentType, name: config.agentName },
+    actor: { type: config2.agentType, name: config2.agentName },
     concept,
     // MUST be TOP-LEVEL so it populates timeline_events.concept
     message,
     projectKey,
     metadata: {
-      source: config.source,
+      source: config2.source,
       purpose,
       // 'task' | 'decision'
       intent_source: intent_source ?? "cursor_chat",
@@ -833,11 +786,11 @@ async function handleLogChangeSummary(client, args) {
   const body = {
     kind: "note",
     concept: "concept:change_summary",
-    actor: { type: config.agentType, name: config.agentName },
+    actor: { type: config2.agentType, name: config2.agentName },
     message,
     projectKey,
     metadata: {
-      source: config.source,
+      source: config2.source,
       purpose: "change_summary",
       tool: "memora_log_change_summary",
       ...scope ? { scope } : {},
@@ -876,11 +829,11 @@ async function handleLogToolResult(client, args) {
   const body = {
     kind: "note",
     concept: "concept:tool_result",
-    actor: { type: config.agentType, name: config.agentName },
+    actor: { type: config2.agentType, name: config2.agentName },
     message,
     projectKey,
     metadata: {
-      source: config.source,
+      source: config2.source,
       purpose: "tool_result",
       tool: "memora_log_tool_result",
       tool_name: tool,
@@ -920,11 +873,11 @@ async function handleLogCommand(client, args) {
   const body = {
     kind: "note",
     concept: "concept:command",
-    actor: { type: config.agentType, name: config.agentName },
+    actor: { type: config2.agentType, name: config2.agentName },
     message,
     projectKey,
     metadata: {
-      source: config.source,
+      source: config2.source,
       purpose: "command",
       tool: "memora_log_command",
       cmd,
@@ -941,12 +894,340 @@ async function handleLogCommand(client, args) {
 
 // src/tools/handlers/listProjects.ts
 async function handleListProjects(client) {
-  const res = await client.get("/admin/projects");
+  const res = await client.get("/v1/projects");
   return res ?? { items: [] };
 }
 
 // src/tools/handlers/setProject.ts
 var import_v415 = 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 parseBooleanFlag3 = (value) => {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return ["1", "true", "yes", "on"].includes(normalized);
+};
+var debugEnabled2 = parseBooleanFlag3(process.env.MEMORAONE_DEV_MODE);
+var debugLog = (message) => {
+  if (!debugEnabled2) {
+    return;
+  }
+  process.stderr.write(`[memoraone-mcp][debug] ${message}
+`);
+};
+var normalizeRemoteUrl = (remoteUrl) => {
+  let normalized = remoteUrl.trim();
+  normalized = normalized.replace(/^[a-z]+:\/\//i, "");
+  normalized = normalized.replace(/^git@([^:]+):/i, "$1/");
+  normalized = normalized.replace(/\.git$/i, "");
+  normalized = normalized.replace(/\/+$/, "");
+  return normalized.toLowerCase();
+};
+var sha256 = (value) => {
+  return crypto4.createHash("sha256").update(value).digest("hex");
+};
+var resolveGitDir = (gitPath) => {
+  try {
+    const stat2 = fs3.statSync(gitPath);
+    if (stat2.isDirectory()) {
+      return gitPath;
+    }
+    if (stat2.isFile()) {
+      const content = fs3.readFileSync(gitPath, "utf8");
+      const match = content.match(/^gitdir:\s*(.+)$/m);
+      if (match) {
+        const gitDir = match[1].trim();
+        return path4.resolve(path4.dirname(gitPath), gitDir);
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+};
+var findGitRoot = (start) => {
+  let current = path4.resolve(start);
+  while (true) {
+    const gitPath = path4.join(current, ".git");
+    if (fs3.existsSync(gitPath)) {
+      const gitDir = resolveGitDir(gitPath);
+      if (gitDir) {
+        return { gitRoot: current, gitDir };
+      }
+    }
+    const parent = path4.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+};
+var readOriginRemote = (gitDir) => {
+  const configPath = path4.join(gitDir, "config");
+  try {
+    const content = fs3.readFileSync(configPath, "utf8");
+    const lines = content.split(/\r?\n/);
+    let inOrigin = false;
+    for (const line of lines) {
+      const sectionMatch = line.match(/^\s*\[(.+)]\s*$/);
+      if (sectionMatch) {
+        inOrigin = sectionMatch[1].trim() === 'remote "origin"';
+        continue;
+      }
+      if (inOrigin) {
+        const urlMatch = line.match(/^\s*url\s*=\s*(.+)\s*$/);
+        if (urlMatch) {
+          return urlMatch[1].trim();
+        }
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+};
+function resolveRepoFingerprint(cwd2) {
+  const found = findGitRoot(cwd2);
+  if (!found) {
+    const fallbackPath = path4.resolve(cwd2);
+    const fingerprint2 = sha256(fallbackPath);
+    debugLog(`repo fingerprint=${fingerprint2} source=path-fallback`);
+    return {
+      fingerprint: fingerprint2,
+      gitRoot: fallbackPath,
+      source: "path-fallback"
+    };
+  }
+  const { gitRoot, gitDir } = found;
+  const remoteUrl = readOriginRemote(gitDir);
+  if (remoteUrl) {
+    const normalized = normalizeRemoteUrl(remoteUrl);
+    const fingerprint2 = sha256(normalized);
+    debugLog(`repo fingerprint=${fingerprint2} source=git-remote`);
+    return {
+      fingerprint: fingerprint2,
+      gitRoot,
+      remoteUrl,
+      source: "git-remote"
+    };
+  }
+  const fingerprint = sha256(path4.resolve(gitRoot));
+  debugLog(`repo fingerprint=${fingerprint} source=path-fallback`);
+  return {
+    fingerprint,
+    gitRoot,
+    source: "path-fallback"
+  };
+}
+
+// src/workspaceMap.ts
+var fs4 = __toESM(require("fs/promises"), 1);
+var path5 = __toESM(require("path"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var parseBooleanFlag4 = (value) => {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return ["1", "true", "yes", "on"].includes(normalized);
+};
+var debugEnabled3 = parseBooleanFlag4(process.env.MEMORAONE_DEV_MODE);
+var debugLog2 = (message) => {
+  if (!debugEnabled3) {
+    return;
+  }
+  process.stderr.write(`[memoraone-mcp][debug] ${message}
+`);
+};
+var fingerprintRegex = /^[0-9a-f]{64}$/i;
+function getWorkspaceMapPath() {
+  return path5.join(import_node_os.default.homedir(), ".memoraone", "workspaces.json");
+}
+var ensureWorkspaceDir = async () => {
+  const dir = path5.dirname(getWorkspaceMapPath());
+  await fs4.mkdir(dir, { recursive: true });
+};
+async function acquireWorkspaceMapLock() {
+  const filePath = getWorkspaceMapPath();
+  const lockPath = `${filePath}.lock`;
+  const maxRetries = 10;
+  const retryDelayMs = 50;
+  const maxLockAgeMs = 5e3;
+  await ensureWorkspaceDir();
+  let lockAcquired = false;
+  let retries = 0;
+  while (!lockAcquired && retries < maxRetries) {
+    try {
+      try {
+        const stat2 = await fs4.stat(lockPath);
+        const ageMs = Date.now() - stat2.mtimeMs;
+        if (ageMs > maxLockAgeMs) {
+          await fs4.unlink(lockPath);
+          debugLog2(`removed stale workspace map lock (age: ${ageMs}ms)`);
+        }
+      } catch (err) {
+        if (err?.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      const fd = await fs4.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));
+          continue;
+        }
+        throw new Error(
+          `[memoraone-mcp] Failed to acquire workspace map lock after ${maxRetries} retries`
+        );
+      }
+      throw err;
+    }
+  }
+  return async () => {
+    try {
+      await fs4.unlink(lockPath);
+    } catch (err) {
+      if (err?.code !== "ENOENT") {
+        debugLog2(`failed to release workspace map lock: ${String(err)}`);
+      }
+    }
+  };
+}
+var validateWorkspaceMap = (map, filePath) => {
+  if (!map || typeof map !== "object" || Array.isArray(map)) {
+    throw new Error(
+      `[memoraone-mcp] Invalid workspace map schema in ${filePath}`
+    );
+  }
+  for (const [fingerprint, entry] of Object.entries(map)) {
+    if (!fingerprintRegex.test(fingerprint)) {
+      throw new Error(
+        `[memoraone-mcp] Invalid workspace fingerprint in ${filePath}`
+      );
+    }
+    if (typeof entry === "string") {
+      if (!entry.trim()) {
+        throw new Error(
+          `[memoraone-mcp] Invalid workspace projectKey in ${filePath}`
+        );
+      }
+      continue;
+    }
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(
+        `[memoraone-mcp] Invalid workspace projectKey in ${filePath}`
+      );
+    }
+    const projectKey = entry.projectKey ?? entry.project_id;
+    if (!projectKey || !projectKey.trim()) {
+      throw new Error(
+        `[memoraone-mcp] Invalid workspace projectKey in ${filePath}`
+      );
+    }
+    const source = entry.source;
+    if (source !== void 0 && typeof source !== "string") {
+      throw new Error(
+        `[memoraone-mcp] Invalid workspace source in ${filePath}`
+      );
+    }
+    const linkedAt = entry.linked_at;
+    if (linkedAt !== void 0 && typeof linkedAt !== "string") {
+      throw new Error(
+        `[memoraone-mcp] Invalid workspace linked_at in ${filePath}`
+      );
+    }
+  }
+};
+async function readWorkspaceMap() {
+  const filePath = getWorkspaceMapPath();
+  try {
+    const content = await fs4.readFile(filePath, "utf8");
+    const parsed2 = JSON.parse(content);
+    validateWorkspaceMap(parsed2, filePath);
+    const typed = parsed2;
+    let migrated = false;
+    const normalized = {};
+    for (const [fingerprint, entry] of Object.entries(typed)) {
+      if (typeof entry === "string") {
+        normalized[fingerprint] = entry;
+        continue;
+      }
+      const projectKey = entry.projectKey ?? entry.project_id ?? "";
+      if (entry.project_id && !entry.projectKey) {
+        migrated = true;
+      }
+      normalized[fingerprint] = {
+        ...projectKey ? { projectKey } : {},
+        ...entry.source ? { source: entry.source } : {},
+        ...entry.linked_at ? { linked_at: entry.linked_at } : {}
+      };
+    }
+    debugLog2(
+      `workspace map loaded path=${filePath} entries=${Object.keys(normalized).length}`
+    );
+    return { map: normalized, needsMigration: migrated };
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      const emptyMap = {};
+      debugLog2(`workspace map loaded path=${filePath} entries=0`);
+      return { map: emptyMap, needsMigration: false };
+    }
+    if (err instanceof SyntaxError) {
+      throw new Error(
+        `[memoraone-mcp] Failed to parse workspace map at ${filePath}`
+      );
+    }
+    throw err;
+  }
+}
+async function writeWorkspaceMap(map) {
+  const filePath = getWorkspaceMapPath();
+  validateWorkspaceMap(map, filePath);
+  await ensureWorkspaceDir();
+  const tempPath = `${filePath}.tmp`;
+  const content = JSON.stringify(map, null, 2);
+  await fs4.writeFile(tempPath, content, "utf8");
+  await fs4.rename(tempPath, filePath);
+}
+async function setProjectIdForFingerprint(args) {
+  const { fingerprint, projectKey, source, linked_at } = args;
+  if (!fingerprintRegex.test(fingerprint)) {
+    throw new Error("[memoraone-mcp] Invalid fingerprint");
+  }
+  if (!projectKey.trim()) {
+    throw new Error("[memoraone-mcp] Invalid projectKey");
+  }
+  const releaseLock = await acquireWorkspaceMapLock();
+  try {
+    const { map, needsMigration } = await readWorkspaceMap();
+    if (needsMigration) {
+      await writeWorkspaceMap(map);
+    }
+    map[fingerprint] = {
+      projectKey,
+      ...source ? { source } : {},
+      linked_at: linked_at ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeWorkspaceMap(map);
+    debugLog2(
+      `workspace map set fingerprint=${fingerprint} projectKey=${projectKey}`
+    );
+  } finally {
+    await releaseLock();
+  }
+}
+
+// src/tools/handlers/setProject.ts
 var setProjectInputSchema = import_v415.z.object({
   projectKey: import_v415.z.string().min(1).optional(),
   projectId: import_v415.z.string().min(1).optional()
@@ -957,6 +1238,13 @@ async function handleSetProject(args) {
   if (!resolvedProjectKey) {
     throw new Error("projectKey is required");
   }
+  const requested = resolvedProjectKey.trim();
+  const bound = getBoundProjectId();
+  if (bound !== null && requested !== bound) {
+    throw new Error(
+      `Project switching is disabled (Option A). This MCP process is bound to ${bound}. Start a separate MCP instance/window for ${requested}.`
+    );
+  }
   setCurrentProjectId(resolvedProjectKey);
   const repo = resolveRepoFingerprint(process.cwd());
   await setProjectIdForFingerprint({
@@ -968,9 +1256,91 @@ async function handleSetProject(args) {
 }
 
 // src/index.ts
-async function sendHeartbeat(client) {
+var notInitializedResult = {
+  content: [
+    {
+      type: "text",
+      text: "MemoraOne MCP not initialized (project binding missing)."
+    }
+  ]
+};
+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 isHeartbeatDebugEnabled() {
+  const value = String(process.env.MEMORAONE_DEBUG_HEARTBEAT ?? "").trim().toLowerCase();
+  return ["1", "true", "yes", "on"].includes(value);
+}
+function fingerprintApiKey(apiKey) {
+  return crypto5.createHash("sha256").update(apiKey).digest("hex").slice(0, 12);
+}
+function inferIdeType(params) {
+  if (config2.ideType) {
+    return config2.ideType;
+  }
+  const clientInfoName = String(params?.clientInfo?.name ?? "").toLowerCase();
+  const clientInfoVersion = String(params?.clientInfo?.version ?? "").toLowerCase();
+  const termProgram = String(process.env.TERM_PROGRAM ?? "").toLowerCase();
+  const argv = process.argv.join(" ").toLowerCase();
+  const envKeys = Object.keys(process.env);
+  const hasCursorSignals = envKeys.some((key) => key.startsWith("CURSOR_")) || termProgram === "cursor" || clientInfoName.includes("cursor") || clientInfoVersion.includes("cursor") || argv.includes("cursor");
+  if (hasCursorSignals) {
+    return "cursor";
+  }
+  const hasJetBrainsSignals = envKeys.some(
+    (key) => [
+      "JETBRAINS_IDE",
+      "IDEA_INITIAL_DIRECTORY",
+      "JETBRAINS_REMOTE_RUN",
+      "INTELLIJ_ENVIRONMENT_READER"
+    ].includes(key)
+  ) || String(process.env.TERMINAL_EMULATOR ?? "").toLowerCase().includes("jetbrains") || /(jetbrains|intellij|pycharm|webstorm|goland|rubymine|clion|phpstorm|rider|datagrip)/.test(
+    clientInfoName
+  ) || /(jetbrains|intellij|pycharm|webstorm|goland|rubymine|clion|phpstorm|rider|datagrip)/.test(
+    argv
+  );
+  if (hasJetBrainsSignals) {
+    return "jetbrains";
+  }
+  const hasVsCodeSignals = envKeys.some((key) => key.startsWith("VSCODE_")) || /(visual studio code|vscode|vs code|github copilot)/.test(clientInfoName) || /(visual studio code|vscode|vs code)/.test(argv);
+  if (hasVsCodeSignals) {
+    return "copilot-vscode";
+  }
+  return void 0;
+}
+async function sendHeartbeat(client, runtime) {
   try {
-    await client.post("/admin/api-keys/heartbeat", {}, { log: false });
+    const pid = runtime.projectId?.trim();
+    if (isHeartbeatDebugEnabled()) {
+      process.stderr.write(
+        `[memoraone-mcp][diag] heartbeat projectId=${pid ?? "unknown"} apiKeySource=${runtime.apiKeySource ?? "unknown"} apiKeyFingerprint=${runtime.apiKeyFingerprint ?? "unknown"}
+`
+      );
+    }
+    if (!pid) {
+      throw new Error("[memoraone-mcp] Cannot send heartbeat without an active project binding");
+    }
+    const body = {};
+    if (runtime.ideType) body.ide_type = runtime.ideType;
+    await client.post(`/v1/projects/${pid}/heartbeat`, body, {
+      log: false,
+      headers: {
+        "x-project-id": pid
+      }
+    });
   } catch (err) {
     process.stderr.write(
       `[memoraone-mcp][info] heartbeat error (silent) ${String(err)}
@@ -1004,20 +1374,19 @@ function sanitizeArgsSummary(args) {
     return "[unable to serialize args]";
   }
 }
-async function postWorklogEvent(client, message) {
+async function postWorklogEvent(client, projectId, message) {
   try {
-    const projectKey = getCurrentProjectId();
-    if (!projectKey) {
+    if (!projectId) {
       return;
     }
     const body = {
       kind: "note",
       concept: "concept:worklog",
-      actor: { type: config.agentType, name: config.agentName },
+      actor: { type: config2.agentType, name: config2.agentName },
       message,
-      projectKey,
+      projectKey: projectId,
       metadata: {
-        source: config.source,
+        source: config2.source,
         purpose: "worklog"
       }
     };
@@ -1026,241 +1395,363 @@ async function postWorklogEvent(client, message) {
     console.error("[memoraone-mcp] worklog error (silent)", err);
   }
 }
-function registerToolWithWorklog(server, client, toolName, description, schema, handler) {
-  if (!config.worklogEnabled) {
-    server.tool(toolName, description, schema, handler);
-    return;
-  }
-  server.tool(toolName, description, schema, async (args) => {
+function registerToolWithWorklog(server, runtime, sessionContext, toolName, description, schema, handler) {
+  const wrapped = async (args) => runWithSessionContext(sessionContext, async () => {
+    if (!runtime.client || !runtime.projectId) return notInitializedResult;
+    if (!config2.worklogEnabled) {
+      return handler(args);
+    }
     const argsSummary = sanitizeArgsSummary(args);
     const start = Date.now();
-    await postWorklogEvent(client, `tool_start: ${toolName} ${argsSummary}`);
+    await postWorklogEvent(runtime.client, runtime.projectId, `tool_start: ${toolName} ${argsSummary}`);
     try {
       const result = await handler(args);
       const durationMs = Date.now() - start;
-      await postWorklogEvent(client, `tool_end: ${toolName} ok (${durationMs}ms)`);
+      await postWorklogEvent(runtime.client, runtime.projectId, `tool_end: ${toolName} ok (${durationMs}ms)`);
       return result;
     } catch (err) {
       const durationMs = Date.now() - start;
       const errorSummary = err?.message || String(err);
       const shortError = errorSummary.length > 100 ? errorSummary.slice(0, 100) + "..." : errorSummary;
-      await postWorklogEvent(client, `tool_end: ${toolName} error (${durationMs}ms): ${shortError}`);
+      await postWorklogEvent(
+        runtime.client,
+        runtime.projectId,
+        `tool_end: ${toolName} error (${durationMs}ms): ${shortError}`
+      );
       throw err;
     }
   });
+  server.tool(toolName, description, schema, wrapped);
 }
-async function main() {
-  const repo = resolveRepoFingerprint(process.cwd());
-  const envProjectKey = process.env.MEMORAONE_PROJECT_ID;
-  const repoFilePath = readRepoProjectIdPath(repo.gitRoot);
-  const repoFileProjectKey = await readRepoProjectId(repo.gitRoot);
-  const workspaceResolved = await getProjectIdForFingerprint(repo.fingerprint);
-  const binding = resolveProjectIdOrThrow({
-    envProjectKey,
-    repoFileProjectKey,
-    workspaceProjectKey: workspaceResolved.projectKey,
-    repoFilePath
+async function main(opts = {}) {
+  let bindingReadyResolve = null;
+  let bindingReadyReject = null;
+  const bindingReady = new Promise((resolve6, reject) => {
+    bindingReadyResolve = resolve6;
+    bindingReadyReject = reject;
   });
-  const projectKey = binding.projectKey;
-  const source = binding.source;
-  setCurrentProjectId(projectKey);
-  const devMode = Boolean(config.devMode);
-  if (devMode) {
-    const remoteInfo = repo.remoteUrl ? ` remoteUrl=${repo.remoteUrl}` : "";
-    console.error(
-      `[memoraone-mcp][debug] repo fingerprint=${repo.fingerprint} projectKey=${projectKey} source=${source} gitRoot=${repo.gitRoot}${remoteInfo}`
-    );
-  }
-  const client = new memoraClient_default(config, projectKey);
-  console.error(
-    `[memoraone-mcp] Agent identity: name="${config.agentName}", type="${config.agentType}", source="${config.source}"`
-  );
+  const devMode = Boolean(config2.devMode);
+  const sessionLabel = opts.sessionLabel ?? "session";
+  const sessionContext = createSessionRunContext();
+  const runtime = {
+    client: null,
+    projectId: null,
+    apiKeySource: null,
+    apiKeyFingerprint: null,
+    ideType: void 0
+  };
+  let workspaceRoot;
   const server = new import_mcp.McpServer({
     name: "memoraone-mcp",
     version: "1.0.0"
   });
+  const resolveFallbackBindingFromInitialize = async (params) => {
+    let fallbackWorkspaceRoot = workspaceRoot;
+    try {
+      const rootsResult = await server.server.listRoots({});
+      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)");
+      }
+    } catch (e) {
+      console.error("[memoraone-mcp] 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 (params.workspaceFolders?.length) {
+        fallbackWorkspaceRoot = uriToPath(params.workspaceFolders[0].uri);
+        console.error("[memoraone-mcp] 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");
+        }
+      }
+    }
+    const binding = await resolveAuthoritativeBinding(fallbackWorkspaceRoot);
+    workspaceRoot = binding.workspaceRoot;
+    return binding;
+  };
   const registeredToolNames = [];
-  registeredToolNames.push("memora_post_event");
   server.tool(
     "memora_post_event",
     "Forward an event to MemoraOne timeline",
     postEventShape,
-    async (args) => {
-      const result = await handlePostEvent(client, args);
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handlePostEvent(runtime.client, args);
       return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
-    }
+    })
   );
-  registeredToolNames.push("memora_list_projects");
+  registeredToolNames.push("memora_post_event");
   server.tool(
     "memora_list_projects",
     "List projects available to the current API key",
     listProjectsShape,
-    async () => {
-      const result = await handleListProjects(client);
+    async () => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handleListProjects(runtime.client);
       return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
-    }
+    })
   );
-  registeredToolNames.push("memora_set_project");
+  registeredToolNames.push("memora_list_projects");
   server.tool(
     "memora_set_project",
     "Set the current project key for subsequent tool calls",
     setProjectShape,
-    async (args) => {
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
       const result = await handleSetProject(args);
       return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
-    }
+    })
   );
-  registeredToolNames.push("memora_ask_with_memory");
+  registeredToolNames.push("memora_set_project");
   registerToolWithWorklog(
     server,
-    client,
+    runtime,
+    sessionContext,
     "memora_ask_with_memory",
     "Ask MemoraOne with project memory context",
     askWithMemoryShape,
     async (args) => {
-      const result = await handleAskWithMemory(client, args);
+      const result = await handleAskWithMemory(runtime.client, args);
       return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
     }
   );
-  registeredToolNames.push("memora_log_intent");
+  registeredToolNames.push("memora_ask_with_memory");
   registerToolWithWorklog(
     server,
-    client,
+    runtime,
+    sessionContext,
     "memora_log_intent",
     "Log a natural-language TASK or DECISION intent to the MemoraOne timeline",
     logIntentShape,
     async (args) => {
-      const result = await handleLogIntent(client, args);
+      const result = await handleLogIntent(runtime.client, args);
       return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
     }
   );
-  registeredToolNames.push("memora_log_change_summary");
+  registeredToolNames.push("memora_log_intent");
   registerToolWithWorklog(
     server,
-    client,
+    runtime,
+    sessionContext,
     "memora_log_change_summary",
     "Log a concise code change summary to the MemoraOne timeline",
     logChangeSummaryShape,
     async (args) => {
-      const result = await handleLogChangeSummary(client, args);
+      const result = await handleLogChangeSummary(runtime.client, args);
       return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
     }
   );
-  registeredToolNames.push("memora_log_tool_result");
+  registeredToolNames.push("memora_log_change_summary");
   registerToolWithWorklog(
     server,
-    client,
+    runtime,
+    sessionContext,
     "memora_log_tool_result",
     "Log a tool execution result to the MemoraOne timeline",
     logToolResultShape,
     async (args) => {
-      const result = await handleLogToolResult(client, args);
+      const result = await handleLogToolResult(runtime.client, args);
       return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
     }
   );
-  registeredToolNames.push("memora_log_command");
+  registeredToolNames.push("memora_log_tool_result");
   registerToolWithWorklog(
     server,
-    client,
+    runtime,
+    sessionContext,
     "memora_log_command",
     "Log a command execution to the MemoraOne timeline",
     logCommandShape,
     async (args) => {
-      const result = await handleLogCommand(client, args);
+      const result = await handleLogCommand(runtime.client, args);
       return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          }
-        ]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
     }
   );
+  registeredToolNames.push("memora_log_command");
+  server.server.setRequestHandler(
+    import_types.InitializeRequestSchema,
+    async (request) => runWithSessionContext(sessionContext, async () => {
+      try {
+        const params = request.params;
+        runtime.ideType = inferIdeType(params);
+        if (!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) : [];
+          const cursorEnv = Object.keys(process.env).filter((k) => k.startsWith("CURSOR_")).reduce((acc, k) => {
+            acc[k] = process.env[k] ?? "";
+            return acc;
+          }, {});
+          const vscodeEnv = Object.keys(process.env).filter((k) => k.startsWith("VSCODE_")).reduce((acc, k) => {
+            acc[k] = process.env[k] ?? "";
+            return acc;
+          }, {});
+          console.error("[memoraone-mcp][diag] Initialize dump (once per process):");
+          console.error(`[memoraone-mcp][diag]   params.rootUri: ${JSON.stringify(params.rootUri)}`);
+          console.error(`[memoraone-mcp][diag]   params.workspaceFolders: ${JSON.stringify(folders)}`);
+          console.error(`[memoraone-mcp][diag]   params.clientInfo: ${JSON.stringify(params.clientInfo)}`);
+          console.error(`[memoraone-mcp][diag]   params.capabilities (keys): ${JSON.stringify(capKeys)}`);
+          console.error(`[memoraone-mcp][diag]   process.cwd(): ${process.cwd()}`);
+          console.error(`[memoraone-mcp][diag]   process.execPath: ${process.execPath}`);
+          console.error(`[memoraone-mcp][diag]   process.argv: ${JSON.stringify(process.argv)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.WORKSPACE_FOLDER_PATHS: ${JSON.stringify(process.env.WORKSPACE_FOLDER_PATHS)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.PWD: ${JSON.stringify(process.env.PWD)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.HOME: ${JSON.stringify(process.env.HOME)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.CURSOR_*: ${JSON.stringify(cursorEnv)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.VSCODE_*: ${JSON.stringify(vscodeEnv)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.TERM_PROGRAM: ${JSON.stringify(process.env.TERM_PROGRAM)}`);
+          console.error(`[memoraone-mcp][diag]   process.env.MEMORAONE_M1_PATH: ${JSON.stringify(process.env.MEMORAONE_M1_PATH)}`);
+        }
+        const debugAuth = ["1", "true", "yes", "on"].includes(
+          String(process.env.MEMORAONE_DEBUG_AUTH ?? "").trim().toLowerCase()
+        );
+        const debugLog3 = config2.devMode || debugAuth;
+        const binding = opts.authoritativeBinding ? opts.authoritativeBinding : await resolveFallbackBindingFromInitialize(params);
+        const apiKeyToUse = binding.apiKey;
+        if (!apiKeyToUse) {
+          throw new Error(
+            "[memoraone-mcp] No actor key. Set MEMORAONE_API_KEY or MEMORA_API_KEY, or add MEMORAONE_API_KEY/api_key to memoraone.m1"
+          );
+        }
+        if (debugLog3) {
+          console.error(
+            "[memoraone-mcp][debug] Resolved actor key from " + (binding.apiKeySource === "env" ? "ENV" : "memoraone.m1")
+          );
+        }
+        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 (existing === null) {
+          setBoundProjectId(projectId);
+          setBoundApiKey(apiKeyToUse);
+          console.error(
+            `[memoraone-mcp] ${sessionLabel} bound to project ${projectId} (Option A: single-project binding)`
+          );
+        }
+        setCurrentProjectId(projectId);
+        setCurrentApiKey(apiKeyToUse);
+        runtime.projectId = projectId;
+        runtime.apiKeySource = binding.apiKeySource;
+        runtime.apiKeyFingerprint = fingerprintApiKey(apiKeyToUse);
+        runtime.client = new memoraClient_default(config2, projectId, apiKeyToUse);
+        workspaceRoot = binding.workspaceRoot;
+        process.stderr.write(
+          `[memoraone-mcp] registering workspace source bindingSource=${binding.bindingSource} workspaceRoot=${workspaceRoot ?? "(unset)"} m1Path=${binding.m1Path}
+`
+        );
+        await registerRepoSource(
+          runtime.client,
+          runtime.projectId,
+          binding.workspaceRoot,
+          runtime.ideType
+        );
+        if (debugAuth) {
+          console.error("[memoraone-mcp][auth] repo root:", binding.workspaceRoot);
+          console.error("[memoraone-mcp][auth] project_id:", projectId);
+          console.error("[memoraone-mcp][auth] api_key source:", binding.apiKeySource);
+        }
+        console.error(
+          `[memoraone-mcp] ${sessionLabel} authoritative binding: project=${binding.projectId} workspace=${binding.workspaceRoot} m1=${binding.m1Path} source=${binding.bindingSource} apiKeySource=${binding.apiKeySource}`
+        );
+        bindingReadyResolve?.(runtime.client);
+        return server.server._oninitialize(request);
+      } catch (err) {
+        bindingReadyReject?.(err);
+        throw err;
+      }
+    })
+  );
   if (devMode) {
     console.error("[memoraone-mcp] Starting MCP server with", registeredToolNames.length, "tools");
   }
-  const transport = new import_stdio.StdioServerTransport();
+  const transport = opts.transport ?? new import_stdio.StdioServerTransport();
   await server.connect(transport);
+  const activeClient = await bindingReady;
   let heartbeatInterval = null;
-  if (config.heartbeatEnabled) {
-    if (globalThis.__memoraHeartbeatInterval) {
-      clearInterval(globalThis.__memoraHeartbeatInterval);
-    }
-    await sendHeartbeat(client);
-    const intervalMs = Number.isFinite(config.heartbeatIntervalMs) ? Math.max(1e3, config.heartbeatIntervalMs) : 3e4;
+  if (config2.heartbeatEnabled) {
+    await sendHeartbeat(activeClient, runtime);
+    const intervalMs = Number.isFinite(config2.heartbeatIntervalMs) ? Math.max(1e3, config2.heartbeatIntervalMs) : 3e4;
+    console.error(
+      `[memoraone-mcp] ${sessionLabel} owns heartbeat for project ${runtime.projectId} interval=${intervalMs}ms`
+    );
     heartbeatInterval = setInterval(() => {
-      sendHeartbeat(client).catch(() => {
+      sendHeartbeat(activeClient, runtime).catch(() => {
       });
     }, intervalMs);
-    globalThis.__memoraHeartbeatInterval = heartbeatInterval;
   }
-  const shutdown = (signal) => {
+  const onSigInt = () => shutdown("SIGINT");
+  const onSigTerm = () => shutdown("SIGTERM");
+  const shutdown = (signal, exitProcess = true) => {
+    process.off("SIGINT", onSigInt);
+    process.off("SIGTERM", onSigTerm);
     if (heartbeatInterval) clearInterval(heartbeatInterval);
-    if (globalThis.__memoraHeartbeatInterval) {
-      clearInterval(globalThis.__memoraHeartbeatInterval);
+    heartbeatInterval = null;
+    if (runtime.projectId) {
+      console.error(`[memoraone-mcp] ${sessionLabel} released heartbeat for project ${runtime.projectId}`);
     }
     if (devMode) {
-      console.error(`[memoraone-mcp] Received ${signal}, shutting down`);
+      console.error(`[memoraone-mcp] ${sessionLabel} received ${signal}, shutting down`);
+    }
+    if (exitProcess) {
+      process.exit(0);
     }
-    process.exit(0);
   };
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", onSigInt);
+  process.on("SIGTERM", onSigTerm);
   if (devMode) {
     console.error("[memoraone-mcp] MCP server ready");
   }
+  if (opts.sessionSocket) {
+    await new Promise((resolve6) => {
+      opts.sessionSocket.once("close", () => {
+        shutdown("session closed", false);
+        resolve6();
+      });
+    });
+  }
 }
-main().catch((err) => {
-  console.error("[memoraone-mcp] fatal error", err);
-  process.exit(1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
 });