@velvetmonkey/flywheel-memory 2.0.73 → 2.0.75

package/dist/index.js

@@ -1573,7 +1573,7 @@ var init_taskHelpers = __esm({
 
 // src/index.ts
 import * as path32 from "path";
-import { readFileSync as readFileSync4, realpathSync } from "fs";
+import { readFileSync as readFileSync5, realpathSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname as dirname4, join as join17 } from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -2251,6 +2251,29 @@ function loadEntityEmbeddingsToMemory() {
   } catch {
   }
 }
+function loadNoteEmbeddingsForPaths(paths) {
+  const result = /* @__PURE__ */ new Map();
+  if (!db || paths.length === 0) return result;
+  try {
+    const stmt = db.prepare("SELECT path, embedding FROM note_embeddings WHERE path = ?");
+    for (const p of paths) {
+      const row = stmt.get(p);
+      if (row) {
+        const embedding = new Float32Array(
+          row.embedding.buffer,
+          row.embedding.byteOffset,
+          row.embedding.byteLength / Float32Array.BYTES_PER_ELEMENT
+        );
+        result.set(p, embedding);
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+function getEntityEmbedding(entityName) {
+  return entityEmbeddingsMap.get(entityName) ?? null;
+}
 function getEntityEmbeddingsCount() {
   if (!db) return 0;
   try {
@@ -3242,8 +3265,8 @@ async function upsertNote(index, vaultPath2, notePath) {
       removeNoteFromIndex(index, notePath);
     }
     const fullPath = path7.join(vaultPath2, notePath);
-    const fs32 = await import("fs/promises");
-    const stats = await fs32.stat(fullPath);
+    const fs33 = await import("fs/promises");
+    const stats = await fs33.stat(fullPath);
     const vaultFile = {
       path: notePath,
       absolutePath: fullPath,
@@ -3829,11 +3852,11 @@ function getAllFeedbackBoosts(stateDb2, folder, now) {
   if (folder !== void 0) {
     folderStatsMap = /* @__PURE__ */ new Map();
     for (const gs of globalStats) {
-      const fs32 = getWeightedFolderStats(stateDb2, gs.entity, folder, now);
-      if (fs32.rawTotal >= FEEDBACK_BOOST_MIN_SAMPLES) {
+      const fs33 = getWeightedFolderStats(stateDb2, gs.entity, folder, now);
+      if (fs33.rawTotal >= FEEDBACK_BOOST_MIN_SAMPLES) {
         folderStatsMap.set(gs.entity, {
-          weightedAccuracy: fs32.weightedAccuracy,
-          rawCount: fs32.rawTotal
+          weightedAccuracy: fs33.weightedAccuracy,
+          rawCount: fs33.rawTotal
         });
       }
     }
@@ -3843,10 +3866,10 @@ function getAllFeedbackBoosts(stateDb2, folder, now) {
     if (stat4.rawTotal < FEEDBACK_BOOST_MIN_SAMPLES) continue;
     let accuracy;
     let sampleCount;
-    const fs32 = folderStatsMap?.get(stat4.entity);
-    if (fs32 && fs32.rawCount >= FEEDBACK_BOOST_MIN_SAMPLES) {
-      accuracy = fs32.weightedAccuracy;
-      sampleCount = fs32.rawCount;
+    const fs33 = folderStatsMap?.get(stat4.entity);
+    if (fs33 && fs33.rawCount >= FEEDBACK_BOOST_MIN_SAMPLES) {
+      accuracy = fs33.weightedAccuracy;
+      sampleCount = fs33.rawCount;
     } else {
       accuracy = stat4.weightedAccuracy;
       sampleCount = stat4.rawTotal;
@@ -8490,12 +8513,13 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
             targetMap.set(key, {
               count: 1,
               sources: /* @__PURE__ */ new Set([broken2.source]),
-              suggestion: broken2.suggestion
+              suggestion: broken2.suggestion,
+              displayTarget: broken2.target
             });
           }
         }
-        const targets = Array.from(targetMap.entries()).map(([target, data]) => ({
-          target,
+        const targets = Array.from(targetMap.values()).map((data) => ({
+          target: data.displayTarget,
           mention_count: data.count,
           sources: Array.from(data.sources),
           ...data.suggestion ? { suggestion: data.suggestion } : {}
@@ -9819,21 +9843,23 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
         if (hasEmbeddingsIndex()) {
           try {
             const semanticResults = await semanticSearch(query, limit);
-            const fts5Ranked = fts5Results.map((r) => ({ path: r.path, title: r.title, snippet: r.snippet }));
-            const semanticRanked = semanticResults.map((r) => ({ path: r.path, title: r.title }));
-            const entityRankedList = entityResults.map((r) => ({ path: r.path, title: r.name }));
+            const normalizePath2 = (p) => p.replace(/\\/g, "/").replace(/\/+/g, "/");
+            const fts5Ranked = fts5Results.map((r) => ({ path: normalizePath2(r.path), title: r.title, snippet: r.snippet }));
+            const semanticRanked = semanticResults.map((r) => ({ path: normalizePath2(r.path), title: r.title }));
+            const entityRankedList = entityResults.map((r) => ({ path: normalizePath2(r.path), title: r.name }));
+            const edgeRankedNorm = edgeRanked.map((r) => ({ path: normalizePath2(r.path), title: r.title }));
             const rrfLists = [fts5Ranked, semanticRanked, entityRankedList];
-            if (edgeRanked.length > 0) rrfLists.push(edgeRanked);
+            if (edgeRankedNorm.length > 0) rrfLists.push(edgeRankedNorm);
             const rrfScores = reciprocalRankFusion(...rrfLists);
             const allPaths = /* @__PURE__ */ new Set([
-              ...fts5Results.map((r) => r.path),
-              ...semanticResults.map((r) => r.path),
-              ...entityResults.map((r) => r.path),
-              ...edgeRanked.map((r) => r.path)
+              ...fts5Results.map((r) => normalizePath2(r.path)),
+              ...semanticResults.map((r) => normalizePath2(r.path)),
+              ...entityResults.map((r) => normalizePath2(r.path)),
+              ...edgeRanked.map((r) => normalizePath2(r.path))
             ]);
-            const fts5Map = new Map(fts5Results.map((r) => [r.path, r]));
-            const semanticMap = new Map(semanticResults.map((r) => [r.path, r]));
-            const entityMap = new Map(entityResults.map((r) => [r.path, r]));
+            const fts5Map = new Map(fts5Results.map((r) => [normalizePath2(r.path), r]));
+            const semanticMap = new Map(semanticResults.map((r) => [normalizePath2(r.path), r]));
+            const entityMap = new Map(entityResults.map((r) => [normalizePath2(r.path), r]));
             const merged = Array.from(allPaths).map((p) => ({
               path: p,
               title: fts5Map.get(p)?.title || semanticMap.get(p)?.title || entityMap.get(p)?.name || p.replace(/\.md$/, "").split("/").pop() || p,
@@ -9856,10 +9882,12 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
           }
         }
         if (entityResults.length > 0) {
-          const fts5Map = new Map(fts5Results.map((r) => [r.path, r]));
-          const entityRanked = entityResults.filter((r) => !fts5Map.has(r.path));
+          const normalizePath2 = (p) => p.replace(/\\/g, "/").replace(/\/+/g, "/");
+          const fts5Map = new Map(fts5Results.map((r) => [normalizePath2(r.path), r]));
+          const entityNormMap = new Map(entityResults.map((r) => [normalizePath2(r.path), r]));
+          const entityRanked = entityResults.filter((r) => !fts5Map.has(normalizePath2(r.path)));
           const merged = [
-            ...fts5Results.map((r) => ({ path: r.path, title: r.title, snippet: r.snippet, in_entity: fts5Map.has(r.path) && entityResults.some((e) => e.path === r.path) })),
+            ...fts5Results.map((r) => ({ path: r.path, title: r.title, snippet: r.snippet, in_entity: entityNormMap.has(normalizePath2(r.path)) })),
             ...entityRanked.map((r) => ({ path: r.path, title: r.name, snippet: void 0, in_entity: true }))
           ];
           return { content: [{ type: "text", text: JSON.stringify({
@@ -17363,6 +17391,142 @@ function registerMemoryTools(server2, getStateDb) {
 // src/tools/read/recall.ts
 import { z as z24 } from "zod";
 import { searchEntities as searchEntitiesDb2 } from "@velvetmonkey/vault-core";
+
+// src/core/read/mmr.ts
+function selectByMmr(candidates, limit, lambda = 0.7) {
+  if (candidates.length <= limit) return candidates;
+  if (candidates.length === 0) return [];
+  const maxScore = Math.max(...candidates.map((c) => c.score));
+  if (maxScore === 0) return candidates.slice(0, limit);
+  const normScores = /* @__PURE__ */ new Map();
+  for (const c of candidates) {
+    normScores.set(c.id, c.score / maxScore);
+  }
+  const selected = [];
+  const remaining = new Set(candidates.map((_, i) => i));
+  let bestIdx = 0;
+  let bestScore = -Infinity;
+  for (const idx of remaining) {
+    if (candidates[idx].score > bestScore) {
+      bestScore = candidates[idx].score;
+      bestIdx = idx;
+    }
+  }
+  selected.push(candidates[bestIdx]);
+  remaining.delete(bestIdx);
+  while (selected.length < limit && remaining.size > 0) {
+    let bestMmr = -Infinity;
+    let bestCandidate = -1;
+    for (const idx of remaining) {
+      const candidate = candidates[idx];
+      const relevance = normScores.get(candidate.id) || 0;
+      let maxSim = 0;
+      if (candidate.embedding !== null) {
+        for (const sel of selected) {
+          if (sel.embedding !== null) {
+            const sim = cosineSimilarity(candidate.embedding, sel.embedding);
+            if (sim > maxSim) maxSim = sim;
+          }
+        }
+      }
+      const mmr = lambda * relevance - (1 - lambda) * maxSim;
+      if (mmr > bestMmr) {
+        bestMmr = mmr;
+        bestCandidate = idx;
+      }
+    }
+    if (bestCandidate === -1) break;
+    selected.push(candidates[bestCandidate]);
+    remaining.delete(bestCandidate);
+  }
+  return selected;
+}
+
+// src/core/read/snippets.ts
+import * as fs29 from "fs";
+function stripFrontmatter(content) {
+  const match = content.match(/^---[\s\S]*?---\n([\s\S]*)$/);
+  return match ? match[1] : content;
+}
+function splitIntoParagraphs(content, maxChunkChars) {
+  const MIN_PARAGRAPH_CHARS = 50;
+  const raw = content.split(/\n\n+/).map((p) => p.trim()).filter((p) => p.length > 0);
+  const merged = [];
+  let buffer2 = "";
+  for (const paragraph of raw) {
+    if (buffer2) {
+      buffer2 += "\n\n" + paragraph;
+      if (buffer2.length >= MIN_PARAGRAPH_CHARS) {
+        merged.push(buffer2.slice(0, maxChunkChars));
+        buffer2 = "";
+      }
+    } else if (paragraph.length < MIN_PARAGRAPH_CHARS) {
+      buffer2 = paragraph;
+    } else {
+      merged.push(paragraph.slice(0, maxChunkChars));
+    }
+  }
+  if (buffer2) {
+    merged.push(buffer2.slice(0, maxChunkChars));
+  }
+  return merged;
+}
+function scoreByKeywords(chunk, queryTokens, queryStems) {
+  const chunkTokens = new Set(tokenize(chunk.toLowerCase()));
+  const chunkStems = new Set([...chunkTokens].map((t) => stem(t)));
+  let score = 0;
+  for (let i = 0; i < queryTokens.length; i++) {
+    if (chunkTokens.has(queryTokens[i])) {
+      score += 10;
+    } else if (chunkStems.has(queryStems[i])) {
+      score += 5;
+    }
+  }
+  return score;
+}
+async function extractBestSnippets(filePath, queryEmbedding, queryTokens, options) {
+  const maxSnippets = options?.maxSnippets ?? 1;
+  const maxChunkChars = options?.maxChunkChars ?? 500;
+  let content;
+  try {
+    content = fs29.readFileSync(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const body = stripFrontmatter(content);
+  if (body.length < 50) {
+    return body.length > 0 ? [{ text: body, score: 1 }] : [];
+  }
+  const paragraphs = splitIntoParagraphs(body, maxChunkChars);
+  if (paragraphs.length === 0) return [];
+  const queryStems = queryTokens.map((t) => stem(t));
+  const scored = paragraphs.map((text, idx) => ({
+    text,
+    idx,
+    keywordScore: scoreByKeywords(text, queryTokens, queryStems)
+  }));
+  scored.sort((a, b) => b.keywordScore - a.keywordScore);
+  const topKeyword = scored.slice(0, 5);
+  if (queryEmbedding && hasEmbeddingsIndex()) {
+    try {
+      const reranked = [];
+      for (const chunk of topKeyword) {
+        const chunkEmbedding = await embedTextCached(chunk.text);
+        const sim = cosineSimilarity(queryEmbedding, chunkEmbedding);
+        reranked.push({ text: chunk.text, score: sim });
+      }
+      reranked.sort((a, b) => b.score - a.score);
+      return reranked.slice(0, maxSnippets);
+    } catch {
+    }
+  }
+  return topKeyword.slice(0, maxSnippets).map((c) => ({
+    text: c.text,
+    score: c.keywordScore
+  }));
+}
+
+// src/tools/read/recall.ts
 function scoreTextRelevance(query, content) {
   const queryTokens = tokenize(query).map((t) => t.toLowerCase());
   const queryStems = queryTokens.map((t) => stem(t));
@@ -17394,7 +17558,9 @@ async function performRecall(stateDb2, query, options = {}) {
     max_results = 20,
     focus = "all",
     entity,
-    max_tokens
+    max_tokens,
+    diversity = 0.7,
+    vaultPath: vaultPath2
   } = options;
   const results = [];
   const recencyIndex2 = loadRecencyFromStateDb();
@@ -17519,11 +17685,60 @@ async function performRecall(stateDb2, query, options = {}) {
     seen.add(key);
     return true;
   });
-  const truncated = deduped.slice(0, max_results);
+  let selected;
+  if (hasEmbeddingsIndex() && deduped.length > max_results) {
+    const notePaths = deduped.filter((r) => r.type === "note").map((r) => r.id);
+    const noteEmbeddings = loadNoteEmbeddingsForPaths(notePaths);
+    let queryEmbedding = null;
+    const mmrCandidates = [];
+    for (const r of deduped) {
+      let embedding = null;
+      if (r.type === "entity") {
+        embedding = getEntityEmbedding(r.id);
+      } else if (r.type === "note") {
+        embedding = noteEmbeddings.get(r.id) ?? null;
+      } else if (r.type === "memory") {
+        try {
+          if (!queryEmbedding) queryEmbedding = await embedTextCached(query);
+          embedding = await embedTextCached(r.content);
+        } catch {
+        }
+      }
+      mmrCandidates.push({ id: `${r.type}:${r.id}`, score: r.score, embedding });
+    }
+    const mmrSelected = selectByMmr(mmrCandidates, max_results, diversity);
+    const selectedIds = new Set(mmrSelected.map((m) => m.id));
+    selected = deduped.filter((r) => selectedIds.has(`${r.type}:${r.id}`));
+    const orderMap = new Map(mmrSelected.map((m, i) => [m.id, i]));
+    selected.sort((a, b) => (orderMap.get(`${a.type}:${a.id}`) ?? 0) - (orderMap.get(`${b.type}:${b.id}`) ?? 0));
+  } else {
+    selected = deduped.slice(0, max_results);
+  }
+  if (vaultPath2) {
+    const queryTokens = tokenize(query).map((t) => t.toLowerCase());
+    let queryEmb = null;
+    if (hasEmbeddingsIndex()) {
+      try {
+        queryEmb = await embedTextCached(query);
+      } catch {
+      }
+    }
+    for (const r of selected) {
+      if (r.type !== "note") continue;
+      try {
+        const absPath = vaultPath2 + "/" + r.id;
+        const snippets = await extractBestSnippets(absPath, queryEmb, queryTokens);
+        if (snippets.length > 0 && snippets[0].text.length > 0) {
+          r.content = snippets[0].text;
+        }
+      } catch {
+      }
+    }
+  }
   if (max_tokens) {
     let tokenBudget = max_tokens;
     const budgeted = [];
-    for (const r of truncated) {
+    for (const r of selected) {
       const estimatedTokens = Math.ceil(r.content.length / 4);
       if (tokenBudget - estimatedTokens < 0 && budgeted.length > 0) break;
       tokenBudget -= estimatedTokens;
@@ -17531,9 +17746,9 @@ async function performRecall(stateDb2, query, options = {}) {
     }
     return budgeted;
   }
-  return truncated;
+  return selected;
 }
-function registerRecallTools(server2, getStateDb) {
+function registerRecallTools(server2, getStateDb, getVaultPath) {
   server2.tool(
     "recall",
     "Query everything the system knows about a topic. Searches across entities, notes, and memories with graph-boosted ranking.",
@@ -17542,7 +17757,8 @@ function registerRecallTools(server2, getStateDb) {
       max_results: z24.number().min(1).max(100).optional().describe("Max results (default: 20)"),
       focus: z24.enum(["entities", "notes", "memories", "all"]).optional().describe("Limit search to specific type (default: all)"),
       entity: z24.string().optional().describe("Filter memories by entity association"),
-      max_tokens: z24.number().optional().describe("Token budget for response (truncates lower-ranked results)")
+      max_tokens: z24.number().optional().describe("Token budget for response (truncates lower-ranked results)"),
+      diversity: z24.number().min(0).max(1).optional().describe("Relevance vs diversity tradeoff (0=max diversity, 1=pure relevance, default: 0.7)")
     },
     async (args) => {
       const stateDb2 = getStateDb();
@@ -17556,7 +17772,9 @@ function registerRecallTools(server2, getStateDb) {
         max_results: args.max_results,
         focus: args.focus,
         entity: args.entity,
-        max_tokens: args.max_tokens
+        max_tokens: args.max_tokens,
+        diversity: args.diversity,
+        vaultPath: getVaultPath?.()
       });
       const entities = results.filter((r) => r.type === "entity");
       const notes = results.filter((r) => r.type === "note");
@@ -17992,7 +18210,7 @@ function registerConfigTools(server2, getConfig, setConfig, getStateDb) {
 
 // src/tools/write/enrich.ts
 import { z as z27 } from "zod";
-import * as fs29 from "fs/promises";
+import * as fs30 from "fs/promises";
 import * as path30 from "path";
 function hasSkipWikilinks(content) {
   if (!content.startsWith("---")) return false;
@@ -18004,7 +18222,7 @@ function hasSkipWikilinks(content) {
 async function collectMarkdownFiles(dirPath, basePath, excludeFolders) {
   const results = [];
   try {
-    const entries = await fs29.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs30.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
       const fullPath = path30.join(dirPath, entry.name);
@@ -18079,7 +18297,7 @@ function registerInitTools(server2, vaultPath2, getStateDb) {
         const fullPath = path30.join(vaultPath2, relativePath);
         let content;
         try {
-          content = await fs29.readFile(fullPath, "utf-8");
+          content = await fs30.readFile(fullPath, "utf-8");
         } catch {
           continue;
         }
@@ -18107,7 +18325,7 @@ function registerInitTools(server2, vaultPath2, getStateDb) {
         });
         if (!dry_run) {
           const fullPath = path30.join(vaultPath2, relativePath);
-          await fs29.writeFile(fullPath, result.content, "utf-8");
+          await fs30.writeFile(fullPath, result.content, "utf-8");
           notesModified++;
           if (stateDb2) {
             trackWikilinkApplications(stateDb2, relativePath, entities);
@@ -18466,7 +18684,7 @@ function registerActivityTools(server2, getStateDb, getSessionId2) {
 import { z as z30 } from "zod";
 
 // src/core/read/similarity.ts
-import * as fs30 from "fs";
+import * as fs31 from "fs";
 import * as path31 from "path";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
@@ -18607,7 +18825,7 @@ function findSimilarNotes(db4, vaultPath2, index, sourcePath, options = {}) {
   const absPath = path31.join(vaultPath2, sourcePath);
   let content;
   try {
-    content = fs30.readFileSync(absPath, "utf-8");
+    content = fs31.readFileSync(absPath, "utf-8");
   } catch {
     return [];
   }
@@ -18685,6 +18903,7 @@ async function findSemanticSimilarNotes(vaultPath2, index, sourcePath, options =
 }
 async function findHybridSimilarNotes(db4, vaultPath2, index, sourcePath, options = {}) {
   const limit = options.limit ?? 10;
+  const diversity = options.diversity ?? 0.7;
   const bm25Results = findSimilarNotes(db4, vaultPath2, index, sourcePath, {
     limit: limit * 2,
     excludeLinked: options.excludeLinked
@@ -18716,7 +18935,19 @@ async function findHybridSimilarNotes(db4, vaultPath2, index, sourcePath, option
     };
   });
   merged.sort((a, b) => b.score - a.score);
-  return merged.slice(0, limit);
+  if (merged.length > limit) {
+    const noteEmbeddings = loadNoteEmbeddingsForPaths(merged.map((m) => m.path));
+    const mmrCandidates = merged.map((m) => ({
+      id: m.path,
+      score: m.score,
+      embedding: noteEmbeddings.get(m.path) ?? null
+    }));
+    const mmrSelected = selectByMmr(mmrCandidates, limit, diversity);
+    const selectedPaths = new Set(mmrSelected.map((m) => m.id));
+    const mergedMap = new Map(merged.map((m) => [m.path, m]));
+    return mmrSelected.map((m) => mergedMap.get(m.id)).filter(Boolean);
+  }
+  return merged;
 }
 
 // src/tools/read/similarity.ts
@@ -18729,10 +18960,11 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
       inputSchema: {
         path: z30.string().describe('Path to the source note (relative to vault root, e.g. "projects/alpha.md")'),
         limit: z30.number().optional().describe("Maximum number of similar notes to return (default: 10)"),
-        exclude_linked: z30.boolean().optional().describe("Exclude notes already linked to/from the source note (default: true)")
+        exclude_linked: z30.boolean().optional().describe("Exclude notes already linked to/from the source note (default: true)"),
+        diversity: z30.number().min(0).max(1).optional().describe("Relevance vs diversity tradeoff (0=max diversity, 1=pure relevance, default: 0.7)")
       }
     },
-    async ({ path: path33, limit, exclude_linked }) => {
+    async ({ path: path33, limit, exclude_linked, diversity }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const stateDb2 = getStateDb();
@@ -18751,7 +18983,8 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
       }
       const opts = {
         limit: limit ?? 10,
-        excludeLinked: exclude_linked ?? true
+        excludeLinked: exclude_linked ?? true,
+        diversity: diversity ?? 0.7
       };
       const useHybrid = hasEmbeddingsIndex();
       const method = useHybrid ? "hybrid" : "bm25";
@@ -18997,7 +19230,7 @@ function registerMergeTools2(server2, getStateDb) {
 }
 
 // src/index.ts
-import * as fs31 from "node:fs/promises";
+import * as fs32 from "node:fs/promises";
 import { createHash as createHash3 } from "node:crypto";
 
 // src/resources/vault.ts
@@ -19106,7 +19339,7 @@ function registerVaultResources(server2, getIndex) {
 // src/index.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname4(__filename);
-var pkg = JSON.parse(readFileSync4(join17(__dirname, "../package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync5(join17(__dirname, "../package.json"), "utf-8"));
 var vaultPath = process.env.PROJECT_PATH || process.env.VAULT_PATH || findVaultRoot();
 var resolvedVaultPath;
 try {
@@ -19413,7 +19646,7 @@ registerSimilarityTools(server, () => vaultIndex, () => vaultPath, () => stateDb
 registerSemanticTools(server, () => vaultPath, () => stateDb);
 registerMergeTools2(server, () => stateDb);
 registerMemoryTools(server, () => stateDb);
-registerRecallTools(server, () => stateDb);
+registerRecallTools(server, () => stateDb, () => vaultPath);
 registerBriefTools(server, () => stateDb);
 registerVaultResources(server, () => vaultIndex ?? null);
 serverLog("server", `Registered ${_registeredCount} tools, skipped ${_skippedCount}`);
@@ -19559,7 +19792,7 @@ async function buildStartupCatchupBatch(vaultPath2, sinceMs) {
   async function scanDir(dir) {
     let entries;
     try {
-      entries = await fs31.readdir(dir, { withFileTypes: true });
+      entries = await fs32.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -19570,7 +19803,7 @@ async function buildStartupCatchupBatch(vaultPath2, sinceMs) {
         await scanDir(fullPath);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
         try {
-          const stat4 = await fs31.stat(fullPath);
+          const stat4 = await fs32.stat(fullPath);
           if (stat4.mtimeMs > sinceMs) {
             events.push({
               type: "upsert",
@@ -19773,7 +20006,7 @@ async function runPostIndexWork(index) {
           continue;
         }
         try {
-          const content = await fs31.readFile(path32.join(vaultPath, event.path), "utf-8");
+          const content = await fs32.readFile(path32.join(vaultPath, event.path), "utf-8");
           const hash = createHash3("sha256").update(content).digest("hex").slice(0, 16);
           if (lastContentHashes.get(event.path) === hash) {
             serverLog("watcher", `Hash unchanged, skipping: ${event.path}`);
@@ -20211,7 +20444,7 @@ async function runPostIndexWork(index) {
         for (const event of filteredEvents) {
           if (event.type === "delete" || !event.path.endsWith(".md")) continue;
           try {
-            const content = await fs31.readFile(path32.join(vaultPath, event.path), "utf-8");
+            const content = await fs32.readFile(path32.join(vaultPath, event.path), "utf-8");
             const zones = getProtectedZones2(content);
             const linked = new Set(
               (forwardLinkResults.find((r) => r.file === event.path)?.resolved ?? []).map((n) => n.toLowerCase())
@@ -20252,7 +20485,7 @@ async function runPostIndexWork(index) {
           for (const event of filteredEvents) {
             if (event.type === "delete" || !event.path.endsWith(".md")) continue;
             try {
-              const content = await fs31.readFile(path32.join(vaultPath, event.path), "utf-8");
+              const content = await fs32.readFile(path32.join(vaultPath, event.path), "utf-8");
               const removed = processImplicitFeedback(stateDb, event.path, content);
               for (const entity of removed) feedbackResults.push({ entity, file: event.path });
             } catch {
@@ -20332,7 +20565,7 @@ async function runPostIndexWork(index) {
         for (const event of filteredEvents) {
           if (event.type === "delete" || !event.path.endsWith(".md")) continue;
           try {
-            const content = await fs31.readFile(path32.join(vaultPath, event.path), "utf-8");
+            const content = await fs32.readFile(path32.join(vaultPath, event.path), "utf-8");
             const zones = getProtectedZones2(content);
             const linkedSet = new Set(
               (forwardLinkResults.find((r) => r.file === event.path)?.resolved ?? []).concat(forwardLinkResults.find((r) => r.file === event.path)?.dead ?? []).map((n) => n.toLowerCase())
@@ -20365,7 +20598,7 @@ async function runPostIndexWork(index) {
         for (const event of filteredEvents) {
           if (event.type === "delete" || !event.path.endsWith(".md")) continue;
           try {
-            const content = await fs31.readFile(path32.join(vaultPath, event.path), "utf-8");
+            const content = await fs32.readFile(path32.join(vaultPath, event.path), "utf-8");
             const result = await suggestRelatedLinks(content, {
               maxSuggestions: 5,
               strictness: "balanced",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.73",
+  "version": "2.0.75",
   "description": "MCP server that gives Claude full read/write access to your Obsidian vault. Select from 51 tools for search, backlinks, graph queries, mutations, agent memory, and hybrid semantic search.",
   "type": "module",
   "main": "dist/index.js",
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@velvetmonkey/vault-core": "^2.0.73",
+    "@velvetmonkey/vault-core": "^2.0.75",
     "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",