@lotargo/memory_plugin 1.5.3 → 1.6.1

package/mcp-server/preinstall.js

@@ -5,6 +5,27 @@ if (process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.DEBIAN_F
   process.exit(0);
 }
 
+// ── Node version warning ────────────────────────────────────────────────────
+// engines.node >= 22.5.0 is set in package.json but npm only warns by default.
+// Print a loud, actionable message so the user notices before the server crashes.
+{
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  if (major < 22 || (major === 22 && minor < 5)) {
+    console.error(
+      `\n` +
+      `  ⚠️  @lotargo/memory_plugin requires Node.js >= 22.5.0\n` +
+      `     Detected: Node.js ${process.versions.node}\n` +
+      `\n` +
+      `     The built-in node:sqlite module used by this plugin was\n` +
+      `     introduced in Node.js 22.5.0.  The server WILL NOT START\n` +
+      `     on your current version.\n` +
+      `\n` +
+      `     Please upgrade:  nvm install 22   (or: brew install node@22)\n`
+    );
+  }
+}
+
+
 // Only run graceful process termination during explicit global npm updates
 if (process.env.npm_config_global === "true" || process.env.MEMORY_PREINSTALL_FORCE === "true") {
   try {
@@ -13,7 +34,7 @@ if (process.env.npm_config_global === "true" || process.env.MEMORY_PREINSTALL_FO
 
     if (process.platform === "win32") {
       try {
-        const psCmd = `Get-CimInstance Win32_Process | Where-Object { ($_.CommandLine -like '*mcp-server/index.js*' -or $_.CommandLine -like '*mcp-server\\\\index.js*') -and $_.CommandLine -notlike '*install*' -and $_.ProcessId -ne ${currentPid} -and $_.ProcessId -ne ${ppid} } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force }`;
+        const psCmd = `Get-CimInstance Win32_Process | Where-Object { ($_.CommandLine -like '*mcp-server/boot.js*' -or $_.CommandLine -like '*mcp-server\\\\boot.js*' -or $_.CommandLine -like '*mcp-server/index.js*' -or $_.CommandLine -like '*mcp-server\\\\index.js*') -and $_.CommandLine -notlike '*install*' -and $_.ProcessId -ne ${currentPid} -and $_.ProcessId -ne ${ppid} } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force }`;
         execSync(`powershell -NoProfile -NonInteractive -Command "${psCmd}"`, { stdio: "ignore" });
       } catch {}
     } else {
@@ -30,7 +51,7 @@ if (process.env.npm_config_global === "true" || process.env.MEMORY_PREINSTALL_FO
 
           if (!pid || pid === currentPid || pid === ppid || parentPid === currentPid) continue;
 
-          const isServer = cmd.includes("mcp-server/index.js") || cmd.includes("mcp-server/index.js");
+          const isServer = cmd.includes("mcp-server/boot.js") || cmd.includes("mcp-server/index.js");
           const isInstaller = /npm|npx|yarn|pnpm|preinstall|install/i.test(cmd);
 
           if (isServer && !isInstaller) {

package/mcp-server/retrieval/retriever.js

@@ -1,6 +1,5 @@
 import { getDatabase } from "../db/database.js";
 import { embedText, cosineSimilarity, rerankHits } from "../ml/model_manager.js";
-import { getRelatedSymbols } from "../graph/graph_extractor.js";
 import { getConfig } from "../config/config_manager.js";
 
 export function sanitizeFtsQuery(query) {
@@ -37,6 +36,20 @@ export async function bm25Search(db, query, limit = 30) {
   }
 }
 
+// Normalize whatever the active driver hands back for a BLOB column into a
+// Uint8Array view. node:sqlite -> Uint8Array, Turso/libsql -> base64 string or
+// a serialized {type:"Buffer",data:[...]} object, better-sqlite3 -> Buffer.
+export function toVectorBytes(value) {
+  if (value === null || value === undefined) return null;
+  if (typeof value === "string") return new Uint8Array(Buffer.from(value, "base64"));
+  if (value instanceof Uint8Array) return value; // covers Buffer too
+  if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (value.type === "Buffer" && Array.isArray(value.data)) return new Uint8Array(value.data);
+  if (Array.isArray(value)) return new Uint8Array(value);
+  return null;
+}
+
 export async function vectorSearch(db, queryVector, limit = 30, minSim = 0.25) {
   if (!queryVector || queryVector.length === 0) return [];
 
@@ -45,23 +58,30 @@ export async function vectorSearch(db, queryVector, limit = 30, minSim = 0.25) {
   const tempView = new Uint8Array(tempBuf);
   const tempVec = new Float32Array(tempBuf);
 
-  const stmt = db.prepare(`
-    SELECT m.id, m.section_id, m.doc_id, m.content, m.vector, s.breadcrumbs
-    FROM micro_chunks m
-    JOIN sections s ON m.section_id = s.id;
-  `);
+  const scanLimit = Number(getConfig().vectorScanLimit) || 0;
+  const scanSql = scanLimit > 0
+    ? `
+      SELECT m.id, m.section_id, m.doc_id, m.content, m.vector, s.breadcrumbs
+      FROM micro_chunks m
+      JOIN sections s ON m.section_id = s.id
+      LIMIT ?;
+    `
+    : `
+      SELECT m.id, m.section_id, m.doc_id, m.content, m.vector, s.breadcrumbs
+      FROM micro_chunks m
+      JOIN sections s ON m.section_id = s.id;
+    `;
 
+  const stmt = db.prepare(scanSql);
+  const rows = scanLimit > 0 ? await stmt.all(scanLimit) : await stmt.all();
   const scored = [];
-  const rows = await stmt.all();
   for (const r of rows) {
-    let vecSub = r.vector;
-    if (typeof vecSub === "string") {
-      vecSub = Buffer.from(vecSub, "base64");
-    } else if (vecSub.type === "Buffer" && Array.isArray(vecSub.data)) {
-      vecSub = Buffer.from(vecSub.data);
-    } else if (Array.isArray(vecSub)) {
-      vecSub = Buffer.from(vecSub);
-    }
+    // node:sqlite returns BLOBs as plain Uint8Array (NOT Buffer), the Turso
+    // client may return base64 strings or {type:"Buffer",data:[...]}.
+    // A Buffer.isBuffer() gate here silently dropped every local row and made
+    // vector search return zero hits.
+    const vecSub = toVectorBytes(r.vector);
+    if (!vecSub || vecSub.byteLength !== vectorDim * 4) continue;
     tempView.set(vecSub.subarray(0, vectorDim * 4));
 
     const sim = cosineSimilarity(queryVector, tempVec);

package/mcp-server/security/path_guard.js

@@ -0,0 +1,67 @@
+import { realpathSync, existsSync } from "node:fs";
+import { resolve, dirname, sep } from "node:path";
+import { getConfig } from "../config/config_manager.js";
+import { MEMORY_DIR } from "../memory.js";
+
+// Resolve a path to its real location, following symlinks/junctions.
+// Falls back to the nearest existing ancestor when the target does not exist yet
+// (needed for export targets that are about to be created).
+export function realResolve(pathStr) {
+  const abs = resolve(String(pathStr || "").trim());
+  try {
+    return realpathSync(abs);
+  } catch {
+    let parent = dirname(abs);
+    const seen = new Set();
+    while (parent && !seen.has(parent)) {
+      seen.add(parent);
+      if (existsSync(parent)) {
+        try {
+          return resolve(realpathSync(parent), abs.slice(parent.length + 1));
+        } catch {
+          break;
+        }
+      }
+      const next = dirname(parent);
+      if (next === parent) break;
+      parent = next;
+    }
+    return abs;
+  }
+}
+
+export function isWithin(resolvedPath, dir) {
+  const root = realResolve(dir);
+  return resolvedPath === root || resolvedPath.startsWith(root + sep);
+}
+
+// Roots the ingest pipeline is allowed to read from.
+// Defaults to the current working directory (the project the agent is working in)
+// plus the plugin's own data directory. Extendable via config.ingestAllowedPaths.
+export function getIngestAllowedRoots() {
+  const config = getConfig();
+  const roots = [process.cwd(), MEMORY_DIR];
+  if (Array.isArray(config.ingestAllowedPaths)) {
+    for (const p of config.ingestAllowedPaths) {
+      if (typeof p === "string" && p.trim()) roots.push(p.trim());
+    }
+  }
+  return [...new Set(roots.map((r) => realResolve(r)))];
+}
+
+// Guard against arbitrary file reads (~/.ssh/id_rsa, .env, /etc/passwd) reaching
+// the RAG store — and, in hybrid-sync mode, the cloud.
+export function assertIngestPathAllowed(pathStr) {
+  const resolved = realResolve(pathStr);
+  const config = getConfig();
+  if (config.ingestAllowAnyPath === true) return resolved;
+
+  const roots = getIngestAllowedRoots();
+  if (roots.some((root) => isWithin(resolved, root))) return resolved;
+
+  throw new Error(
+    `Ingestion blocked: '${pathStr}' is outside the allowed directories ` +
+      `(${roots.join(", ")}). Add the directory to config.ingestAllowedPaths ` +
+      `or set config.ingestAllowAnyPath = true to override.`
+  );
+}

package/mcp-server/setup.js

@@ -28,10 +28,18 @@ export async function runSetup() {
   let configuredCount = 0;
 
   // 0. Headless cloud authentication (Google Jules / CI / VPS)
-  if (apiKeyArg) {
+  if (apiKeyArg || process.env.TURSO_API_TOKEN) {
     try {
+      const { resolveSecret } = await import("./cli/secret_input.js");
+      const apiKey = await resolveSecret({
+        argvValue: apiKeyArg,
+        envKeys: ["TURSO_API_TOKEN"],
+        promptLabel: "Turso API token",
+        interactive: false,
+      });
+      if (!apiKey) throw new Error("Missing API token. Set TURSO_API_TOKEN or pass --api-key <TOKEN>.");
       const { loginWithApiToken } = await import("./admin/auth.js");
-      const secrets = await loginWithApiToken({ token: apiKeyArg });
+      const secrets = await loginWithApiToken({ token: apiKey });
       if (modeArg && VALID_MODES.includes(modeArg)) {
         const { updateConfig } = await import("./config/config_manager.js");
         updateConfig({ mode: modeArg });

package/mcp-server/storage/blob_store.js

@@ -1,10 +1,23 @@
 import { createHash } from "node:crypto";
 import { gzipSync, gunzipSync } from "node:zlib";
-import { readFile, writeFile, mkdir, unlink, access } from "node:fs/promises";
+import { readFile, writeFile, mkdir, unlink } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { BLOBS_DIR } from "../db/database.js";
 
+// Hard cap on gunzip output to prevent zip-bomb style memory exhaustion.
+export const MAX_UNPACKED_BYTES = 512 * 1024 * 1024;
+
+export function safeGunzip(compressed, maxBytes = MAX_UNPACKED_BYTES) {
+  const decompressed = gunzipSync(compressed, { maxOutputLength: maxBytes });
+  if (decompressed.length > maxBytes) {
+    throw new Error(
+      `Decompressed payload of ${decompressed.length} bytes exceeds the ${maxBytes} byte limit.`
+    );
+  }
+  return decompressed;
+}
+
 export function hashContent(data) {
   const hash = createHash("sha256");
   hash.update(data);
@@ -48,7 +61,7 @@ export async function readBlob(hash, baseDir = BLOBS_DIR) {
   }
 
   const compressed = await readFile(blobPath);
-  const decompressed = gunzipSync(compressed);
+  const decompressed = safeGunzip(compressed);
   return decompressed.toString("utf-8");
 }
 

package/mcp-server/tools/core/memory_core.js

@@ -0,0 +1,393 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import {
+  readMemory,
+  readMemoryRaw,
+  writeMemory,
+  today,
+  MEMORY_DIR,
+  GLOBAL_KEY,
+  scopeKey,
+  projectKey,
+  projectName,
+  canonicalPath,
+  listProjectStores,
+  storeFilePath,
+} from "../../memory.js";
+import {
+  parseFactEntry,
+  factText,
+  factMeta,
+  withMeta,
+  nextFactId,
+  isKeepFact,
+  isExpiredLine,
+  isSuperseded,
+  formatFactEntry,
+  matchesQuery,
+  matchesTags,
+  inDateRange,
+  factTitle,
+  factBody,
+  autoGenerateTitle,
+} from "../../fact_format.js";
+import { requireProjectKey, resolveFactIndex } from "../helpers.js";
+
+// Single implementation of the Notebook tools, shared by the MCP server
+// (mcp-server/tools/memory_tools.js) and the OpenCode plugin
+// (opencode-plugin/index.js). Both used to carry their own copy, so bug fixes
+// in one never reached the other. Every function returns a plain string; the
+// callers wrap it in whatever envelope their host expects.
+//
+// `ctx` carries the host's notion of the current location:
+//   { worktree, directory } — the MCP server passes nothing and falls back to cwd.
+
+const TITLE_PATTERN = /^\*\*([^*]+)\*\*\s*(?:—|--|-|:)?\s*(.*)$/;
+
+function splitTitle(rawText, explicitTitle) {
+  let finalTitle = explicitTitle ? explicitTitle.trim() : null;
+  let finalFact = String(rawText || "").trim();
+  const match = TITLE_PATTERN.exec(finalFact);
+  if (match) {
+    if (!finalTitle) finalTitle = match[1].trim();
+    finalFact = match[2].trim();
+  }
+  return { finalTitle, finalFact };
+}
+
+async function resolveScopeKey(scope, ctx = {}) {
+  return await scopeKey(scope || "project", ctx.worktree ?? null, ctx.directory ?? null);
+}
+
+export async function rememberFact(
+  { fact, title, scope, docId, startLine, endLine, relationType, ttl, keep, tags, supersedes },
+  ctx = {}
+) {
+  const key = requireProjectKey(await resolveScopeKey(scope, ctx));
+  const entries = await readMemory(key);
+
+  let { finalTitle, finalFact } = splitTitle(fact, title);
+  if (!finalTitle) finalTitle = autoGenerateTitle(finalFact);
+
+  const text = `**${finalTitle}** — ${finalFact}`;
+  const factBodyNormalized = finalFact.toLowerCase();
+  const duplicate = entries.some((e) => factBody(e).toLowerCase().trim() === factBodyNormalized);
+
+  let supersededInfo = "";
+  if (!duplicate) {
+    const [date, time] = today().split(" ");
+    const meta = { ttl, tags };
+    if (keep) meta.keep = "1";
+    if (supersedes) {
+      const targetIdx = resolveFactIndex(entries, supersedes);
+      if (targetIdx !== -1) {
+        const newId = nextFactId(entries);
+        const targetId = factMeta(entries[targetIdx]).id || nextFactId(entries);
+        entries[targetIdx] = withMeta(entries[targetIdx], { id: targetId, supersededBy: newId });
+        meta.id = newId;
+        meta.supersedes = targetId;
+        supersededInfo = ` [superseded: "${factText(entries[targetIdx]).slice(0, 60)}"]`;
+      } else {
+        supersededInfo = " (note: supersedes target not found)";
+      }
+    }
+    if (!meta.id) meta.id = nextFactId(entries);
+    entries.push(formatFactEntry({ date, time, text, meta }));
+    await writeMemory(key, entries);
+  }
+
+  let linkInfo = "";
+  if (docId) {
+    try {
+      const { linkFactToDocument } = await import("../../graph/knowledge_linker.js");
+      const linkRes = await linkFactToDocument({
+        factKey: key,
+        factText: finalFact,
+        docId,
+        startLine,
+        endLine,
+        relationType: relationType || "LINKS_TO",
+      });
+      const linesStr = startLine ? `:L${startLine}${endLine ? `-${endLine}` : ""}` : "";
+      linkInfo = ` [Linked to Doc: "${linkRes.docTitle}"${linesStr}]`;
+    } catch (err) {
+      linkInfo = ` (Note: Fact saved, but document link failed: ${err.message})`;
+    }
+  }
+
+  return `Memory updated${supersededInfo}${linkInfo}`;
+}
+
+async function resolveTargetKey(projectPath) {
+  if (!projectPath) return null;
+  try {
+    const { resolveProjectIdentity } = await import("../../identity.js");
+    const identity = await resolveProjectIdentity(projectPath);
+    if (identity) return identity.key;
+  } catch {}
+  return canonicalPath(projectPath);
+}
+
+export async function recallFacts(
+  { scope, project, query, tags, since, until, mode, offset, limit },
+  ctx = {}
+) {
+  const results = [];
+  const now = Date.now();
+  const targetMode = mode || "full";
+  const targetOffset = offset !== undefined && offset !== null ? offset : 0;
+
+  if (scope === "list_projects") {
+    const stores = await listProjectStores();
+    if (!stores.length) return "No project memory stores found.";
+    const lines = stores.map(
+      (s, i) =>
+        `${i + 1}. ${s.basename} — ${s.count} fact(s) [${s.file}]${
+          s.path ? ` (bound to ${s.path})` : " (unbound legacy store)"
+        }`
+    );
+    return `Project Memory Stores:\n${lines.join(
+      "\n"
+    )}\n\nUse recall(scope: "project", project: "<path>") to read a specific store.\n\nMemory dir: ${MEMORY_DIR}`;
+  }
+
+  let getLinksForFact = null;
+  try {
+    ({ getLinksForFact } = await import("../../graph/knowledge_linker.js"));
+  } catch {}
+
+  const target =
+    (await resolveTargetKey(project)) ?? (await projectKey(ctx.worktree ?? null, ctx.directory ?? null));
+  const label = project ? target : await projectName(ctx.worktree ?? null, ctx.directory ?? null);
+
+  const formatFactWithLinks = async (factLine, index, key) => {
+    const p = parseFactEntry(factLine);
+    if (!p) return factLine;
+
+    const meta = p.meta;
+    const badges = [];
+    if (isExpiredLine(factLine, now)) badges.push("EXPIRED");
+    if (isKeepFact(factLine)) badges.push("KEEP");
+    if (isSuperseded(factLine)) badges.push("SUPERSEDED");
+    if (meta.inject === "1") badges.push("INJECT");
+    if (meta.id) badges.push(`id:${meta.id}`);
+    if (meta.tags) badges.push(`tags:${meta.tags}`);
+    badges.push(`${p.date} ${p.time}`);
+    const badgesStr = badges.length ? ` [${badges.join("] [")}]` : "";
+
+    let lineText =
+      targetMode === "headers" ? `**${factTitle(factLine)}**${badgesStr}` : `${p.text}${badgesStr}`;
+
+    if (getLinksForFact) {
+      try {
+        const links = await getLinksForFact(key, p.text);
+        if (links && links.length > 0) {
+          const docStr = links
+            .map((l) => {
+              const range = l.start_line ? `:L${l.start_line}${l.end_line ? `-${l.end_line}` : ""}` : "";
+              return `${l.doc_title || l.doc_path}${range}`;
+            })
+            .join(", ");
+          lineText += ` 🔗 [Linked Docs: ${docStr}]`;
+        }
+      } catch {}
+    }
+    return `${index}. ${lineText}`;
+  };
+
+  const collect = async (entries, key) => {
+    const matched = entries.filter(
+      (e) => matchesQuery(e, query) && matchesTags(e, tags) && inDateRange(e, since, until)
+    );
+    if (!matched.length) return;
+    if (results.length) results.push("");
+    results.push(`--- ${key === GLOBAL_KEY ? "Global" : `Project: ${key === target ? label : key}`} ---`);
+
+    const hasLimit = limit !== undefined && limit !== null;
+    const targetLimit = hasLimit ? limit : matched.length;
+    const paginated = matched.slice(targetOffset, targetOffset + targetLimit);
+    for (let i = 0; i < paginated.length; i++) {
+      results.push(await formatFactWithLinks(paginated[i], targetOffset + i + 1, key));
+    }
+    if (hasLimit && matched.length > targetLimit) {
+      results.push(
+        `Showing entries ${targetOffset + 1}-${Math.min(targetOffset + targetLimit, matched.length)} of ${matched.length}`
+      );
+    }
+    results.push(`Store file: ${storeFilePath(key)}`);
+  };
+
+  if (scope !== "project") await collect(await readMemory(GLOBAL_KEY), GLOBAL_KEY);
+  if (scope !== "global") await collect(await readMemory(target), target);
+
+  const filtered = Boolean(query || tags || since || until);
+  if (!results.length) return filtered ? "No facts match the search." : "Memory is empty.";
+  return `${results.join("\n")}\n\nMemory dir: ${MEMORY_DIR}`;
+}
+
+export async function getFactById({ id, scope }, ctx = {}) {
+  const targetId = String(id || "").trim();
+  if (!targetId) throw new Error("ID parameter is required.");
+
+  const results = [];
+  const check = async (key) => {
+    const entries = await readMemory(key);
+    const match = entries.find((e) => factMeta(e).id === targetId);
+    if (match) {
+      results.push({ key, title: factTitle(match), body: factBody(match), meta: factMeta(match), line: match });
+    }
+  };
+
+  if (scope !== "project") await check(GLOBAL_KEY);
+  if (scope !== "global") await check(await projectKey(ctx.worktree ?? null, ctx.directory ?? null));
+
+  if (!results.length) return `Fact with ID "${targetId}" not found.`;
+
+  return results
+    .map((r) => {
+      const metaStr = Object.entries(r.meta)
+        .map(([k, v]) => `${k}:${v}`)
+        .join(", ");
+      return `[Store: ${r.key === GLOBAL_KEY ? "Global" : "Project"}]\nTitle: ${r.title}\nBody: ${r.body}\nMetadata: ${
+        metaStr ? `<!-- ${metaStr} -->` : "none"
+      }`;
+    })
+    .join("\n\n");
+}
+
+export async function forgetFacts({ query, scope, force }, ctx = {}) {
+  const key = requireProjectKey(await resolveScopeKey(scope, ctx));
+  const entries = await readMemory(key);
+
+  const rangeMatch = /^\s*(\d+)\s*-\s*(\d+)\s*$/.exec(query);
+  let indices = [];
+  if (rangeMatch) {
+    const from = parseInt(rangeMatch[1], 10);
+    const to = parseInt(rangeMatch[2], 10);
+    if (from > 0 && to >= from && to <= entries.length) {
+      for (let i = from - 1; i < to; i++) indices.push(i);
+    }
+  }
+  if (!indices.length && /^\s*\d+\s*$/.test(String(query))) {
+    const num = parseInt(query, 10);
+    if (num > 0 && num <= entries.length) indices.push(num - 1);
+  }
+  if (!indices.length) {
+    const q = String(query).toLowerCase();
+    indices = entries.reduce((acc, e, i) => (e.toLowerCase().includes(q) ? acc.concat(i) : acc), []);
+  }
+  if (!indices.length) return "Not found.";
+
+  const removable = indices.filter((i) => force || !isKeepFact(entries[i]));
+  const protectedCount = indices.length - removable.length;
+  if (removable.length) {
+    for (const i of removable.sort((a, b) => b - a)) entries.splice(i, 1);
+    await writeMemory(key, entries);
+  }
+  let text = removable.length ? "Memory updated" : "Nothing removed.";
+  if (protectedCount) text += ` (${protectedCount} protected fact(s) skipped; use force=true to override)`;
+  return text;
+}
+
+export async function updateFactText({ id, newText, title, scope }, ctx = {}) {
+  const key = requireProjectKey(await resolveScopeKey(scope, ctx));
+  const entries = await readMemory(key);
+  const idx = resolveFactIndex(entries, id);
+  if (idx === -1) throw new Error(`Fact not found: ${id}`);
+
+  const p = parseFactEntry(entries[idx]);
+  const oldText = p ? p.text : entries[idx];
+  const oldBody = factBody(entries[idx]) || oldText;
+
+  let { finalTitle, finalFact } = splitTitle(newText, title);
+  if (!finalTitle) finalTitle = factTitle(entries[idx]) || autoGenerateTitle(finalFact);
+
+  entries[idx] = formatFactEntry({
+    date: p.date,
+    time: p.time,
+    text: `**${finalTitle}** — ${finalFact}`,
+    meta: p.meta,
+  });
+  await writeMemory(key, entries);
+
+  let linksUpdated = 0;
+  try {
+    const { getDatabase } = await import("../../db/database.js");
+    const db = await getDatabase();
+    const res = await db
+      .prepare("UPDATE knowledge_links SET fact_text = ? WHERE fact_key = ? AND fact_text = ?")
+      .run(finalFact, key, oldBody);
+    linksUpdated = res.changes;
+  } catch {}
+
+  return `Fact updated${linksUpdated ? `, ${linksUpdated} doc link(s) updated` : ""}`;
+}
+
+export async function memoryInfo(_args = {}, ctx = {}) {
+  const dbPath = join(MEMORY_DIR, "storage", "memory.sqlite");
+  const activeKey = await projectKey(ctx.worktree ?? null, ctx.directory ?? null);
+  const globalFile = storeFilePath(GLOBAL_KEY);
+  const projectFile = storeFilePath(activeKey);
+
+  let version = "unknown";
+  try {
+    version = JSON.parse(await readFile(new URL("../../../package.json", import.meta.url), "utf-8")).version;
+  } catch {}
+
+  const rag = {};
+  try {
+    const { getDatabase } = await import("../../db/database.js");
+    const db = await getDatabase();
+    const count = async (table) => {
+      const row = await db.prepare(`SELECT COUNT(*) AS c FROM ${table}`).get();
+      return row ? row.c : 0;
+    };
+    rag.documents = await count("documents");
+    rag.sections = await count("sections");
+    rag.chunks = await count("micro_chunks");
+    rag.edges = await count("graph_edges");
+    rag.links = await count("knowledge_links");
+  } catch (e) {
+    rag.error = e.message;
+  }
+
+  const stores = await listProjectStores();
+
+  const identityLines = [];
+  try {
+    const { getDatabase } = await import("../../db/database.js");
+    const { resolveProjectIdentity, listIdentities } = await import("../../identity.js");
+    const db = await getDatabase();
+    const identity = await resolveProjectIdentity(ctx.worktree || ctx.directory || process.cwd());
+    const all = await listIdentities(db);
+    identityLines.push(
+      `Identity: ${identity ? "git" : "no-git"}` +
+        (identity
+          ? ` | key: ${identity.key} | name: ${identity.name}${
+              identity.primaryRemote ? ` | remote: ${identity.primaryRemote}` : ""
+            }`
+          : ""),
+      `Known identities: ${all.length}`
+    );
+  } catch (e) {
+    identityLines.push(`Identity: unavailable (${e.message})`);
+  }
+
+  const lines = [
+    `Version: ${version}`,
+    `MEMORY_DIR: ${MEMORY_DIR}`,
+    `SQLite DB: ${dbPath}`,
+    `Global store: ${globalFile}`,
+    `Project store: ${projectFile}`,
+    `Project stores: ${stores.length}`,
+    `Facts (global): ${(await readMemoryRaw(GLOBAL_KEY)).length}`,
+    `Facts (project): ${(await readMemoryRaw(activeKey)).length}`,
+    ...identityLines,
+  ];
+  if (rag.error) lines.push(`RAG: unavailable (${rag.error})`);
+  else
+    lines.push(
+      `RAG: ${rag.documents} doc(s), ${rag.sections} section(s), ${rag.chunks} chunk(s), ${rag.edges} edge(s), ${rag.links} memory link(s)`
+    );
+  return lines.join("\n");
+}