@velvetmonkey/flywheel-memory 2.0.126 → 2.0.128

package/dist/index.js

@@ -4065,8 +4065,8 @@ async function suggestRelatedLinks(content, options = {}) {
     return emptyResult;
   }
   const MAX_SUFFIX_ENTRIES = 3;
-  const MIN_SUFFIX_SCORE = 12;
-  const MIN_SUFFIX_CONTENT = 3;
+  const MIN_SUFFIX_SCORE = noteContext === "daily" ? 8 : 12;
+  const MIN_SUFFIX_CONTENT = noteContext === "daily" ? 2 : 3;
   const suffixEntries = topEntries.filter(
     (e) => e.score >= MIN_SUFFIX_SCORE && (e.breakdown.contentMatch >= MIN_SUFFIX_CONTENT || e.breakdown.cooccurrenceBoost >= MIN_SUFFIX_CONTENT || (e.breakdown.semanticBoost ?? 0) >= MIN_SUFFIX_CONTENT)
   ).slice(0, MAX_SUFFIX_ENTRIES);
@@ -4552,7 +4552,7 @@ var init_constants = __esm({
 });
 
 // src/core/write/writer.ts
-import fs19 from "fs/promises";
+import fs20 from "fs/promises";
 import path21 from "path";
 import matter5 from "gray-matter";
 import { createHash as createHash2 } from "node:crypto";
