@memoraone/mcp 0.1.14 → 0.1.17

package/dist/cli.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -22,6 +25,44 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "@memoraone/mcp",
+      version: "0.1.17",
+      type: "module",
+      main: "dist/index.cjs",
+      bin: {
+        "memoraone-mcp": "dist-bin/memoraone-mcp.cjs"
+      },
+      files: [
+        "dist",
+        "dist-bin"
+      ],
+      publishConfig: {
+        access: "public"
+      },
+      scripts: {
+        build: "tsup && node scripts/writeBinWrapper.cjs",
+        prepublishOnly: "pnpm run build",
+        dev: "tsx src/index.ts",
+        lint: "eslint ."
+      },
+      dependencies: {
+        "@modelcontextprotocol/sdk": "^1.25.1",
+        dotenv: "^16.4.5",
+        zod: "^4.0.0"
+      },
+      devDependencies: {
+        tsx: "^4.21.0",
+        tsup: "^8.5.1",
+        typescript: "^5.9.2"
+      }
+    };
+  }
+});
+
 // src/index.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
@@ -114,6 +155,40 @@ 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 parseBooleanFlag2 = (value) => {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return ["1", "true", "yes", "on"].includes(normalized);
+};
+var debugEnabled = parseBooleanFlag2(process.env.MEMORAONE_DEV_MODE);
 async function requestJson(url, method, headers, body) {
   const res = await fetch(url, {
     method,
@@ -137,9 +212,21 @@ var MemoraOneHttpError = class extends Error {
   }
 };
 var MemoraClient = class {
-  constructor(cfg) {
+  constructor(cfg, projectKey) {
+    if (!projectKey?.trim()) {
+      throw new Error("[memoraone-mcp] Invalid projectKey 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");
+    }
+    return projectKey;
   }
   buildHeaders(options) {
     return {
@@ -148,30 +235,66 @@ var MemoraClient = class {
       ...options?.headers ?? {}
     };
   }
-  async post(path2, body, options) {
-    const url = `${this.baseUrl}${path2.startsWith("/") ? path2 : `/${path2}`}`;
-    if (options?.log !== false) {
-      process.stderr.write(
-        `[memoraone-mcp] http url=${url} apiKeyPrefix=${String(this.apiKey).slice(0, 8)} apiKeyLen=${String(this.apiKey).length}
-`
+  async post(path5, body, options) {
+    console.error(
+      `[memoraone-mcp][info] MemoraClient.post ENTER path=${path5}`
+    );
+    const nonce = crypto2.randomBytes(8).toString("hex");
+    const url = `${this.baseUrl}${path5.startsWith("/") ? path5 : `/${path5}`}`;
+    this.resolveProjectKey();
+    console.error(
+      `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=POST url=${url}`
+    );
+    const res = await requestJson(url, "POST", this.buildHeaders(options), body);
+    if (debugEnabled && options?.log !== false) {
+      const snippet = res.text.length > 200 ? `${res.text.slice(0, 200)}...` : res.text;
+      console.error(
+        `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_response_log`
+      );
+      const line = `[memoraone-mcp][info] http response method=POST url=${url} status=${res.status} body=${snippet}`;
+      console.error(line);
+      console.error(
+        `[memoraone-mcp][info] requestJson nonce=${nonce} stage=after_response_log`
       );
     }
-    const res = await requestJson(url, "POST", this.buildHeaders(options), body);
     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}
+`
+      );
       throw new MemoraOneHttpError(res.status, res.statusText, res.text);
     }
+    console.error(
+      `[memoraone-mcp][info] MemoraClient.post EXIT path=${path5}`
+    );
     return res.text ? JSON.parse(res.text) : null;
   }
-  async get(path2, options) {
-    const url = `${this.baseUrl}${path2.startsWith("/") ? path2 : `/${path2}`}`;
-    if (options?.log !== false) {
-      process.stderr.write(
-        `[memoraone-mcp] http url=${url} apiKeyPrefix=${String(this.apiKey).slice(0, 8)} apiKeyLen=${String(this.apiKey).length}
-`
+  async get(path5, options) {
+    const nonce = crypto2.randomBytes(8).toString("hex");
+    const url = `${this.baseUrl}${path5.startsWith("/") ? path5 : `/${path5}`}`;
+    this.resolveProjectKey();
+    console.error(
+      `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_fetch method=GET url=${url}`
+    );
+    const res = await requestJson(url, "GET", this.buildHeaders(options));
+    if (debugEnabled && options?.log !== false) {
+      const snippet = res.text.length > 200 ? `${res.text.slice(0, 200)}...` : res.text;
+      console.error(
+        `[memoraone-mcp][info] requestJson nonce=${nonce} stage=before_response_log`
+      );
+      const line = `[memoraone-mcp][info] http response method=GET url=${url} status=${res.status} body=${snippet}`;
+      console.error(line);
+      console.error(
+        `[memoraone-mcp][info] requestJson nonce=${nonce} stage=after_response_log`
       );
     }
-    const res = await requestJson(url, "GET", this.buildHeaders(options));
     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=GET url=${url} status=${res.status} body=${snippet}
+`
+      );
       throw new MemoraOneHttpError(res.status, res.statusText, res.text);
     }
     return res.text ? JSON.parse(res.text) : null;
@@ -179,11 +302,339 @@ var MemoraClient = class {
 };
 var memoraClient_default = MemoraClient;
 
+// src/repoFingerprint.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var crypto3 = __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 crypto3.createHash("sha256").update(value).digest("hex");
+};
+var resolveGitDir = (gitPath) => {
+  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);
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+};
+var findGitRoot = (start) => {
+  let current = path2.resolve(start);
+  while (true) {
+    const gitPath = path2.join(current, ".git");
+    if (fs2.existsSync(gitPath)) {
+      const gitDir = resolveGitDir(gitPath);
+      if (gitDir) {
+        return { gitRoot: current, gitDir };
+      }
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    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();
+        }
+      }
+    }
+  } 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"
+    };
+  }
+  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(path2.resolve(gitRoot));
+  debugLog(`repo fingerprint=${fingerprint} source=path-fallback`);
+  return {
+    fingerprint,
+    gitRoot,
+    source: "path-fallback"
+  };
+}
+
+// src/workspaceMap.ts
+var fs3 = __toESM(require("fs/promises"), 1);
+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;
+  }
+  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");
+}
+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}`
+      );
+    }
+    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 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(args2) {
+  const { fingerprint, projectKey, source, linked_at } = args2;
+  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(args2) {
+  const envProjectKey = args2.envProjectKey?.trim();
+  if (envProjectKey) {
+    return { projectKey: envProjectKey, source: "env" };
+  }
+  const repoFileProjectKey = args2.repoFileProjectKey?.trim();
+  if (repoFileProjectKey) {
+    return { projectKey: repoFileProjectKey, source: "repo-file" };
+  }
+  const workspaceProjectKey = args2.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 ${args2.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) }),
+  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()
 };
@@ -256,58 +707,59 @@ var listProjectsShape = {};
 // src/tools/setProject.ts
 var import_v48 = require("zod/v4");
 var setProjectShape = {
-  projectId: import_v48.z.string().min(1)
+  projectKey: import_v48.z.string().min(1).optional(),
+  projectId: import_v48.z.string().min(1).optional()
 };
 
 // src/tools/handlers/postEvent.ts
 var import_v49 = require("zod/v4");
-
-// 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/tools/handlers/postEvent.ts
+var crypto4 = __toESM(require("crypto"), 1);
 var postEventInputSchema = import_v49.z.object({
   kind: import_v49.z.string().min(1),
-  actor: import_v49.z.object({ identifier: import_v49.z.string().min(1) }),
+  actor: import_v49.z.object({
+    identifier: import_v49.z.string().min(1),
+    id: import_v49.z.string().min(1).optional()
+  }),
   content: import_v49.z.record(import_v49.z.string(), import_v49.z.any()),
   metadata: import_v49.z.record(import_v49.z.string(), import_v49.z.any()).optional()
 });
-async function handlePostEvent(client, args) {
-  const parsed2 = postEventInputSchema.parse(args ?? {});
-  const projectId = getCurrentProjectId();
-  if (!projectId) {
+async function handlePostEvent(client, args2) {
+  const nonce = crypto4.randomBytes(8).toString("hex");
+  console.error(
+    `[memoraone-mcp][debug] tool=memora_post_event toolCallId=unknown nonce=${nonce} stage=before_post`
+  );
+  const parsed2 = postEventInputSchema.parse(args2 ?? {});
+  const projectKey = getCurrentProjectId();
+  if (!projectKey) {
     throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
   }
+  const content = parsed2.content ?? {};
+  const message = typeof content.message === "string" ? content.message : typeof content.text === "string" ? content.text : JSON.stringify(content);
   const body = {
     kind: parsed2.kind,
-    actor: { type: config.agentType, identifier: parsed2.actor.identifier },
-    content: parsed2.content,
-    metadata: {
-      source: config.source,
-      ...parsed2.metadata
-    }
+    message,
+    projectKey,
+    actor: {
+      type: "agent",
+      identifier: config.agentName,
+      ...parsed2.actor.id ? { id: parsed2.actor.id } : {}
+    },
+    ...parsed2.metadata ? { metadata: parsed2.metadata } : {}
   };
-  await client.post("/timeline/events", body, { projectId });
+  try {
+    await client.post("/timeline/events", body);
+    console.error(
+      `[memoraone-mcp][debug] tool=memora_post_event toolCallId=unknown nonce=${nonce} stage=after_post`
+    );
+  } catch (err) {
+    if (err instanceof MemoraOneHttpError) {
+      const bodyText = typeof err.body === "string" ? err.body : JSON.stringify(err.body ?? "");
+      throw new Error(
+        `memora_post_event failed: ${err.status} ${err.message} ${bodyText}`.trim()
+      );
+    }
+    throw err;
+  }
   return { ok: true, forwarded: true };
 }
 
@@ -324,19 +776,20 @@ var askWithMemoryInputSchema = import_v410.z.object({
 function isAskWithMemoryResponse(value) {
   return typeof value === "object" && value !== null && typeof value.answer === "string" && value.answer !== "";
 }
-async function handleAskWithMemory(client, args) {
-  const parsed2 = askWithMemoryInputSchema.parse(args ?? {});
-  const projectId = getCurrentProjectId();
-  if (!projectId) {
+async function handleAskWithMemory(client, args2) {
+  const parsed2 = askWithMemoryInputSchema.parse(args2 ?? {});
+  const projectKey = getCurrentProjectId();
+  if (!projectKey) {
     throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
   }
   const payload = {
-    question: parsed2.question
+    question: parsed2.question,
+    projectKey
   };
   if (parsed2.code_context) {
     payload.code_context = parsed2.code_context;
   }
-  const res = await client.post("/agent/ask-with-memory", payload, { projectId });
+  const res = await client.post("/agent/ask-with-memory", payload);
   if (!isAskWithMemoryResponse(res)) {
     const err = new Error("Unexpected response from MemoraOne");
     err.status = 502;
@@ -358,10 +811,10 @@ var logIntentInputSchema = import_v411.z.object({
   intent_source: import_v411.z.string().optional().default("cursor_chat"),
   run_id: import_v411.z.string().min(1).optional()
 });
-async function handleLogIntent(client, args) {
-  const parsed2 = logIntentInputSchema.parse(args ?? {});
-  const projectId = getCurrentProjectId();
-  if (!projectId) {
+async function handleLogIntent(client, args2) {
+  const parsed2 = logIntentInputSchema.parse(args2 ?? {});
+  const projectKey = getCurrentProjectId();
+  if (!projectKey) {
     throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
   }
   const intent = parsed2.intent;
@@ -381,6 +834,7 @@ async function handleLogIntent(client, args) {
     concept,
     // MUST be TOP-LEVEL so it populates timeline_events.concept
     message,
+    projectKey,
     metadata: {
       source: config.source,
       purpose,
@@ -390,7 +844,7 @@ async function handleLogIntent(client, args) {
       ...context ? { context } : {}
     }
   };
-  await client.post("/timeline/events", body, { projectId });
+  await client.post("/timeline/events", body);
   return { ok: true, run_id };
 }
 
@@ -408,10 +862,10 @@ var logChangeSummaryInputSchema = import_v412.z.object({
   commit: import_v412.z.string().min(1).optional(),
   run_id: import_v412.z.string().min(1).optional()
 });
-async function handleLogChangeSummary(client, args) {
-  const parsed2 = logChangeSummaryInputSchema.parse(args ?? {});
-  const projectId = getCurrentProjectId();
-  if (!projectId) {
+async function handleLogChangeSummary(client, args2) {
+  const parsed2 = logChangeSummaryInputSchema.parse(args2 ?? {});
+  const projectKey = getCurrentProjectId();
+  if (!projectKey) {
     throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
   }
   const { summary, scope, files, stats, commit } = parsed2;
@@ -422,6 +876,7 @@ async function handleLogChangeSummary(client, args) {
     concept: "concept:change_summary",
     actor: { type: config.agentType, name: config.agentName },
     message,
+    projectKey,
     metadata: {
       source: config.source,
       purpose: "change_summary",
@@ -433,7 +888,7 @@ async function handleLogChangeSummary(client, args) {
       ...run_id ? { run_id } : {}
     }
   };
-  await client.post("/timeline/events", body, { projectId });
+  await client.post("/timeline/events", body);
   return { ok: true };
 }
 
@@ -450,10 +905,10 @@ var logToolResultInputSchema = import_v413.z.object({
   error_kind: import_v413.z.enum(["infra", "logic", "auth", "rate_limit", "validation", "unknown"]).optional(),
   stats: import_v413.z.record(import_v413.z.string(), import_v413.z.any()).optional()
 });
-async function handleLogToolResult(client, args) {
-  const parsed2 = logToolResultInputSchema.parse(args ?? {});
-  const projectId = getCurrentProjectId();
-  if (!projectId) {
+async function handleLogToolResult(client, args2) {
+  const parsed2 = logToolResultInputSchema.parse(args2 ?? {});
+  const projectKey = getCurrentProjectId();
+  if (!projectKey) {
     throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
   }
   const { tool, status, summary, duration_ms, error_code, error_message, error_kind, stats } = parsed2;
@@ -464,6 +919,7 @@ async function handleLogToolResult(client, args) {
     concept: "concept:tool_result",
     actor: { type: config.agentType, name: config.agentName },
     message,
+    projectKey,
     metadata: {
       source: config.source,
       purpose: "tool_result",
@@ -478,7 +934,7 @@ async function handleLogToolResult(client, args) {
       ...stats ? { stats } : {}
     }
   };
-  await client.post("/timeline/events", body, { projectId });
+  await client.post("/timeline/events", body);
   return { ok: true };
 }
 
@@ -493,10 +949,10 @@ var logCommandInputSchema = import_v414.z.object({
   run_id: import_v414.z.string().min(1).optional(),
   stats: import_v414.z.record(import_v414.z.string(), import_v414.z.any()).optional()
 });
-async function handleLogCommand(client, args) {
-  const parsed2 = logCommandInputSchema.parse(args ?? {});
-  const projectId = getCurrentProjectId();
-  if (!projectId) {
+async function handleLogCommand(client, args2) {
+  const parsed2 = logCommandInputSchema.parse(args2 ?? {});
+  const projectKey = getCurrentProjectId();
+  if (!projectKey) {
     throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
   }
   const { cmd, summary, cwd: cwd2, exit_code, duration_ms, stats } = parsed2;
@@ -507,6 +963,7 @@ async function handleLogCommand(client, args) {
     concept: "concept:command",
     actor: { type: config.agentType, name: config.agentName },
     message,
+    projectKey,
     metadata: {
       source: config.source,
       purpose: "command",
@@ -519,7 +976,7 @@ async function handleLogCommand(client, args) {
       ...stats ? { stats } : {}
     }
   };
-  await client.post("/timeline/events", body, { projectId });
+  await client.post("/timeline/events", body);
   return { ok: true };
 }
 
@@ -532,12 +989,23 @@ async function handleListProjects(client) {
 // src/tools/handlers/setProject.ts
 var import_v415 = require("zod/v4");
 var setProjectInputSchema = import_v415.z.object({
-  projectId: import_v415.z.string().min(1)
+  projectKey: import_v415.z.string().min(1).optional(),
+  projectId: import_v415.z.string().min(1).optional()
 });
-async function handleSetProject(args) {
-  const parsed2 = setProjectInputSchema.parse(args ?? {});
-  setCurrentProjectId(parsed2.projectId);
-  return { ok: true, projectId: parsed2.projectId };
+async function handleSetProject(args2) {
+  const parsed2 = setProjectInputSchema.parse(args2 ?? {});
+  const resolvedProjectKey = parsed2.projectKey ?? parsed2.projectId;
+  if (!resolvedProjectKey) {
+    throw new Error("projectKey is required");
+  }
+  setCurrentProjectId(resolvedProjectKey);
+  const repo = resolveRepoFingerprint(process.cwd());
+  await setProjectIdForFingerprint({
+    fingerprint: repo.fingerprint,
+    projectKey: resolvedProjectKey,
+    source: "manual"
+  });
+  return { ok: true, projectKey: resolvedProjectKey };
 }
 
 // src/index.ts
@@ -545,7 +1013,10 @@ async function sendHeartbeat(client) {
   try {
     await client.post("/admin/api-keys/heartbeat", {}, { log: false });
   } catch (err) {
-    console.error("[memoraone-mcp] heartbeat error (silent)", err);
+    process.stderr.write(
+      `[memoraone-mcp][info] heartbeat error (silent) ${String(err)}
+`
+    );
   }
 }
 function redactSensitiveFields(obj) {
@@ -565,9 +1036,9 @@ function redactSensitiveFields(obj) {
   }
   return redacted;
 }
-function sanitizeArgsSummary(args) {
+function sanitizeArgsSummary(args2) {
   try {
-    const redacted = redactSensitiveFields(args);
+    const redacted = redactSensitiveFields(args2);
     const summary = JSON.stringify(redacted);
     return summary.length > 200 ? summary.slice(0, 200) + "..." : summary;
   } catch {
@@ -576,11 +1047,16 @@ function sanitizeArgsSummary(args) {
 }
 async function postWorklogEvent(client, message) {
   try {
+    const projectKey = getCurrentProjectId();
+    if (!projectKey) {
+      return;
+    }
     const body = {
       kind: "note",
       concept: "concept:worklog",
       actor: { type: config.agentType, name: config.agentName },
       message,
+      projectKey,
       metadata: {
         source: config.source,
         purpose: "worklog"
@@ -596,12 +1072,12 @@ function registerToolWithWorklog(server, client, toolName, description, schema,
     server.tool(toolName, description, schema, handler);
     return;
   }
-  server.tool(toolName, description, schema, async (args) => {
-    const argsSummary = sanitizeArgsSummary(args);
+  server.tool(toolName, description, schema, async (args2) => {
+    const argsSummary = sanitizeArgsSummary(args2);
     const start = Date.now();
     await postWorklogEvent(client, `tool_start: ${toolName} ${argsSummary}`);
     try {
-      const result = await handler(args);
+      const result = await handler(args2);
       const durationMs = Date.now() - start;
       await postWorklogEvent(client, `tool_end: ${toolName} ok (${durationMs}ms)`);
       return result;
@@ -615,8 +1091,28 @@ function registerToolWithWorklog(server, client, toolName, description, schema,
   });
 }
 async function main() {
-  const client = new memoraClient_default(config);
+  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
+  });
+  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}"`
   );
