@memoraone/mcp 0.1.14 → 0.1.16

package/dist/index.cjs

@@ -114,6 +114,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 +171,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 +194,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 +261,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(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) }),
+  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 +666,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 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(args ?? {});
-  const projectId = getCurrentProjectId();
-  if (!projectId) {
+  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 };
 }
 
@@ -326,17 +737,18 @@ function isAskWithMemoryResponse(value) {
 }
 async function handleAskWithMemory(client, args) {
   const parsed2 = askWithMemoryInputSchema.parse(args ?? {});
-  const projectId = getCurrentProjectId();
-  if (!projectId) {
+  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;
@@ -360,8 +772,8 @@ var logIntentInputSchema = import_v411.z.object({
 });
 async function handleLogIntent(client, args) {
   const parsed2 = logIntentInputSchema.parse(args ?? {});
-  const projectId = getCurrentProjectId();
-  if (!projectId) {
+  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 +793,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 +803,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 };
 }
 
@@ -410,8 +823,8 @@ var logChangeSummaryInputSchema = import_v412.z.object({
 });
 async function handleLogChangeSummary(client, args) {
   const parsed2 = logChangeSummaryInputSchema.parse(args ?? {});
-  const projectId = getCurrentProjectId();
-  if (!projectId) {
+  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 +835,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 +847,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 };
 }
 
@@ -452,8 +866,8 @@ var logToolResultInputSchema = import_v413.z.object({
 });
 async function handleLogToolResult(client, args) {
   const parsed2 = logToolResultInputSchema.parse(args ?? {});
-  const projectId = getCurrentProjectId();
-  if (!projectId) {
+  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 +878,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 +893,7 @@ async function handleLogToolResult(client, args) {
       ...stats ? { stats } : {}
     }
   };
-  await client.post("/timeline/events", body, { projectId });
+  await client.post("/timeline/events", body);
   return { ok: true };
 }
 
@@ -495,8 +910,8 @@ var logCommandInputSchema = import_v414.z.object({
 });
 async function handleLogCommand(client, args) {
   const parsed2 = logCommandInputSchema.parse(args ?? {});
-  const projectId = getCurrentProjectId();
-  if (!projectId) {
+  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 +922,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 +935,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 +948,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 };
+  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 +972,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) {
@@ -576,11 +1006,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"
@@ -615,8 +1050,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,9 +1081,7 @@ 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,
@@ -664,7 +1117,7 @@ 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);