@@ -4940,9 +4940,9 @@ async function validatePathSecure(vaultPath2, notePath) {
   try {
     const fullPath = path21.join(vaultPath2, notePath);
     try {
-      await fs19.access(fullPath);
-      const realPath = await fs19.realpath(fullPath);
-      const realVaultPath = await fs19.realpath(vaultPath2);
+      await fs20.access(fullPath);
+      const realPath = await fs20.realpath(fullPath);
+      const realVaultPath = await fs20.realpath(vaultPath2);
       if (!realPath.startsWith(realVaultPath)) {
         return {
           valid: false,
@@ -4959,9 +4959,9 @@ async function validatePathSecure(vaultPath2, notePath) {
     } catch {
       const parentDir = path21.dirname(fullPath);
       try {
-        await fs19.access(parentDir);
-        const realParentPath = await fs19.realpath(parentDir);
-        const realVaultPath = await fs19.realpath(vaultPath2);
+        await fs20.access(parentDir);
+        const realParentPath = await fs20.realpath(parentDir);
+        const realVaultPath = await fs20.realpath(vaultPath2);
         if (!realParentPath.startsWith(realVaultPath)) {
           return {
             valid: false,
@@ -4988,8 +4988,8 @@ async function readVaultFile(vaultPath2, notePath) {
   }
   const fullPath = path21.join(vaultPath2, notePath);
   const [rawContent, stat5] = await Promise.all([
-    fs19.readFile(fullPath, "utf-8"),
-    fs19.stat(fullPath)
+    fs20.readFile(fullPath, "utf-8"),
+    fs20.stat(fullPath)
   ]);
   const contentHash2 = computeContentHash(rawContent);
   const lineEnding = detectLineEnding(rawContent);
@@ -5043,7 +5043,7 @@ async function writeVaultFile(vaultPath2, notePath, content, frontmatter, lineEn
   }
   const fullPath = path21.join(vaultPath2, notePath);
   if (expectedHash) {
-    const currentRaw = await fs19.readFile(fullPath, "utf-8");
+    const currentRaw = await fs20.readFile(fullPath, "utf-8");
     const currentHash = computeContentHash(currentRaw);
     if (currentHash !== expectedHash) {
       throw new WriteConflictError(notePath);
@@ -5052,7 +5052,7 @@ async function writeVaultFile(vaultPath2, notePath, content, frontmatter, lineEn
   let output = matter5.stringify(content, frontmatter);
   output = normalizeTrailingNewline(output);
   output = convertLineEndings(output, lineEnding);
-  await fs19.writeFile(fullPath, output, "utf-8");
+  await fs20.writeFile(fullPath, output, "utf-8");
 }
 function removeFromSection(content, section, pattern, mode = "first", useRegex = false) {
   const lines = content.split("\n");
@@ -5899,7 +5899,7 @@ __export(conditions_exports, {
   evaluateCondition: () => evaluateCondition,
   shouldStepExecute: () => shouldStepExecute
 });
-import fs26 from "fs/promises";
+import fs27 from "fs/promises";
 import path27 from "path";
 async function evaluateCondition(condition, vaultPath2, context) {
   const interpolatedPath = condition.path ? interpolate(condition.path, context) : void 0;
@@ -5955,7 +5955,7 @@ async function evaluateCondition(condition, vaultPath2, context) {
 async function evaluateFileExists(vaultPath2, notePath, expectExists) {
   const fullPath = path27.join(vaultPath2, notePath);
   try {
-    await fs26.access(fullPath);
+    await fs27.access(fullPath);
     return {
       met: expectExists,
       reason: expectExists ? `File exists: ${notePath}` : `File exists (expected not to): ${notePath}`
@@ -5970,7 +5970,7 @@ async function evaluateFileExists(vaultPath2, notePath, expectExists) {
 async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectExists) {
   const fullPath = path27.join(vaultPath2, notePath);
   try {
-    await fs26.access(fullPath);
+    await fs27.access(fullPath);
   } catch {
     return {
       met: !expectExists,
@@ -6001,7 +6001,7 @@ async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectEx
 async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expectExists) {
   const fullPath = path27.join(vaultPath2, notePath);
   try {
-    await fs26.access(fullPath);
+    await fs27.access(fullPath);
   } catch {
     return {
       met: !expectExists,
@@ -6032,7 +6032,7 @@ async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expect
 async function evaluateFrontmatterEquals(vaultPath2, notePath, fieldName, expectedValue) {
   const fullPath = path27.join(vaultPath2, notePath);
   try {
-    await fs26.access(fullPath);
+    await fs27.access(fullPath);
   } catch {
     return {
       met: false,
@@ -11206,6 +11206,149 @@ function expandQuery(expansionTerms, primaryResults, index, stateDb2) {
 }
 
 // src/tools/read/query.ts
+init_wikilinkFeedback();
+init_cooccurrence();
+init_wikilinks();
+init_recency();
+init_edgeWeights();
+
+// src/core/read/snippets.ts
+init_embeddings();
+init_stemmer();
+import * as fs12 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 = fs12.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/query.ts
+init_stemmer();
+function applyGraphReranking(results, stateDb2) {
+  if (!stateDb2) return;
+  const cooccurrenceIndex2 = getCooccurrenceIndex();
+  const recencyIndex2 = loadRecencyFromStateDb();
+  const feedbackBoosts = getAllFeedbackBoosts(stateDb2);
+  const edgeWeightMap = getEntityEdgeWeightMap(stateDb2);
+  if (!cooccurrenceIndex2 && !recencyIndex2) return;
+  const seedEntities = /* @__PURE__ */ new Set();
+  for (const r of results) {
+    const name = r.title || r.path?.replace(/\.md$/, "").split("/").pop() || "";
+    if (name) seedEntities.add(name);
+  }
+  for (const r of results) {
+    const name = r.title || r.path?.replace(/\.md$/, "").split("/").pop() || "";
+    let graphBoost = 0;
+    if (cooccurrenceIndex2) graphBoost += getCooccurrenceBoost(name, seedEntities, cooccurrenceIndex2, recencyIndex2);
+    if (recencyIndex2) graphBoost += getRecencyBoost(name, recencyIndex2);
+    graphBoost += feedbackBoosts.get(name) ?? 0;
+    const avgWeight = edgeWeightMap.get(name.toLowerCase());
+    if (avgWeight && avgWeight > 1) graphBoost += Math.min((avgWeight - 1) * 3, 6);
+    if (graphBoost > 0) {
+      r.graph_boost = graphBoost;
+      const baseScore = r.rrf_score ?? 0;
+      r._combined_score = baseScore + graphBoost / 50;
+    }
+  }
+  results.sort(
+    (a, b) => (b._combined_score ?? b.rrf_score ?? 0) - (a._combined_score ?? a.rrf_score ?? 0)
+  );
+}
+async function enhanceSnippets(results, query, vaultPath2) {
+  if (!hasEmbeddingsIndex()) return;
+  const queryTokens = tokenize(query).map((t) => t.toLowerCase());
+  let queryEmb = null;
+  try {
+    queryEmb = await embedTextCached(query);
+  } catch {
+  }
+  for (const r of results) {
+    if (!r.path) continue;
+    try {
+      const snippets = await extractBestSnippets(`${vaultPath2}/${r.path}`, queryEmb, queryTokens);
+      if (snippets.length > 0 && snippets[0].text.length > 0) {
+        r.snippet = snippets[0].text;
+      }
+    } catch {
+    }
+  }
+}
 function matchesFrontmatter(note, where) {
   for (const [key, value] of Object.entries(where)) {
     const noteValue = note.frontmatter[key];
@@ -11469,6 +11612,8 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb2) {
             const expansionTerms2 = extractExpansionTerms(results2, query, index);
             const expansionResults2 = expandQuery(expansionTerms2, [...results2, ...hopResults2], index, stateDb2);
             results2.push(...hopResults2, ...expansionResults2);
+            applyGraphReranking(results2, stateDb2);
+            await enhanceSnippets(results2, query, vaultPath2);
             return { content: [{ type: "text", text: JSON.stringify({
               method: "hybrid",
               query,
@@ -11498,6 +11643,8 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb2) {
           const expansionTerms2 = extractExpansionTerms(results2, query, index);
           const expansionResults2 = expandQuery(expansionTerms2, [...results2, ...hopResults2], index, stateDb2);
           results2.push(...hopResults2, ...expansionResults2);
+          applyGraphReranking(results2, stateDb2);
+          await enhanceSnippets(results2, query, vaultPath2);
           return { content: [{ type: "text", text: JSON.stringify({
             method: "fts5",
             query,
@@ -11512,6 +11659,8 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb2) {
         const expansionTerms = extractExpansionTerms(results, query, index);
         const expansionResults = expandQuery(expansionTerms, [...results, ...hopResults], index, stateDbFts);
         results.push(...hopResults, ...expansionResults);
+        applyGraphReranking(results, stateDbFts);
+        await enhanceSnippets(results, query, vaultPath2);
         return { content: [{ type: "text", text: JSON.stringify({
           method: "fts5",
           query,
@@ -11525,7 +11674,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb2) {
 }
 
 // src/tools/read/system.ts
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as path15 from "path";
 import { z as z5 } from "zod";
 import { scanVaultEntities as scanVaultEntities2, getEntityIndexFromDb as getEntityIndexFromDb2 } from "@velvetmonkey/vault-core";
@@ -11840,7 +11989,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
         }
         try {
           const fullPath = path15.join(vaultPath2, note.path);
-          const content = await fs12.promises.readFile(fullPath, "utf-8");
+          const content = await fs13.promises.readFile(fullPath, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
@@ -12099,7 +12248,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
 import { z as z6 } from "zod";
 
 // src/tools/read/structure.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as path16 from "path";
 var HEADING_REGEX2 = /^(#{1,6})\s+(.+)$/;
 function extractHeadings2(content) {
@@ -12157,7 +12306,7 @@ async function getNoteStructure(index, notePath, vaultPath2) {
   const absolutePath = path16.join(vaultPath2, notePath);
   let content;
   try {
-    content = await fs13.promises.readFile(absolutePath, "utf-8");
+    content = await fs14.promises.readFile(absolutePath, "utf-8");
   } catch {
     return null;
   }
@@ -12180,7 +12329,7 @@ async function getSectionContent(index, notePath, headingText, vaultPath2, inclu
   const absolutePath = path16.join(vaultPath2, notePath);
   let content;
   try {
-    content = await fs13.promises.readFile(absolutePath, "utf-8");
+    content = await fs14.promises.readFile(absolutePath, "utf-8");
   } catch {
     return null;
   }
@@ -12222,7 +12371,7 @@ async function findSections(index, headingPattern, vaultPath2, folder) {
     const absolutePath = path16.join(vaultPath2, note.path);
     let content;
     try {
-      content = await fs13.promises.readFile(absolutePath, "utf-8");
+      content = await fs14.promises.readFile(absolutePath, "utf-8");
     } catch {
       continue;
     }
@@ -12546,7 +12695,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
 
 // src/tools/read/migrations.ts
 import { z as z7 } from "zod";
-import * as fs14 from "fs/promises";
+import * as fs15 from "fs/promises";
 import * as path17 from "path";
 import matter2 from "gray-matter";
 function getNotesInFolder(index, folder) {
@@ -12562,7 +12711,7 @@ function getNotesInFolder(index, folder) {
 async function readFileContent(notePath, vaultPath2) {
   const fullPath = path17.join(vaultPath2, notePath);
   try {
-    return await fs14.readFile(fullPath, "utf-8");
+    return await fs15.readFile(fullPath, "utf-8");
   } catch {
     return null;
   }
@@ -12570,7 +12719,7 @@ async function readFileContent(notePath, vaultPath2) {
 async function writeFileContent(notePath, vaultPath2, content) {
   const fullPath = path17.join(vaultPath2, notePath);
   try {
-    await fs14.writeFile(fullPath, content, "utf-8");
+    await fs15.writeFile(fullPath, content, "utf-8");
     return true;
   } catch {
     return false;
@@ -12748,7 +12897,7 @@ function registerMigrationTools(server2, getIndex, getVaultPath) {
 }
 
 // src/tools/read/graphAnalysis.ts
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 import path18 from "node:path";
 import { z as z8 } from "zod";
 
@@ -13462,7 +13611,7 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb2
           const scored = allNotes.map((note) => {
             let wordCount = 0;
             try {
-              const content = fs15.readFileSync(path18.join(vaultPath2, note.path), "utf-8");
+              const content = fs16.readFileSync(path18.join(vaultPath2, note.path), "utf-8");
               const body = content.replace(/^---[\s\S]*?---\n?/, "");
               wordCount = body.split(/\s+/).filter((w) => w.length > 0).length;
             } catch {
@@ -14092,7 +14241,7 @@ function registerSemanticAnalysisTools(server2, getIndex, getVaultPath) {
 import { z as z11 } from "zod";
 
 // src/tools/read/bidirectional.ts
-import * as fs16 from "fs/promises";
+import * as fs17 from "fs/promises";
 import * as path19 from "path";
 import matter3 from "gray-matter";
 var PROSE_PATTERN_REGEX = /^([A-Za-z][A-Za-z0-9 _-]*):\s*(?:\[\[([^\]]+)\]\]|"([^"]+)"|([^\n]+?))\s*$/gm;
@@ -14100,7 +14249,7 @@ var CODE_BLOCK_REGEX2 = /```[\s\S]*?```|`[^`\n]+`/g;
 async function readFileContent2(notePath, vaultPath2) {
   const fullPath = path19.join(vaultPath2, notePath);
   try {
-    return await fs16.readFile(fullPath, "utf-8");
+    return await fs17.readFile(fullPath, "utf-8");
   } catch {
     return null;
   }
@@ -14276,13 +14425,13 @@ async function suggestWikilinksInFrontmatter(index, notePath, vaultPath2) {
 }
 
 // src/tools/read/computed.ts
-import * as fs17 from "fs/promises";
+import * as fs18 from "fs/promises";
 import * as path20 from "path";
 import matter4 from "gray-matter";
 async function readFileContent3(notePath, vaultPath2) {
   const fullPath = path20.join(vaultPath2, notePath);
   try {
-    return await fs17.readFile(fullPath, "utf-8");
+    return await fs18.readFile(fullPath, "utf-8");
   } catch {
     return null;
   }
@@ -14290,7 +14439,7 @@ async function readFileContent3(notePath, vaultPath2) {
 async function getFileStats(notePath, vaultPath2) {
   const fullPath = path20.join(vaultPath2, notePath);
   try {
-    const stats = await fs17.stat(fullPath);
+    const stats = await fs18.stat(fullPath);
     return {
       modified: stats.mtime,
       created: stats.birthtime
@@ -14420,7 +14569,7 @@ async function computeFrontmatter(index, notePath, vaultPath2, fields) {
 
 // src/tools/read/noteIntelligence.ts
 init_embeddings();
-import fs18 from "node:fs";
+import fs19 from "node:fs";
 import nodePath from "node:path";
 function registerNoteIntelligenceTools(server2, getIndex, getVaultPath, getConfig2) {
   server2.registerTool(
@@ -14480,7 +14629,7 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath, getConfi
           }
           let noteContent;
           try {
-            noteContent = fs18.readFileSync(nodePath.join(vaultPath2, notePath), "utf-8");
+            noteContent = fs19.readFileSync(nodePath.join(vaultPath2, notePath), "utf-8");
           } catch {
             return {
               content: [{ type: "text", text: JSON.stringify({
@@ -14559,7 +14708,7 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath, getConfi
 // src/tools/write/mutations.ts
 init_writer();
 import { z as z12 } from "zod";
-import fs21 from "fs/promises";
+import fs22 from "fs/promises";
 import path23 from "path";
 
 // src/core/write/validator.ts
@@ -14778,7 +14927,7 @@ init_constants();
 init_writer();
 init_wikilinks();
 init_wikilinkFeedback();
-import fs20 from "fs/promises";
+import fs21 from "fs/promises";
 import path22 from "path";
 function formatMcpResult(result) {
   if (result.tokensEstimate === void 0 || result.tokensEstimate === 0) {
@@ -14828,7 +14977,7 @@ async function handleGitCommit(vaultPath2, notePath, commit, prefix) {
 async function getPolicyHint(vaultPath2) {
   try {
     const policiesDir = path22.join(vaultPath2, ".claude", "policies");
-    const files = await fs20.readdir(policiesDir);
+    const files = await fs21.readdir(policiesDir);
     const yamlFiles = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
     if (yamlFiles.length > 0) {
       const names = yamlFiles.map((f) => f.replace(/\.ya?ml$/, "")).join(", ");
@@ -14841,7 +14990,7 @@ async function getPolicyHint(vaultPath2) {
 async function ensureFileExists(vaultPath2, notePath) {
   const fullPath = path22.join(vaultPath2, notePath);
   try {
-    await fs20.access(fullPath);
+    await fs21.access(fullPath);
     return null;
   } catch {
     const hint = await getPolicyHint(vaultPath2);
@@ -15020,14 +15169,14 @@ async function executeCreateNote(options) {
     const fullPath = path22.join(vaultPath2, notePath);
     let fileExists = false;
     try {
-      await fs20.access(fullPath);
+      await fs21.access(fullPath);
       fileExists = true;
     } catch {
     }
     if (fileExists && !overwrite) {
       return { success: false, result: errorResult(notePath, `File already exists: ${notePath}. Use overwrite=true to replace.`), filesWritten: [] };
     }
-    await fs20.mkdir(path22.dirname(fullPath), { recursive: true });
+    await fs21.mkdir(path22.dirname(fullPath), { recursive: true });
     const { maybeApplyWikilinks: maybeApplyWikilinks2 } = await Promise.resolve().then(() => (init_wikilinks(), wikilinks_exports));
     const { content: processedContent } = maybeApplyWikilinks2(content, skipWikilinks ?? false, notePath);
     let finalFrontmatter = frontmatter;
@@ -15063,11 +15212,11 @@ async function executeDeleteNote(options) {
     }
     const fullPath = path22.join(vaultPath2, notePath);
     try {
-      await fs20.access(fullPath);
+      await fs21.access(fullPath);
     } catch {
       return { success: false, result: errorResult(notePath, `File not found: ${notePath}`), filesWritten: [] };
     }
-    await fs20.unlink(fullPath);
+    await fs21.unlink(fullPath);
     const result = successResult(notePath, `Deleted note: ${notePath}`, {});
     return { success: true, result, filesWritten: [notePath] };
   } catch (error) {
@@ -15086,7 +15235,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
     throw new Error(`Path blocked: ${validation.reason}`);
   }
   const fullPath = path23.join(vaultPath2, notePath);
-  await fs21.mkdir(path23.dirname(fullPath), { recursive: true });
+  await fs22.mkdir(path23.dirname(fullPath), { recursive: true });
   const templates = config.templates || {};
   const filename = path23.basename(notePath, ".md").toLowerCase();
   let templatePath;
@@ -15110,7 +15259,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   if (templatePath) {
     try {
       const absTemplatePath = path23.join(vaultPath2, templatePath);
-      templateContent = await fs21.readFile(absTemplatePath, "utf-8");
+      templateContent = await fs22.readFile(absTemplatePath, "utf-8");
     } catch {
       const title = path23.basename(notePath, ".md");
       templateContent = `---
@@ -15173,7 +15322,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
       if (create_if_missing && !dry_run) {
         const fullPath = path23.join(vaultPath2, notePath);
         try {
-          await fs21.access(fullPath);
+          await fs22.access(fullPath);
         } catch {
           const config = getConfig2();
           const result = await createNoteFromTemplate(vaultPath2, notePath, config);
@@ -15184,7 +15333,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
       if (create_if_missing && dry_run) {
         const fullPath = path23.join(vaultPath2, notePath);
         try {
-          await fs21.access(fullPath);
+          await fs22.access(fullPath);
         } catch {
           return {
             content: [{
@@ -15669,7 +15818,7 @@ Example: vault_update_frontmatter({ path: "projects/alpha.md", frontmatter: { st
 init_writer();
 init_wikilinks();
 import { z as z15 } from "zod";
-import fs22 from "fs/promises";
+import fs23 from "fs/promises";
 import path24 from "path";
 function registerNoteTools(server2, getVaultPath, getIndex) {
   server2.tool(
@@ -15702,13 +15851,13 @@ function registerNoteTools(server2, getVaultPath, getIndex) {
           return formatMcpResult(errorResult(notePath, `File already exists: ${notePath}. Use overwrite=true to replace.`));
         }
         const dir = path24.dirname(fullPath);
-        await fs22.mkdir(dir, { recursive: true });
+        await fs23.mkdir(dir, { recursive: true });
         let effectiveContent = content;
         let effectiveFrontmatter = frontmatter;
         if (template) {
           const templatePath = path24.join(vaultPath2, template);
           try {
-            const raw = await fs22.readFile(templatePath, "utf-8");
+            const raw = await fs23.readFile(templatePath, "utf-8");
             const matter9 = (await import("gray-matter")).default;
             const parsed = matter9(raw);
             const dateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -15873,7 +16022,7 @@ ${sources}`;
           return formatMcpResult(errorResult(notePath, previewLines.join("\n")));
         }
         const fullPath = path24.join(vaultPath2, notePath);
-        await fs22.unlink(fullPath);
+        await fs23.unlink(fullPath);
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Flywheel:Delete]");
         const message = backlinkWarning ? `Deleted note: ${notePath}
 
@@ -15893,7 +16042,7 @@ init_writer();
 init_git();
 init_wikilinks();
 import { z as z16 } from "zod";
-import fs23 from "fs/promises";
+import fs24 from "fs/promises";
 import path25 from "path";
 import matter6 from "gray-matter";
 function escapeRegex(str) {
@@ -15920,7 +16069,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   const allTargets = [targetTitle, ...targetAliases].map((t) => t.toLowerCase());
   async function scanDir(dir) {
     const files = [];
-    const entries = await fs23.readdir(dir, { withFileTypes: true });
+    const entries = await fs24.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path25.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
@@ -15934,7 +16083,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   const allFiles = await scanDir(vaultPath2);
   for (const filePath of allFiles) {
     const relativePath = path25.relative(vaultPath2, filePath);
-    const content = await fs23.readFile(filePath, "utf-8");
+    const content = await fs24.readFile(filePath, "utf-8");
     const wikilinks = extractWikilinks2(content);
     const matchingLinks = [];
     for (const link of wikilinks) {
@@ -16023,7 +16172,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
         const oldFullPath = path25.join(vaultPath2, oldPath);
         const newFullPath = path25.join(vaultPath2, newPath);
         try {
-          await fs23.access(oldFullPath);
+          await fs24.access(oldFullPath);
         } catch {
           const result2 = {
             success: false,
@@ -16033,7 +16182,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
         try {
-          await fs23.access(newFullPath);
+          await fs24.access(newFullPath);
           const result2 = {
             success: false,
             message: `Destination already exists: ${newPath}`,
@@ -16042,7 +16191,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         } catch {
         }
-        const sourceContent = await fs23.readFile(oldFullPath, "utf-8");
+        const sourceContent = await fs24.readFile(oldFullPath, "utf-8");
         const parsed = matter6(sourceContent);
         const aliases = extractAliases2(parsed.data);
         const oldTitle = getTitleFromPath(oldPath);
@@ -16103,8 +16252,8 @@ function registerMoveNoteTools(server2, getVaultPath) {
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
         const destDir = path25.dirname(newFullPath);
-        await fs23.mkdir(destDir, { recursive: true });
-        await fs23.rename(oldFullPath, newFullPath);
+        await fs24.mkdir(destDir, { recursive: true });
+        await fs24.rename(oldFullPath, newFullPath);
         let gitCommit;
         let undoAvailable;
         let staleLockDetected;
@@ -16183,7 +16332,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
         const newPath = dir === "." ? `${sanitizedTitle}.md` : path25.join(dir, `${sanitizedTitle}.md`);
         const newFullPath = path25.join(vaultPath2, newPath);
         try {
-          await fs23.access(fullPath);
+          await fs24.access(fullPath);
         } catch {
           const result2 = {
             success: false,
@@ -16194,7 +16343,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
         }
         if (fullPath !== newFullPath) {
           try {
-            await fs23.access(newFullPath);
+            await fs24.access(newFullPath);
             const result2 = {
               success: false,
               message: `A note with this title already exists: ${newPath}`,
@@ -16204,7 +16353,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
           } catch {
           }
         }
-        const sourceContent = await fs23.readFile(fullPath, "utf-8");
+        const sourceContent = await fs24.readFile(fullPath, "utf-8");
         const parsed = matter6(sourceContent);
         const aliases = extractAliases2(parsed.data);
         const oldTitle = getTitleFromPath(notePath);
@@ -16264,7 +16413,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
         if (fullPath !== newFullPath) {
-          await fs23.rename(fullPath, newFullPath);
+          await fs24.rename(fullPath, newFullPath);
         }
         let gitCommit;
         let undoAvailable;
@@ -16312,7 +16461,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
 init_writer();
 init_wikilinks();
 import { z as z17 } from "zod";
-import fs24 from "fs/promises";
+import fs25 from "fs/promises";
 function registerMergeTools(server2, getVaultPath) {
   server2.tool(
     "merge_entities",
@@ -16439,7 +16588,7 @@ ${trimmedSource}`;
         }
         await writeVaultFile(vaultPath2, target_path, targetContent, targetFrontmatter, "LF", targetContentHash);
         const fullSourcePath = `${vaultPath2}/${source_path}`;
-        await fs24.unlink(fullSourcePath);
+        await fs25.unlink(fullSourcePath);
         initializeEntityIndex(vaultPath2).catch((err) => {
           console.error(`[Flywheel] Entity cache rebuild failed: ${err}`);
         });
@@ -16711,7 +16860,7 @@ init_schema();
 
 // src/core/write/policy/parser.ts
 init_schema();
-import fs25 from "fs/promises";
+import fs26 from "fs/promises";
 import path26 from "path";
 import matter7 from "gray-matter";
 function parseYaml(content) {
@@ -16737,7 +16886,7 @@ function parsePolicyString(yamlContent) {
 }
 async function loadPolicyFile(filePath) {
   try {
-    const content = await fs25.readFile(filePath, "utf-8");
+    const content = await fs26.readFile(filePath, "utf-8");
     return parsePolicyString(content);
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -16764,12 +16913,12 @@ async function loadPolicy(vaultPath2, policyName) {
   const policiesDir = path26.join(vaultPath2, ".claude", "policies");
   const policyPath = path26.join(policiesDir, `${policyName}.yaml`);
   try {
-    await fs25.access(policyPath);
+    await fs26.access(policyPath);
     return loadPolicyFile(policyPath);
   } catch {
     const ymlPath = path26.join(policiesDir, `${policyName}.yml`);
     try {
-      await fs25.access(ymlPath);
+      await fs26.access(ymlPath);
       return loadPolicyFile(ymlPath);
     } catch {
       return {
@@ -16909,7 +17058,7 @@ init_schema();
 init_writer();
 init_git();
 init_wikilinks();
-import fs27 from "fs/promises";
+import fs28 from "fs/promises";
 import path28 from "path";
 init_constants();
 async function executeStep(step, vaultPath2, context, conditionResults, searchFn) {
@@ -17120,7 +17269,7 @@ async function executeToggleTask(params, vaultPath2) {
   const section = params.section ? String(params.section) : void 0;
   const fullPath = path28.join(vaultPath2, notePath);
   try {
-    await fs27.access(fullPath);
+    await fs28.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -17404,12 +17553,12 @@ async function rollbackChanges(vaultPath2, originalContents, filesModified) {
     const fullPath = path28.join(vaultPath2, filePath);
     if (original === null) {
       try {
-        await fs27.unlink(fullPath);
+        await fs28.unlink(fullPath);
       } catch {
       }
     } else if (original !== void 0) {
       try {
-        await fs27.writeFile(fullPath, original);
+        await fs28.writeFile(fullPath, original);
       } catch {
       }
     }
@@ -17455,27 +17604,27 @@ async function previewPolicy(policy, vaultPath2, variables) {
 }
 
 // src/core/write/policy/storage.ts
-import fs28 from "fs/promises";
+import fs29 from "fs/promises";
 import path29 from "path";
 function getPoliciesDir(vaultPath2) {
   return path29.join(vaultPath2, ".claude", "policies");
 }
 async function ensurePoliciesDir(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
-  await fs28.mkdir(dir, { recursive: true });
+  await fs29.mkdir(dir, { recursive: true });
 }
 async function listPolicies(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
   const policies = [];
   try {
-    const files = await fs28.readdir(dir);
+    const files = await fs29.readdir(dir);
     for (const file of files) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
         continue;
       }
       const filePath = path29.join(dir, file);
-      const stat5 = await fs28.stat(filePath);
-      const content = await fs28.readFile(filePath, "utf-8");
+      const stat5 = await fs29.stat(filePath);
+      const content = await fs29.readFile(filePath, "utf-8");
       const metadata = extractPolicyMetadata(content);
       policies.push({
         name: metadata.name || file.replace(/\.ya?ml$/, ""),
@@ -17501,7 +17650,7 @@ async function writePolicyRaw(vaultPath2, policyName, content, overwrite = false
   const filePath = path29.join(dir, filename);
   if (!overwrite) {
     try {
-      await fs28.access(filePath);
+      await fs29.access(filePath);
       return {
         success: false,
         path: filename,
@@ -17518,7 +17667,7 @@ async function writePolicyRaw(vaultPath2, policyName, content, overwrite = false
       message: `Invalid policy: ${validation.errors.map((e) => e.message).join("; ")}`
     };
   }
-  await fs28.writeFile(filePath, content, "utf-8");
+  await fs29.writeFile(filePath, content, "utf-8");
   return {
     success: true,
     path: filename,
@@ -18043,7 +18192,7 @@ function registerPolicyTools(server2, getVaultPath, getSearchFn) {
 import { z as z21 } from "zod";
 
 // src/core/write/tagRename.ts
-import * as fs29 from "fs/promises";
+import * as fs30 from "fs/promises";
 import * as path30 from "path";
 import matter8 from "gray-matter";
 import { getProtectedZones } from "@velvetmonkey/vault-core";
@@ -18153,7 +18302,7 @@ async function renameTag(index, vaultPath2, oldTag, newTag, options) {
     const fullPath = path30.join(vaultPath2, note.path);
     let fileContent;
     try {
-      fileContent = await fs29.readFile(fullPath, "utf-8");
+      fileContent = await fs30.readFile(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -18226,7 +18375,7 @@ async function renameTag(index, vaultPath2, oldTag, newTag, options) {
       previews.push(preview);
       if (!dryRun) {
         const newContent = matter8.stringify(updatedContent, fm);
-        await fs29.writeFile(fullPath, newContent, "utf-8");
+        await fs30.writeFile(fullPath, newContent, "utf-8");
       }
     }
   }
@@ -19158,92 +19307,6 @@ function selectByMmr(candidates, limit, lambda = 0.7) {
   return selected;
 }
 
-// src/core/read/snippets.ts
-init_embeddings();
-init_stemmer();
-import * as fs30 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 = fs30.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());
@@ -19277,7 +19340,7 @@ async function performRecall(stateDb2, query, options = {}) {
     focus,
     entity,
     max_tokens,
-    diversity = 0.7,
+    diversity = 1,
     vaultPath: vaultPath2
   } = options;
   const results = [];
@@ -19534,6 +19597,12 @@ function registerRecallTools(server2, getStateDb2, getVaultPath, getIndex) {
       const hopResults = index ? multiHopBackfill(enrichedNotes, index, stateDb2, {
         maxBackfill: Math.max(5, (args.max_results ?? 10) - notes.length)
       }) : [];
+      if (index) {
+        const allNoteResults = [...enrichedNotes, ...hopResults];
+        const expansionTerms = extractExpansionTerms(allNoteResults, args.query, index);
+        const expansionResults = expandQuery(expansionTerms, allNoteResults, index, stateDb2);
+        hopResults.push(...expansionResults);
+      }
       return {
         content: [{
           type: "text",
@@ -23713,10 +23782,10 @@ async function runPostIndexWork(index) {
         for (const event of filteredEvents) {
           if (event.type === "delete" || !event.path.endsWith(".md")) continue;
           try {
-            const content = await fs33.readFile(path33.join(vaultPath, event.path), "utf-8");
+            const rawContent = await fs33.readFile(path33.join(vaultPath, event.path), "utf-8");
+            const content = rawContent.replace(/ → \[\[.*$/gm, "");
             const result = await suggestRelatedLinks(content, {
               maxSuggestions: 5,
-              strictness: "balanced",
               notePath: event.path,
               detail: true
             });
@@ -23742,7 +23811,6 @@ async function runPostIndexWork(index) {
           try {
             const proactiveResults = [];
             for (const { file, top } of suggestionResults) {
-              if (getNoteContext(file) === "daily") continue;
               try {
                 const result = await applyProactiveSuggestions(file, vaultPath, top, {
                   minScore: flywheelConfig?.proactive_min_score ?? 20,

package/package.json

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