@@ -626,14 +1122,12 @@ async function main() {
   });
   const registeredToolNames = [];
   registeredToolNames.push("memora_post_event");
-  registerToolWithWorklog(
-    server,
-    client,
+  server.tool(
     "memora_post_event",
     "Forward an event to MemoraOne timeline",
     postEventShape,
-    async (args) => {
-      const result = await handlePostEvent(client, args);
+    async (args2) => {
+      const result = await handlePostEvent(client, args2);
       return {
         content: [
           {
@@ -664,10 +1158,10 @@ async function main() {
   registeredToolNames.push("memora_set_project");
   server.tool(
     "memora_set_project",
-    "Set the current project id for subsequent tool calls",
+    "Set the current project key for subsequent tool calls",
     setProjectShape,
-    async (args) => {
-      const result = await handleSetProject(args);
+    async (args2) => {
+      const result = await handleSetProject(args2);
       return {
         content: [
           {
@@ -685,8 +1179,8 @@ async function main() {
     "memora_ask_with_memory",
     "Ask MemoraOne with project memory context",
     askWithMemoryShape,
-    async (args) => {
-      const result = await handleAskWithMemory(client, args);
+    async (args2) => {
+      const result = await handleAskWithMemory(client, args2);
       return {
         content: [
           {
@@ -704,8 +1198,8 @@ async function main() {
     "memora_log_intent",
     "Log a natural-language TASK or DECISION intent to the MemoraOne timeline",
     logIntentShape,
-    async (args) => {
-      const result = await handleLogIntent(client, args);
+    async (args2) => {
+      const result = await handleLogIntent(client, args2);
       return {
         content: [
           {
@@ -723,8 +1217,8 @@ async function main() {
     "memora_log_change_summary",
     "Log a concise code change summary to the MemoraOne timeline",
     logChangeSummaryShape,
-    async (args) => {
-      const result = await handleLogChangeSummary(client, args);
+    async (args2) => {
+      const result = await handleLogChangeSummary(client, args2);
       return {
         content: [
           {
@@ -742,8 +1236,8 @@ async function main() {
     "memora_log_tool_result",
     "Log a tool execution result to the MemoraOne timeline",
     logToolResultShape,
-    async (args) => {
-      const result = await handleLogToolResult(client, args);
+    async (args2) => {
+      const result = await handleLogToolResult(client, args2);
       return {
         content: [
           {
@@ -761,8 +1255,8 @@ async function main() {
     "memora_log_command",
     "Log a command execution to the MemoraOne timeline",
     logCommandShape,
-    async (args) => {
-      const result = await handleLogCommand(client, args);
+    async (args2) => {
+      const result = await handleLogCommand(client, args2);
       return {
         content: [
           {
@@ -811,3 +1305,15 @@ main().catch((err) => {
   console.error("[memoraone-mcp] fatal error", err);
   process.exit(1);
 });
+
+// src/cli.ts
+var { version } = require_package();
+var args = process.argv.slice(2);
+if (args.includes("--version") || args.includes("-v")) {
+  console.log(version);
+  process.exit(0);
+}
+if (args.includes("--help") || args.includes("-h")) {
+  console.log("Usage: memoraone-mcp [--version] [--help]");
+  process.exit(0);
+}