virlow-mcp 3.69.1 → 3.70.1

package/dist/cli.js

@@ -2121,7 +2121,7 @@ function buildGraph(memories) {
     const key = entityKey(name);
     let entity = entities.get(key);
     if (!entity) {
-      entity = { key, name: name.trim(), memoryIds: /* @__PURE__ */ new Set(), edges: [] };
+      entity = { key, name: name.trim(), memoryIds: /* @__PURE__ */ new Set(), mentionIds: /* @__PURE__ */ new Set(), edges: [] };
       entities.set(key, entity);
       spellings.set(key, /* @__PURE__ */ new Map());
     }
@@ -2130,7 +2130,8 @@ function buildGraph(memories) {
     counts.set(name.trim(), (counts.get(name.trim()) ?? 0) + 1);
     return entity;
   };
-  for (const memory of memories) {
+  const all = [...memories];
+  for (const memory of all) {
     for (const name of memory.meta.about ?? [])
       touch(name, memory.id);
     for (const relation of memory.meta.relations ?? []) {
@@ -2148,7 +2149,16 @@ function buildGraph(memories) {
     if (best)
       entities.get(key).name = best[0];
   }
-  return { entities, edges };
+  const graph = { entities, edges };
+  for (const memory of all) {
+    for (const entity of entitiesMentioned(graph, `${memory.label} ${memory.text}`)) {
+      if (entity.memoryIds.has(memory.id))
+        continue;
+      entity.memoryIds.add(memory.id);
+      entity.mentionIds.add(memory.id);
+    }
+  }
+  return graph;
 }
 function isEntityLike(value) {
   return /^[A-Z0-9]/.test(value.trim());
@@ -2227,7 +2237,8 @@ function supersededBy(graph, relation, at) {
   });
 }
 function graphHealth(graph, memories, at = Date.now()) {
-  const unlinked = memories.filter((m) => !(m.meta.about?.length || m.meta.relations?.length)).map((m) => m.id);
+  const mentioned = new Set([...graph.entities.values()].flatMap((e) => [...e.mentionIds]));
+  const unlinked = memories.filter((m) => !(m.meta.about?.length || m.meta.relations?.length) && !mentioned.has(m.id)).map((m) => m.id);
   const names = [...graph.entities.values()];
   const possibleDuplicates = [];
   for (let i = 0; i < names.length; i++) {
@@ -2263,6 +2274,31 @@ function graphHealth(graph, memories, at = Date.now()) {
   }
   return { unlinked, possibleDuplicates, contradictions };
 }
+function renameEntityInMeta(meta, from, into) {
+  const fromKey = entityKey(from);
+  const names = [...meta.about ?? [], ...(meta.relations ?? []).flatMap((r) => [r.s, r.o])];
+  if (!names.some((n) => entityKey(n) === fromKey))
+    return null;
+  const swap = (n) => entityKey(n) === fromKey ? into.trim() : n;
+  const next = { ...meta };
+  if (meta.about)
+    next.about = uniqueNames(meta.about.map(swap));
+  if (meta.relations) {
+    const byKey = /* @__PURE__ */ new Map();
+    for (const r of meta.relations.map((r2) => ({ ...r2, s: swap(r2.s), o: swap(r2.o) }))) {
+      byKey.set(`${entityKey(r.s)}|${normalizePredicate(r.p)}|${entityKey(r.o)}`, r);
+    }
+    next.relations = [...byKey.values()];
+  }
+  return next;
+}
+function uniqueNames(names) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const n of names)
+    if (!byKey.has(entityKey(n)))
+      byKey.set(entityKey(n), n);
+  return [...byKey.values()];
+}
 
 // ../../packages/mcp-core/dist/memory-secrets.js
 var PATTERNS = [
@@ -2716,19 +2752,11 @@ var MemoryStore = class {
       await this.sync();
       const key = this.requireSession();
       const startEpoch = this.epoch;
-      const fromKey = entityKey(from);
-      const swap = (n) => entityKey(n) === fromKey ? into.trim() : n;
       let changed = 0;
       for (const memory of [...this.cache.values()]) {
-        const names = [...memory.meta.about ?? [], ...(memory.meta.relations ?? []).flatMap((r) => [r.s, r.o])];
-        if (!names.some((n) => entityKey(n) === fromKey))
+        const meta = renameEntityInMeta(memory.meta, from, into);
+        if (!meta)
           continue;
-        const meta = { ...memory.meta };
-        if (memory.meta.about)
-          meta.about = unionNames([], memory.meta.about.map(swap));
-        if (memory.meta.relations) {
-          meta.relations = unionRelations([], memory.meta.relations.map((r) => ({ ...r, s: swap(r.s), o: swap(r.o) })));
-        }
         const row = await this.writeNote(key, memory.id, memory.label, memory.text, meta);
         if (this.epoch === startEpoch) {
           this.cache.set(memory.id, { ...memory, meta, updatedAt: row.updatedAt });
@@ -2763,6 +2791,11 @@ var MemoryStore = class {
     const memories = this.list(namespace);
     return graphHealth(this.graph(namespace), memories);
   }
+  /** The namespace of a memory this session has seen, without a sync;
+   *  undefined for a global memory or one not cached yet. */
+  namespaceOfCached(id) {
+    return this.cache.get(id)?.namespace;
+  }
   /** Requires a prior sync() in the same unlock to have populated the cache. */
   list(namespace) {
     this.requireSession();
@@ -2979,10 +3012,48 @@ async function memoriesAllowed(api) {
   }
 }
 var MEMORIES_DISABLED_MESSAGE = 'AI memories are switched off for this account. Turn on "AI memories" in Settings \u2192 Security in the Virlow app to use this tool.';
+async function requireMemoriesSetting(api) {
+  let me;
+  try {
+    me = await api.me();
+  } catch (err) {
+    throw new Error(memoriesUnreadableMessage(err));
+  }
+  if (me.memoriesEnabled !== true)
+    throw new Error(MEMORIES_DISABLED_MESSAGE);
+}
+function memoriesUnreadableMessage(err) {
+  const status = err instanceof ApiError ? err.status : void 0;
+  const reason = status === 429 ? "Virlow is rate limiting requests right now" : `Virlow could not be reached (${err instanceof Error ? err.message : String(err)})`;
+  return `Could not check whether AI memories are on: ${reason}. Nothing was changed. Wait a minute and try again; this is not the AI memories switch.`;
+}
 
 // ../../packages/mcp-core/dist/tools.js
 import { z } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// ../../packages/mcp-core/dist/memory-pause.js
+async function capturePausedReason(api, namespace) {
+  try {
+    const me = await api.me();
+    if (me.memoriesPaused === true)
+      return MEMORIES_PAUSED_MESSAGE;
+    if (namespace === void 0)
+      return null;
+    const { folders } = await api.listFolders();
+    const root = folders.find((f) => f.kind === "memories");
+    const paused = folders.some((f) => root !== void 0 && f.parentId === root.id && f.name === namespace && f.memoryPaused === true);
+    return paused ? projectPausedMessage(namespace) : null;
+  } catch {
+    return "Not saved: could not confirm that saving memories is allowed. Try again shortly.";
+  }
+}
+var MEMORIES_PAUSED_MESSAGE = "Not saved: saving memories is paused in the Virlow app. Recall still works; do not retry or ask the user to save this another way.";
+function projectPausedMessage(namespace) {
+  return `Not saved: saving memories is paused for the project "${namespace}" in the Virlow app. Recall still works; do not retry or ask the user to save this another way.`;
+}
+
+// ../../packages/mcp-core/dist/tools.js
 function textResult(text) {
   return { content: [{ type: "text", text }] };
 }
@@ -3109,9 +3180,14 @@ function buildServer(opts) {
   const requireMemories = async () => {
     if (!vault.isUnlocked())
       return;
-    if (!await memoriesAllowed(api)) {
-      throw new Error(MEMORIES_DISABLED_MESSAGE);
-    }
+    await requireMemoriesSetting(api);
+  };
+  const requireCapture = async (namespace) => {
+    if (!vault.isUnlocked())
+      return;
+    const reason = await capturePausedReason(api, namespace);
+    if (reason)
+      throw new Error(reason);
   };
   const shownMemories = /* @__PURE__ */ new Set();
   const relatedMemories = async (text) => {
@@ -3159,6 +3235,7 @@ function buildServer(opts) {
       if (args.valid_from !== void 0)
         meta.validFrom = args.valid_from;
       await requireMemories();
+      await requireCapture(args.namespace);
       const result = await memoryStore.add(args.label, args.text, args.namespace, meta);
       let message = result.action === "updated" ? `updated existing memory ${result.id}` : `stored ${result.id}`;
       if (result.closed.length > 0) {
@@ -3199,12 +3276,18 @@ ${formatSyncStats(stats)}`);
       description: "List cached memories, optionally filtered by namespace. Syncs with the server first so the list reflects the latest state across devices. Requires the vault to be unlocked.",
       inputSchema: {
         namespace: z.string().max(100).optional(),
-        limit: z.number().int().min(1).max(50).optional()
+        limit: z.number().int().min(1).max(50).optional(),
+        unlinked_only: z.boolean().optional().describe("Only memories linked to no entity, for organising them with link_memory.")
       }
     }, wrap(async (args) => {
       await requireMemories();
       const stats = await memoryStore.sync();
-      const items = memoryStore.list(args.namespace).slice(0, args.limit ?? 50);
+      let all = memoryStore.list(args.namespace);
+      if (args.unlinked_only) {
+        const unlinked = new Set((await memoryStore.health(args.namespace)).unlinked);
+        all = all.filter((m) => unlinked.has(m.id));
+      }
+      const items = all.slice(0, args.limit ?? 50);
       const lines = items.map((m, i) => `${i + 1}. [${m.id}] ${m.label} \u2014 ${m.text}${m.namespace ? ` (namespace: ${m.namespace})` : ""}${formatMeta(m.meta)}`);
       const body = lines.length > 0 ? lines.join("\n") : "(no memories found)";
       return textResult(`${body}
@@ -3241,6 +3324,7 @@ ${formatSyncStats(stats)}`);
       }
     }, wrap(async (args) => {
       await requireMemories();
+      await requireCapture(memoryStore.namespaceOfCached(args.id));
       const closed = await memoryStore.link(args.id, {
         ...args.entities && { about: args.entities },
         ...args.relations && { relations: args.relations }
@@ -3256,6 +3340,7 @@ ${formatSyncStats(stats)}`);
       }
     }, wrap(async (args) => {
       await requireMemories();
+      await requireCapture();
       const changed = await memoryStore.mergeEntities(args.from, args.into);
       return textResult(`merged "${args.from}" into "${args.into}" in ${changed} memor${changed === 1 ? "y" : "ies"}`);
     }));
@@ -3269,6 +3354,9 @@ ${formatSyncStats(stats)}`);
       await requireMemories();
       const { entities, facts } = await memoryStore.context(args.namespace, args.limit ?? 12);
       const parts = [];
+      const paused = await capturePausedReason(api, args.namespace);
+      if (paused)
+        parts.push("Saving memories is paused (recall only). Do not call add_memory this session.");
       if (entities.length) {
         parts.push("Key entities: " + entities.map((e) => `${e.name} (${e.facts})`).join(", "));
       }
@@ -3297,17 +3385,23 @@ ${formatSyncStats(stats)}`);
         label: z.string().min(1).max(80).optional(),
         text: z.string().min(1).max(4e3).optional(),
         tags: z.array(z.string().max(50)).max(20).optional(),
-        confidence: z.string().max(20).optional()
+        confidence: z.string().max(20).optional(),
+        valid_from: z.string().max(40).optional().describe("When the fact became true (YYYY-MM-DD)."),
+        valid_to: z.string().max(40).optional().describe("When the fact stopped being true (YYYY-MM-DD). It is kept as history, not deleted.")
       }
     }, wrap(async (args) => {
-      if (args.label === void 0 && args.text === void 0 && args.tags === void 0 && args.confidence === void 0) {
-        throw new Error("update_memory needs at least one of label, text, tags, or confidence");
+      if (args.label === void 0 && args.text === void 0 && args.tags === void 0 && args.confidence === void 0 && args.valid_from === void 0 && args.valid_to === void 0) {
+        throw new Error("update_memory needs at least one of label, text, tags, confidence, valid_from or valid_to");
       }
       const meta = {};
       if (args.tags !== void 0)
         meta.tags = args.tags;
       if (args.confidence !== void 0)
         meta.confidence = args.confidence;
+      if (args.valid_from !== void 0)
+        meta.validFrom = args.valid_from;
+      if (args.valid_to !== void 0)
+        meta.validTo = args.valid_to;
       const changes = { meta };
       if (args.label !== void 0)
         changes.label = args.label;
@@ -4005,7 +4099,7 @@ function startUnlockServer(api, vault, opts = {}) {
 }
 
 // src/version.ts
-var VERSION = true ? "3.69.1" : "dev";
+var VERSION = true ? "3.70.1" : "dev";
 
 // src/server.ts
 function defaultEmbeddingCacheDir() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "virlow-mcp",
-  "version": "3.69.1",
+  "version": "3.70.1",
   "description": "Local MCP server for Virlow Secure Notes: end-to-end-encrypted AI memories and notes for Cursor, Claude, Codex, and any MCP client.",
   "license": "UNLICENSED",
   "type": "module",
@@ -34,9 +34,9 @@
     "esbuild": "^0.25.0",
     "typescript": "^5.8.0",
     "vitest": "^3.0.0",
-    "@batalabs/virlow-mcp-core": "3.69.1",
-    "@batalabs/virlow-memory": "3.69.1",
-    "@batalabs/virlow-crypto": "3.69.1"
+    "@batalabs/virlow-memory": "3.70.1",
+    "@batalabs/virlow-mcp-core": "3.70.1",
+    "@batalabs/virlow-crypto": "3.70.1"
   },
   "scripts": {
     "build": "node build.mjs",