@memoraone/mcp 0.1.18 → 0.1.20

package/dist/index.cjs

@@ -226,11 +226,18 @@ 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(
@@ -405,41 +412,70 @@ async function resolveAuthoritativeBinding(workspaceRoot) {
 // src/sourceRegistration.ts
 var path3 = __toESM(require("path"), 1);
 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
+    };
+  }
+  return body;
+}
 async function registerRepoSource(client, projectId, repoPath, ideType) {
-  const normalizedRepoPath = path3.resolve(repoPath);
-  const endpointPath = `/v1/projects/${projectId}/sources`;
-  console.error(
-    `[memoraone-mcp DEBUG registerRepoSource] registerRepoSource() called projectId=${projectId} repoPath(raw)=${JSON.stringify(repoPath)} repoPath(normalized)=${JSON.stringify(normalizedRepoPath)} ideType=${ideType ?? "(none)"}`
-  );
   try {
-    const body = {
-      kind: "repo",
-      label: path3.basename(normalizedRepoPath),
-      uri: (0, import_node_url.pathToFileURL)(normalizedRepoPath).href
-    };
-    if (ideType) {
-      body.metadata = {
-        ide_type: ideType
-      };
+    if (repoPath === void 0 || repoPath === null || String(repoPath).trim() === "") {
+      process.stderr.write(
+        `${LOG_PREFIX} skipped: empty repoPath (cannot register workspace)
+`
+      );
+      return;
     }
-    console.error(
-      `[memoraone-mcp DEBUG registerRepoSource] POST endpoint=${endpointPath} body=${JSON.stringify(body)}`
-    );
-    const result = await client.post(endpointPath, body);
-    console.error(
-      `[memoraone-mcp DEBUG registerRepoSource] POST succeeded endpoint=${endpointPath} responseSummary=${JSON.stringify(result)}`
+    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;
+      }
+      throw err;
+    }
   } catch (err) {
-    console.error(
-      `[memoraone-mcp DEBUG registerRepoSource] POST threw endpoint=${endpointPath} message=${String(err?.message ?? 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);
-      console.error(
-        `[memoraone-mcp DEBUG registerRepoSource] MemoraOneHttpError status=${err.status} body=${bodyStr}`
+      process.stderr.write(
+        `${LOG_PREFIX} http status=${err.status} body=${bodyStr.length > 500 ? bodyStr.slice(0, 500) + "..." : bodyStr}
+`
       );
     }
-    console.warn("[memoraone-mcp] registerRepoSource failed:", err);
   }
 }
 
@@ -455,80 +491,106 @@ var postEventShape = {
   metadata: import_v42.z.record(import_v42.z.string(), import_v42.z.any()).optional()
 };
 
-// src/tools/askWithMemory.ts
+// src/tools/createFact.ts
 var import_v43 = require("zod/v4");
+var createFactShape = {
+  content: import_v43.z.string().min(1).describe("Explicit fact text to persist for the current project"),
+  metadata: import_v43.z.record(import_v43.z.string(), import_v43.z.any()).optional()
+};
+
+// src/tools/addPersonalContext.ts
+var import_v44 = require("zod/v4");
+var addPersonalContextShape = {
+  content: import_v44.z.string().min(1).describe("Text to store (note, preference, or similar)"),
+  category: import_v44.z.string().optional().describe("Optional category label"),
+  tags: import_v44.z.array(import_v44.z.string()).optional().describe("Optional tags"),
+  scope_type: import_v44.z.enum(["general", "project"]).optional(),
+  scope_id: import_v44.z.string().optional()
+};
+
+// src/tools/getPersonalContext.ts
+var import_v45 = require("zod/v4");
+var getPersonalContextShape = {
+  query: import_v45.z.string().optional().describe("Search query; sent as q when set"),
+  scope_type: import_v45.z.enum(["general", "project"]).optional(),
+  scope_id: import_v45.z.string().optional(),
+  limit: import_v45.z.number().int().positive().optional().describe("Max items to return")
+};
+
+// src/tools/askWithMemory.ts
+var import_v46 = require("zod/v4");
 var askWithMemoryShape = {
-  question: import_v43.z.string().min(1),
-  code_context: import_v43.z.object({
-    file_path: import_v43.z.string().optional(),
-    selected_text: import_v43.z.string().optional(),
-    language: import_v43.z.string().optional()
+  question: import_v46.z.string().min(1),
+  code_context: import_v46.z.object({
+    file_path: import_v46.z.string().optional(),
+    selected_text: import_v46.z.string().optional(),
+    language: import_v46.z.string().optional()
   }).optional()
 };
 
 // src/tools/logIntent.ts
-var import_v44 = require("zod/v4");
+var import_v47 = require("zod/v4");
 var logIntentShape = {
-  intent: import_v44.z.enum(["task", "decision"]),
-  message: import_v44.z.string().min(1),
-  context: import_v44.z.record(import_v44.z.string(), import_v44.z.any()).optional(),
-  intent_source: import_v44.z.string().optional().default("cursor_chat"),
-  run_id: import_v44.z.string().min(1).optional()
+  intent: import_v47.z.enum(["task", "decision"]),
+  message: import_v47.z.string().min(1),
+  context: import_v47.z.record(import_v47.z.string(), import_v47.z.any()).optional(),
+  intent_source: import_v47.z.string().optional().default("cursor_chat"),
+  run_id: import_v47.z.string().min(1).optional()
 };
 
 // src/tools/logChangeSummary.ts
-var import_v45 = require("zod/v4");
+var import_v48 = require("zod/v4");
 var logChangeSummaryShape = {
-  summary: import_v45.z.string().min(1),
-  scope: import_v45.z.string().min(1).optional(),
-  files: import_v45.z.array(import_v45.z.string().min(1)).optional(),
-  stats: import_v45.z.object({
-    files: import_v45.z.number().int().nonnegative().optional(),
-    add: import_v45.z.number().int().nonnegative().optional(),
-    del: import_v45.z.number().int().nonnegative().optional()
+  summary: import_v48.z.string().min(1),
+  scope: import_v48.z.string().min(1).optional(),
+  files: import_v48.z.array(import_v48.z.string().min(1)).optional(),
+  stats: import_v48.z.object({
+    files: import_v48.z.number().int().nonnegative().optional(),
+    add: import_v48.z.number().int().nonnegative().optional(),
+    del: import_v48.z.number().int().nonnegative().optional()
   }).optional(),
-  commit: import_v45.z.string().min(1).optional(),
-  run_id: import_v45.z.string().min(1).optional()
+  commit: import_v48.z.string().min(1).optional(),
+  run_id: import_v48.z.string().min(1).optional()
 };
 
 // src/tools/logToolResult.ts
-var import_v46 = require("zod/v4");
+var import_v49 = require("zod/v4");
 var logToolResultShape = {
-  tool: import_v46.z.string().min(1),
-  status: import_v46.z.enum(["ok", "error", "partial"]),
-  summary: import_v46.z.string().min(1),
-  run_id: import_v46.z.string().min(1).optional(),
-  duration_ms: import_v46.z.number().int().nonnegative().optional(),
-  error_code: import_v46.z.string().min(1).optional(),
-  error_message: import_v46.z.string().min(1).optional(),
-  error_kind: import_v46.z.enum(["infra", "logic", "auth", "rate_limit", "validation", "unknown"]).optional(),
-  stats: import_v46.z.record(import_v46.z.string(), import_v46.z.any()).optional()
+  tool: import_v49.z.string().min(1),
+  status: import_v49.z.enum(["ok", "error", "partial"]),
+  summary: import_v49.z.string().min(1),
+  run_id: import_v49.z.string().min(1).optional(),
+  duration_ms: import_v49.z.number().int().nonnegative().optional(),
+  error_code: import_v49.z.string().min(1).optional(),
+  error_message: import_v49.z.string().min(1).optional(),
+  error_kind: import_v49.z.enum(["infra", "logic", "auth", "rate_limit", "validation", "unknown"]).optional(),
+  stats: import_v49.z.record(import_v49.z.string(), import_v49.z.any()).optional()
 };
 
 // src/tools/logCommand.ts
-var import_v47 = require("zod/v4");
+var import_v410 = require("zod/v4");
 var logCommandShape = {
-  cmd: import_v47.z.string().min(1),
-  summary: import_v47.z.string().min(1),
-  cwd: import_v47.z.string().min(1).optional(),
-  exit_code: import_v47.z.number().int().optional(),
-  duration_ms: import_v47.z.number().int().nonnegative().optional(),
-  run_id: import_v47.z.string().min(1).optional(),
-  stats: import_v47.z.record(import_v47.z.string(), import_v47.z.any()).optional()
+  cmd: import_v410.z.string().min(1),
+  summary: import_v410.z.string().min(1),
+  cwd: import_v410.z.string().min(1).optional(),
+  exit_code: import_v410.z.number().int().optional(),
+  duration_ms: import_v410.z.number().int().nonnegative().optional(),
+  run_id: import_v410.z.string().min(1).optional(),
+  stats: import_v410.z.record(import_v410.z.string(), import_v410.z.any()).optional()
 };
 
 // src/tools/listProjects.ts
 var listProjectsShape = {};
 
 // src/tools/setProject.ts
-var import_v48 = require("zod/v4");
+var import_v411 = require("zod/v4");
 var setProjectShape = {
-  projectKey: import_v48.z.string().min(1).optional(),
-  projectId: import_v48.z.string().min(1).optional()
+  projectKey: import_v411.z.string().min(1).optional(),
+  projectId: import_v411.z.string().min(1).optional()
 };
 
 // src/tools/handlers/postEvent.ts
-var import_v49 = require("zod/v4");
+var import_v412 = require("zod/v4");
 var crypto3 = __toESM(require("crypto"), 1);
 
 // src/runContext.ts
@@ -590,14 +652,14 @@ function generateRunId() {
 }
 
 // src/tools/handlers/postEvent.ts
-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),
-    id: import_v49.z.string().min(1).optional()
+var postEventInputSchema = import_v412.z.object({
+  kind: import_v412.z.string().min(1),
+  actor: import_v412.z.object({
+    identifier: import_v412.z.string().min(1),
+    id: import_v412.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()
+  content: import_v412.z.record(import_v412.z.string(), import_v412.z.any()),
+  metadata: import_v412.z.record(import_v412.z.string(), import_v412.z.any()).optional()
 });
 async function handlePostEvent(client, args) {
   const nonce = crypto3.randomBytes(8).toString("hex");
@@ -639,14 +701,144 @@ async function handlePostEvent(client, args) {
   return { ok: true, forwarded: true };
 }
 
+// src/tools/handlers/createFact.ts
+var import_v413 = require("zod/v4");
+var createFactInputSchema = import_v413.z.object({
+  content: import_v413.z.string().min(1),
+  metadata: import_v413.z.record(import_v413.z.string(), import_v413.z.any()).optional()
+});
+async function handleCreateFact(client, args) {
+  const parsed2 = createFactInputSchema.parse(args ?? {});
+  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.trim();
+  if (!content) {
+    throw new Error("content cannot be empty after trimming");
+  }
+  const { tags: userTagsRaw, ...userMetaRest } = parsed2.metadata ?? {};
+  const userTags = Array.isArray(userTagsRaw) ? userTagsRaw.filter((t) => typeof t === "string") : [];
+  const tags = ["explicit_fact", ...userTags.filter((t) => t !== "explicit_fact")];
+  const body = {
+    projectKey,
+    content,
+    metadata: {
+      ...userMetaRest,
+      source: "memoraone-mcp",
+      purpose: "explicit_fact",
+      schema: "v1",
+      tool: "memora_create_fact",
+      agent_identifier: config2.agentName,
+      tags
+    }
+  };
+  try {
+    const result = await client.post("/facts", body);
+    return { ok: true, result };
+  } catch (err) {
+    if (err instanceof MemoraOneHttpError) {
+      const bodyText = typeof err.body === "string" ? err.body : JSON.stringify(err.body ?? "");
+      throw new Error(
+        `memora_create_fact failed: ${err.status} ${err.message} ${bodyText}`.trim()
+      );
+    }
+    throw err;
+  }
+}
+
+// src/tools/handlers/addPersonalContext.ts
+var import_v414 = require("zod/v4");
+var addPersonalContextInputSchema = import_v414.z.object({
+  content: import_v414.z.string().min(1),
+  category: import_v414.z.string().optional(),
+  tags: import_v414.z.array(import_v414.z.string()).optional(),
+  scope_type: import_v414.z.enum(["general", "project"]).optional(),
+  scope_id: import_v414.z.string().optional()
+});
+async function handleAddPersonalContext(client, args) {
+  const parsed2 = addPersonalContextInputSchema.parse(args ?? {});
+  const content = parsed2.content.trim();
+  if (!content) {
+    throw new Error("content cannot be empty after trimming");
+  }
+  const body = { content };
+  if (parsed2.category !== void 0 && parsed2.category.trim() !== "") {
+    body.category = parsed2.category.trim();
+  }
+  if (parsed2.tags !== void 0 && parsed2.tags.length > 0) {
+    body.tags = parsed2.tags;
+  }
+  if (parsed2.scope_type !== void 0) {
+    body.scope_type = parsed2.scope_type;
+  }
+  if (parsed2.scope_id !== void 0 && parsed2.scope_id.trim() !== "") {
+    body.scope_id = parsed2.scope_id.trim();
+  }
+  try {
+    const result = await client.post("/v1/personal-context", body);
+    return { ok: true, result };
+  } catch (err) {
+    if (err instanceof MemoraOneHttpError) {
+      const bodyText = typeof err.body === "string" ? err.body : JSON.stringify(err.body ?? "");
+      throw new Error(
+        `memora_add_personal_context failed: ${err.status} ${err.message} ${bodyText}`.trim()
+      );
+    }
+    throw err;
+  }
+}
+
+// src/tools/handlers/getPersonalContext.ts
+var import_v415 = require("zod/v4");
+var getPersonalContextInputSchema = import_v415.z.object({
+  query: import_v415.z.string().optional(),
+  scope_type: import_v415.z.enum(["general", "project"]).optional(),
+  scope_id: import_v415.z.string().optional(),
+  limit: import_v415.z.number().int().positive().optional()
+});
+function buildPersonalContextPath(parsed2) {
+  const params = new URLSearchParams();
+  if (parsed2.query !== void 0 && parsed2.query.trim() !== "") {
+    params.set("q", parsed2.query.trim());
+  }
+  if (parsed2.scope_type !== void 0) {
+    params.set("scope_type", parsed2.scope_type);
+  }
+  if (parsed2.scope_id !== void 0 && parsed2.scope_id.trim() !== "") {
+    params.set("scope_id", parsed2.scope_id.trim());
+  }
+  if (parsed2.limit !== void 0) {
+    params.set("limit", String(parsed2.limit));
+  }
+  const qs = params.toString();
+  return qs ? `/v1/personal-context?${qs}` : "/v1/personal-context";
+}
+async function handleGetPersonalContext(client, args) {
+  const parsed2 = getPersonalContextInputSchema.parse(args ?? {});
+  const path7 = buildPersonalContextPath(parsed2);
+  try {
+    const result = await client.get(path7);
+    return { ok: true, result };
+  } catch (err) {
+    if (err instanceof MemoraOneHttpError) {
+      const bodyText = typeof err.body === "string" ? err.body : JSON.stringify(err.body ?? "");
+      throw new Error(
+        `memora_get_personal_context failed: ${err.status} ${err.message} ${bodyText}`.trim()
+      );
+    }
+    throw err;
+  }
+}
+
 // src/tools/handlers/askWithMemory.ts
-var import_v410 = require("zod/v4");
-var askWithMemoryInputSchema = import_v410.z.object({
-  question: import_v410.z.string().min(1),
-  code_context: import_v410.z.object({
-    file_path: import_v410.z.string().optional(),
-    selected_text: import_v410.z.string().optional(),
-    language: import_v410.z.string().optional()
+var import_v416 = require("zod/v4");
+var askWithMemoryInputSchema = import_v416.z.object({
+  question: import_v416.z.string().min(1),
+  code_context: import_v416.z.object({
+    file_path: import_v416.z.string().optional(),
+    selected_text: import_v416.z.string().optional(),
+    language: import_v416.z.string().optional()
   }).optional()
 });
 function isAskWithMemoryResponse(value) {
@@ -679,13 +871,13 @@ async function handleAskWithMemory(client, args) {
 }
 
 // src/tools/handlers/logIntent.ts
-var import_v411 = require("zod/v4");
-var logIntentInputSchema = import_v411.z.object({
-  intent: import_v411.z.enum(["task", "decision"]),
-  message: import_v411.z.string().min(1),
-  context: import_v411.z.record(import_v411.z.string(), import_v411.z.any()).optional(),
-  intent_source: import_v411.z.string().optional().default("cursor_chat"),
-  run_id: import_v411.z.string().min(1).optional()
+var import_v417 = require("zod/v4");
+var logIntentInputSchema = import_v417.z.object({
+  intent: import_v417.z.enum(["task", "decision"]),
+  message: import_v417.z.string().min(1),
+  context: import_v417.z.record(import_v417.z.string(), import_v417.z.any()).optional(),
+  intent_source: import_v417.z.string().optional().default("cursor_chat"),
+  run_id: import_v417.z.string().min(1).optional()
 });
 async function handleLogIntent(client, args) {
   const parsed2 = logIntentInputSchema.parse(args ?? {});
@@ -725,18 +917,18 @@ async function handleLogIntent(client, args) {
 }
 
 // src/tools/handlers/logChangeSummary.ts
-var import_v412 = require("zod/v4");
-var logChangeSummaryInputSchema = import_v412.z.object({
-  summary: import_v412.z.string().min(1),
-  scope: import_v412.z.string().min(1).optional(),
-  files: import_v412.z.array(import_v412.z.string().min(1)).optional(),
-  stats: import_v412.z.object({
-    files: import_v412.z.number().int().nonnegative().optional(),
-    add: import_v412.z.number().int().nonnegative().optional(),
-    del: import_v412.z.number().int().nonnegative().optional()
+var import_v418 = require("zod/v4");
+var logChangeSummaryInputSchema = import_v418.z.object({
+  summary: import_v418.z.string().min(1),
+  scope: import_v418.z.string().min(1).optional(),
+  files: import_v418.z.array(import_v418.z.string().min(1)).optional(),
+  stats: import_v418.z.object({
+    files: import_v418.z.number().int().nonnegative().optional(),
+    add: import_v418.z.number().int().nonnegative().optional(),
+    del: import_v418.z.number().int().nonnegative().optional()
   }).optional(),
-  commit: import_v412.z.string().min(1).optional(),
-  run_id: import_v412.z.string().min(1).optional()
+  commit: import_v418.z.string().min(1).optional(),
+  run_id: import_v418.z.string().min(1).optional()
 });
 async function handleLogChangeSummary(client, args) {
   const parsed2 = logChangeSummaryInputSchema.parse(args ?? {});
@@ -769,17 +961,17 @@ async function handleLogChangeSummary(client, args) {
 }
 
 // src/tools/handlers/logToolResult.ts
-var import_v413 = require("zod/v4");
-var logToolResultInputSchema = import_v413.z.object({
-  tool: import_v413.z.string().min(1),
-  status: import_v413.z.enum(["ok", "error", "partial"]),
-  summary: import_v413.z.string().min(1),
-  run_id: import_v413.z.string().min(1).optional(),
-  duration_ms: import_v413.z.number().int().nonnegative().optional(),
-  error_code: import_v413.z.string().min(1).optional(),
-  error_message: import_v413.z.string().min(1).optional(),
-  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()
+var import_v419 = require("zod/v4");
+var logToolResultInputSchema = import_v419.z.object({
+  tool: import_v419.z.string().min(1),
+  status: import_v419.z.enum(["ok", "error", "partial"]),
+  summary: import_v419.z.string().min(1),
+  run_id: import_v419.z.string().min(1).optional(),
+  duration_ms: import_v419.z.number().int().nonnegative().optional(),
+  error_code: import_v419.z.string().min(1).optional(),
+  error_message: import_v419.z.string().min(1).optional(),
+  error_kind: import_v419.z.enum(["infra", "logic", "auth", "rate_limit", "validation", "unknown"]).optional(),
+  stats: import_v419.z.record(import_v419.z.string(), import_v419.z.any()).optional()
 });
 async function handleLogToolResult(client, args) {
   const parsed2 = logToolResultInputSchema.parse(args ?? {});
@@ -815,15 +1007,15 @@ async function handleLogToolResult(client, args) {
 }
 
 // src/tools/handlers/logCommand.ts
-var import_v414 = require("zod/v4");
-var logCommandInputSchema = import_v414.z.object({
-  cmd: import_v414.z.string().min(1),
-  summary: import_v414.z.string().min(1),
-  cwd: import_v414.z.string().min(1).optional(),
-  exit_code: import_v414.z.number().int().optional(),
-  duration_ms: import_v414.z.number().int().nonnegative().optional(),
-  run_id: import_v414.z.string().min(1).optional(),
-  stats: import_v414.z.record(import_v414.z.string(), import_v414.z.any()).optional()
+var import_v420 = require("zod/v4");
+var logCommandInputSchema = import_v420.z.object({
+  cmd: import_v420.z.string().min(1),
+  summary: import_v420.z.string().min(1),
+  cwd: import_v420.z.string().min(1).optional(),
+  exit_code: import_v420.z.number().int().optional(),
+  duration_ms: import_v420.z.number().int().nonnegative().optional(),
+  run_id: import_v420.z.string().min(1).optional(),
+  stats: import_v420.z.record(import_v420.z.string(), import_v420.z.any()).optional()
 });
 async function handleLogCommand(client, args) {
   const parsed2 = logCommandInputSchema.parse(args ?? {});
@@ -863,7 +1055,7 @@ async function handleListProjects(client) {
 }
 
 // src/tools/handlers/setProject.ts
-var import_v415 = require("zod/v4");
+var import_v421 = require("zod/v4");
 
 // src/repoFingerprint.ts
 var fs3 = __toESM(require("fs"), 1);
@@ -1023,6 +1215,7 @@ async function acquireWorkspaceMapLock() {
   const maxRetries = 10;
   const retryDelayMs = 50;
   const maxLockAgeMs = 5e3;
+  await ensureWorkspaceDir();
   let lockAcquired = false;
   let retries = 0;
   while (!lockAcquired && retries < maxRetries) {
@@ -1191,9 +1384,9 @@ async function setProjectIdForFingerprint(args) {
 }
 
 // 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()
+var setProjectInputSchema = import_v421.z.object({
+  projectKey: import_v421.z.string().min(1).optional(),
+  projectId: import_v421.z.string().min(1).optional()
 });
 async function handleSetProject(args) {
   const parsed2 = setProjectInputSchema.parse(args ?? {});
@@ -1461,6 +1654,45 @@ async function main(opts = {}) {
     })
   );
   registeredToolNames.push("memora_post_event");
+  server.tool(
+    "memora_create_fact",
+    "Create an explicit project-scoped fact (POST /facts)",
+    createFactShape,
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handleCreateFact(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    })
+  );
+  registeredToolNames.push("memora_create_fact");
+  server.tool(
+    "memora_add_personal_context",
+    "Store notes or preferences for this workspace (POST /v1/personal-context)",
+    addPersonalContextShape,
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handleAddPersonalContext(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    })
+  );
+  registeredToolNames.push("memora_add_personal_context");
+  server.tool(
+    "memora_get_personal_context",
+    "Search stored notes or preferences for this workspace (GET /v1/personal-context)",
+    getPersonalContextShape,
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handleGetPersonalContext(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    })
+  );
+  registeredToolNames.push("memora_get_personal_context");
   server.tool(
     "memora_list_projects",
     "List projects available to the current API key",
@@ -1492,7 +1724,7 @@ async function main(opts = {}) {
     runtime,
     sessionContext,
     "memora_ask_with_memory",
-    "Ask MemoraOne with project memory context",
+    "Answer using saved workspace knowledge and timeline. In user-visible replies, state facts directly; do not attribute answers to tools, storage, retrieval, or memory-style framing unless the user asks how you know.",
     askWithMemoryShape,
     async (args) => {
       const result = await handleAskWithMemory(runtime.client, args);
@@ -1639,10 +1871,16 @@ async function main(opts = {}) {
         runtime.apiKeyFingerprint = fingerprintApiKey(apiKeyToUse);
         runtime.client = new memoraClient_default(config2, projectId, apiKeyToUse);
         workspaceRoot = binding.workspaceRoot;
-        console.error(
-          `[memoraone-mcp DEBUG registerRepoSource] pre-register bindingSource=${binding.bindingSource} workspaceRoot=${JSON.stringify(binding.workspaceRoot)} m1Path=${JSON.stringify(binding.m1Path)} ideType=${runtime.ideType ?? "(none)"}`
+        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
         );
-        await registerRepoSource(runtime.client, runtime.projectId, workspaceRoot, runtime.ideType);
         if (debugAuth) {
           console.error("[memoraone-mcp][auth] repo root:", binding.workspaceRoot);
           console.error("[memoraone-mcp][auth] project_id:", projectId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoraone/mcp",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "type": "module",
   "main": "dist/index.cjs",
   "bin": {