@velvetmonkey/flywheel-memory 2.0.121 → 2.0.123

package/dist/index.js

@@ -7571,19 +7571,68 @@ function createVaultWatcher(options) {
 }
 
 // src/core/shared/hubExport.ts
+var EIGEN_ITERATIONS = 50;
 function computeHubScores(index) {
-  const hubScores = /* @__PURE__ */ new Map();
+  const nodes = [];
+  const nodeIdx = /* @__PURE__ */ new Map();
+  const adj = [];
   for (const note of index.notes.values()) {
-    const backlinks = getBacklinksForNote(index, note.path);
-    const backlinkCount = backlinks.length;
-    const normalizedPath = normalizeTarget(note.path);
-    hubScores.set(normalizedPath, backlinkCount);
-    const title = note.title.toLowerCase();
-    if (!hubScores.has(title) || backlinkCount > hubScores.get(title)) {
-      hubScores.set(title, backlinkCount);
+    const key = normalizeTarget(note.path);
+    if (!nodeIdx.has(key)) {
+      nodeIdx.set(key, nodes.length);
+      nodes.push(key);
+      adj.push([]);
+    }
+    const titleKey = note.title.toLowerCase();
+    if (!nodeIdx.has(titleKey)) {
+      nodeIdx.set(titleKey, nodeIdx.get(key));
+    }
+  }
+  const N = nodes.length;
+  if (N === 0) return /* @__PURE__ */ new Map();
+  for (const note of index.notes.values()) {
+    const fromIdx = nodeIdx.get(normalizeTarget(note.path));
+    if (fromIdx === void 0) continue;
+    for (const link of note.outlinks) {
+      const target = normalizeTarget(link.target);
+      let toIdx = nodeIdx.get(target);
+      if (toIdx === void 0) {
+        toIdx = nodeIdx.get(link.target.toLowerCase());
+      }
+      if (toIdx !== void 0 && toIdx !== fromIdx) {
+        adj[fromIdx].push(toIdx);
+        adj[toIdx].push(fromIdx);
+      }
     }
   }
-  return hubScores;
+  let scores = new Float64Array(N).fill(1 / N);
+  for (let iter = 0; iter < EIGEN_ITERATIONS; iter++) {
+    const next = new Float64Array(N);
+    for (let i = 0; i < N; i++) {
+      for (const j of adj[i]) {
+        next[i] += scores[j];
+      }
+    }
+    let norm = 0;
+    for (let i = 0; i < N; i++) norm += next[i] * next[i];
+    norm = Math.sqrt(norm);
+    if (norm > 0) {
+      for (let i = 0; i < N; i++) next[i] /= norm;
+    }
+    scores = next;
+  }
+  let maxScore = 0;
+  for (let i = 0; i < N; i++) {
+    if (scores[i] > maxScore) maxScore = scores[i];
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (let i = 0; i < N; i++) {
+    const scaled = maxScore > 0 ? Math.round(scores[i] / maxScore * 100) : 0;
+    if (scaled > 0) {
+      result.set(nodes[i], scaled);
+    }
+  }
+  return result;
 }
 function updateHubScoresInDb(stateDb2, hubScores) {
   const updateStmt = stateDb2.db.prepare(`
@@ -8510,6 +8559,162 @@ function getConnectionStrength(index, noteAPath, noteBPath) {
   }
   return { score, factors };
 }
+function computeCentralityMetrics(index, limit = 20) {
+  const paths = Array.from(index.notes.keys());
+  const N = paths.length;
+  if (N === 0) return [];
+  const pathIdx = /* @__PURE__ */ new Map();
+  paths.forEach((p, i) => pathIdx.set(p, i));
+  for (const note of index.notes.values()) {
+    const normalized = note.title.toLowerCase();
+    if (!pathIdx.has(normalized)) {
+      pathIdx.set(normalized, pathIdx.get(note.path));
+    }
+  }
+  const outAdj = Array.from({ length: N }, () => []);
+  const inAdj = Array.from({ length: N }, () => []);
+  for (const note of index.notes.values()) {
+    const fromIdx = pathIdx.get(note.path);
+    if (fromIdx === void 0) continue;
+    for (const link of note.outlinks) {
+      let toIdx = pathIdx.get(link.target);
+      if (toIdx === void 0) toIdx = pathIdx.get(link.target.toLowerCase());
+      if (toIdx !== void 0 && toIdx !== fromIdx) {
+        outAdj[fromIdx].push(toIdx);
+        inAdj[toIdx].push(fromIdx);
+      }
+    }
+  }
+  const degree = new Float64Array(N);
+  for (let i = 0; i < N; i++) {
+    degree[i] = outAdj[i].length + inAdj[i].length;
+  }
+  const betweenness = new Float64Array(N);
+  const closenessSum = new Float64Array(N);
+  const reachable = new Int32Array(N);
+  const undirAdj = Array.from({ length: N }, () => []);
+  for (let i = 0; i < N; i++) {
+    for (const j of outAdj[i]) {
+      undirAdj[i].push(j);
+      undirAdj[j].push(i);
+    }
+  }
+  for (let s = 0; s < N; s++) {
+    const stack = [];
+    const pred = Array.from({ length: N }, () => []);
+    const sigma = new Float64Array(N);
+    const dist = new Int32Array(N).fill(-1);
+    sigma[s] = 1;
+    dist[s] = 0;
+    const queue = [s];
+    let head = 0;
+    while (head < queue.length) {
+      const v = queue[head++];
+      stack.push(v);
+      for (const w of undirAdj[v]) {
+        if (dist[w] < 0) {
+          dist[w] = dist[v] + 1;
+          queue.push(w);
+        }
+        if (dist[w] === dist[v] + 1) {
+          sigma[w] += sigma[v];
+          pred[w].push(v);
+        }
+      }
+    }
+    for (let t = 0; t < N; t++) {
+      if (dist[t] > 0) {
+        closenessSum[s] += dist[t];
+        reachable[s]++;
+      }
+    }
+    const delta = new Float64Array(N);
+    while (stack.length > 0) {
+      const w = stack.pop();
+      for (const v of pred[w]) {
+        delta[v] += sigma[v] / sigma[w] * (1 + delta[w]);
+      }
+      if (w !== s) {
+        betweenness[w] += delta[w];
+      }
+    }
+  }
+  const normFactor = N > 2 ? (N - 1) * (N - 2) : 1;
+  const results = [];
+  for (let i = 0; i < N; i++) {
+    const note = index.notes.get(paths[i]);
+    results.push({
+      path: paths[i],
+      title: note?.title || paths[i],
+      degree: degree[i],
+      betweenness: Math.round(betweenness[i] / normFactor * 1e4) / 1e4,
+      closeness: reachable[i] > 0 ? Math.round(reachable[i] / closenessSum[i] * 1e4) / 1e4 : 0
+    });
+  }
+  results.sort((a, b) => b.betweenness - a.betweenness);
+  return results.slice(0, limit);
+}
+function detectCycles(index, maxLength = 10, limit = 20) {
+  const paths = Array.from(index.notes.keys());
+  const N = paths.length;
+  if (N === 0) return [];
+  const pathIdx = /* @__PURE__ */ new Map();
+  paths.forEach((p, i) => pathIdx.set(p, i));
+  for (const note of index.notes.values()) {
+    const normalized = note.title.toLowerCase();
+    if (!pathIdx.has(normalized)) {
+      pathIdx.set(normalized, pathIdx.get(note.path));
+    }
+  }
+  const adj = Array.from({ length: N }, () => []);
+  for (const note of index.notes.values()) {
+    const fromIdx = pathIdx.get(note.path);
+    if (fromIdx === void 0) continue;
+    for (const link of note.outlinks) {
+      let toIdx = pathIdx.get(link.target);
+      if (toIdx === void 0) toIdx = pathIdx.get(link.target.toLowerCase());
+      if (toIdx !== void 0 && toIdx !== fromIdx) {
+        adj[fromIdx].push(toIdx);
+      }
+    }
+  }
+  const WHITE = 0, GRAY = 1, BLACK = 2;
+  const color = new Uint8Array(N);
+  const cycles = [];
+  const stack = [];
+  function dfs(u) {
+    if (cycles.length >= limit) return;
+    color[u] = GRAY;
+    stack.push(u);
+    for (const v of adj[u]) {
+      if (cycles.length >= limit) return;
+      if (color[v] === GRAY) {
+        const cycleStart = stack.indexOf(v);
+        if (cycleStart >= 0) {
+          const cyclePath = stack.slice(cycleStart);
+          if (cyclePath.length <= maxLength) {
+            const note = (idx) => index.notes.get(paths[idx])?.title || paths[idx];
+            cycles.push({
+              cycle: cyclePath.map(note),
+              length: cyclePath.length
+            });
+          }
+        }
+      } else if (color[v] === WHITE) {
+        dfs(v);
+      }
+    }
+    stack.pop();
+    color[u] = BLACK;
+  }
+  for (let i = 0; i < N; i++) {
+    if (color[i] === WHITE && cycles.length < limit) {
+      dfs(i);
+    }
+  }
+  cycles.sort((a, b) => a.length - b.length);
+  return cycles;
+}
 
 // src/core/read/indexGuard.ts
 function requireIndex() {
@@ -9802,6 +10007,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
   });
   const HealthCheckOutputSchema = {
     status: z3.enum(["healthy", "degraded", "unhealthy"]).describe("Overall health status"),
+    vault_health_score: z3.coerce.number().describe("Composite vault health score (0-100)"),
     schema_version: z3.coerce.number().describe("StateDb schema version"),
     vault_accessible: z3.boolean().describe("Whether the vault path is accessible"),
     vault_path: z3.string().describe("The vault path being used"),
@@ -10033,8 +10239,37 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
         }
       }
       const topDeadLinkTargets = Array.from(deadTargetCounts.entries()).map(([target, mention_count]) => ({ target, mention_count })).sort((a, b) => b.mention_count - a.mention_count).slice(0, 5);
+      let vault_health_score = 0;
+      if (indexBuilt && noteCount > 0) {
+        const avgOutlinks = linkCount / noteCount;
+        const linkDensity = Math.min(1, avgOutlinks / 3);
+        let orphanCount = 0;
+        for (const note of index.notes.values()) {
+          const bl = index.backlinks.get(note.title.toLowerCase());
+          if (!bl || bl.length === 0) orphanCount++;
+        }
+        const orphanRatio = 1 - orphanCount / noteCount;
+        const totalLinks = linkCount > 0 ? linkCount : 1;
+        const deadLinkRatio = 1 - deadLinkCount / totalLinks;
+        let notesWithFm = 0;
+        for (const note of index.notes.values()) {
+          if (Object.keys(note.frontmatter).length > 0) notesWithFm++;
+        }
+        const fmCoverage = notesWithFm / noteCount;
+        const freshCutoff = Date.now() - 90 * 24 * 60 * 60 * 1e3;
+        let freshCount = 0;
+        for (const note of index.notes.values()) {
+          if (note.modified && note.modified.getTime() > freshCutoff) freshCount++;
+        }
+        const freshness = freshCount / noteCount;
+        const entityCoverage = Math.min(1, entityCount / (noteCount * 0.5));
+        vault_health_score = Math.round(
+          linkDensity * 25 + orphanRatio * 20 + deadLinkRatio * 15 + fmCoverage * 15 + freshness * 15 + entityCoverage * 10
+        );
+      }
       const output = {
         status,
+        vault_health_score,
         schema_version: SCHEMA_VERSION,
         vault_accessible: vaultAccessible,
         vault_path: vaultPath2,
@@ -10485,7 +10720,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
 import { z as z4 } from "zod";
 init_embeddings();
 import {
-  searchEntities,
+  searchEntities as searchEntities2,
   searchEntitiesPrefix
 } from "@velvetmonkey/vault-core";
 
@@ -10494,7 +10729,6 @@ import {
   getEntityByName as getEntityByName2
 } from "@velvetmonkey/vault-core";
 var TOP_LINKS = 10;
-var RECALL_TOP_LINKS = 5;
 function recencyDecay(modifiedDate) {
   if (!modifiedDate) return 0.5;
   const daysSince = (Date.now() - modifiedDate.getTime()) / (1e3 * 60 * 60 * 24);
@@ -10584,6 +10818,63 @@ function rankBacklinks(backlinks, notePath, index, stateDb2, maxLinks = TOP_LINK
     return out;
   }).sort((a, b) => (b.weight ?? 1) - (a.weight ?? 1)).slice(0, maxLinks);
 }
+var COMPACT_OUTLINK_NAMES = 10;
+function enrichResultCompact(result, index, stateDb2, opts) {
+  const note = index.notes.get(result.path);
+  const normalizedPath = result.path.toLowerCase().replace(/\.md$/, "");
+  const backlinks = index.backlinks.get(normalizedPath) || [];
+  const enriched = {
+    path: result.path,
+    title: result.title
+  };
+  if (result.snippet) {
+    enriched.snippet = result.snippet;
+  } else {
+    const preview = getContentPreview(result.path);
+    if (preview) enriched.snippet = preview;
+  }
+  if (note) {
+    enriched.backlink_count = backlinks.length;
+    enriched.modified = note.modified.toISOString();
+    if (note.tags.length > 0) enriched.tags = note.tags;
+    if (note.outlinks.length > 0) {
+      enriched.outlink_names = getOutlinkNames(note.outlinks, result.path, index, stateDb2, COMPACT_OUTLINK_NAMES);
+    }
+  }
+  if (stateDb2) {
+    try {
+      const entity = getEntityByName2(stateDb2, result.title);
+      if (entity) {
+        enriched.category = entity.category;
+        enriched.hub_score = entity.hubScore;
+        if (!enriched.snippet && entity.description) {
+          enriched.snippet = entity.description;
+        }
+      }
+    } catch {
+    }
+  }
+  if (opts?.via) enriched.via = opts.via;
+  if (opts?.hop) enriched.hop = opts.hop;
+  return enriched;
+}
+function getOutlinkNames(outlinks, notePath, index, stateDb2, max) {
+  const weightMap = /* @__PURE__ */ new Map();
+  if (stateDb2) {
+    try {
+      const rows = stateDb2.db.prepare(
+        "SELECT target, weight, weight_updated_at FROM note_links WHERE note_path = ?"
+      ).all(notePath);
+      for (const row of rows) {
+        const daysSince = row.weight_updated_at ? (Date.now() - row.weight_updated_at) / (1e3 * 60 * 60 * 24) : 0;
+        const decay = Math.max(0.1, 1 - daysSince / 180);
+        weightMap.set(row.target, row.weight * decay);
+      }
+    } catch {
+    }
+  }
+  return outlinks.map((l) => ({ name: l.target, weight: weightMap.get(l.target.toLowerCase()) ?? 1 })).sort((a, b) => b.weight - a.weight).slice(0, max).map((l) => l.name);
+}
 function enrichResult(result, index, stateDb2) {
   const note = index.notes.get(result.path);
   const normalizedPath = result.path.toLowerCase().replace(/\.md$/, "");
@@ -10651,7 +10942,7 @@ function enrichResultLight(result, index, stateDb2) {
   }
   return enriched;
 }
-function enrichEntityResult(entityName, stateDb2, index) {
+function enrichEntityCompact(entityName, stateDb2, index) {
   const enriched = {};
   if (stateDb2) {
     try {
@@ -10673,36 +10964,27 @@ function enrichEntityResult(entityName, stateDb2, index) {
       const backlinks = index.backlinks.get(normalizedPath) || [];
       enriched.backlink_count = backlinks.length;
       if (note) {
-        enriched.outlink_count = note.outlinks.length;
         if (note.tags.length > 0) enriched.tags = note.tags;
-        if (backlinks.length > 0) {
-          enriched.top_backlinks = rankBacklinks(backlinks, entityPath, index, stateDb2, RECALL_TOP_LINKS);
-        }
         if (note.outlinks.length > 0) {
-          enriched.top_outlinks = rankOutlinks(note.outlinks, entityPath, index, stateDb2, RECALL_TOP_LINKS);
+          enriched.outlink_names = getOutlinkNames(note.outlinks, entityPath, index, stateDb2, COMPACT_OUTLINK_NAMES);
         }
       }
     }
   }
   return enriched;
 }
-function enrichNoteResult(notePath, stateDb2, index) {
+function enrichNoteCompact(notePath, stateDb2, index) {
   const enriched = {};
   if (!index) return enriched;
   const note = index.notes.get(notePath);
   if (!note) return enriched;
   const normalizedPath = notePath.toLowerCase().replace(/\.md$/, "");
   const backlinks = index.backlinks.get(normalizedPath) || [];
-  enriched.frontmatter = note.frontmatter;
   if (note.tags.length > 0) enriched.tags = note.tags;
   enriched.backlink_count = backlinks.length;
-  enriched.outlink_count = note.outlinks.length;
   enriched.modified = note.modified.toISOString();
-  if (backlinks.length > 0) {
-    enriched.top_backlinks = rankBacklinks(backlinks, notePath, index, stateDb2, RECALL_TOP_LINKS);
-  }
   if (note.outlinks.length > 0) {
-    enriched.top_outlinks = rankOutlinks(note.outlinks, notePath, index, stateDb2, RECALL_TOP_LINKS);
+    enriched.outlink_names = getOutlinkNames(note.outlinks, notePath, index, stateDb2, COMPACT_OUTLINK_NAMES);
   }
   if (stateDb2) {
     try {
@@ -10717,8 +10999,132 @@ function enrichNoteResult(notePath, stateDb2, index) {
   return enriched;
 }
 
+// src/core/read/multihop.ts
+import { getEntityByName as getEntityByName3, searchEntities } from "@velvetmonkey/vault-core";
+var DEFAULT_CONFIG2 = {
+  maxParents: 10,
+  maxHops: 2,
+  maxOutlinksPerHop: 10,
+  maxBackfill: 10
+};
+function multiHopBackfill(primaryResults, index, stateDb2, config = {}) {
+  const cfg = { ...DEFAULT_CONFIG2, ...config };
+  const seen = new Set(primaryResults.map((r) => r.path).filter(Boolean));
+  const candidates = [];
+  const hop1Results = [];
+  for (const primary of primaryResults.slice(0, cfg.maxParents)) {
+    const primaryPath = primary.path;
+    if (!primaryPath) continue;
+    const note = index.notes.get(primaryPath);
+    if (!note) continue;
+    for (const outlink of note.outlinks.slice(0, cfg.maxOutlinksPerHop)) {
+      const targetPath = index.entities.get(outlink.target.toLowerCase());
+      if (!targetPath || seen.has(targetPath)) continue;
+      seen.add(targetPath);
+      const targetNote = index.notes.get(targetPath);
+      const title = targetNote?.title ?? outlink.target;
+      hop1Results.push({ path: targetPath, title, via: primaryPath });
+    }
+  }
+  for (const h1 of hop1Results) {
+    const enriched = enrichResultCompact(
+      { path: h1.path, title: h1.title },
+      index,
+      stateDb2,
+      { via: h1.via, hop: 1 }
+    );
+    const score = scoreCandidate(h1.path, index, stateDb2);
+    candidates.push({ result: enriched, score });
+  }
+  if (cfg.maxHops >= 2) {
+    for (const h1 of hop1Results) {
+      const note = index.notes.get(h1.path);
+      if (!note) continue;
+      for (const outlink of note.outlinks.slice(0, cfg.maxOutlinksPerHop)) {
+        const targetPath = index.entities.get(outlink.target.toLowerCase());
+        if (!targetPath || seen.has(targetPath)) continue;
+        seen.add(targetPath);
+        const targetNote = index.notes.get(targetPath);
+        const title = targetNote?.title ?? outlink.target;
+        const enriched = enrichResultCompact(
+          { path: targetPath, title },
+          index,
+          stateDb2,
+          { via: h1.path, hop: 2 }
+        );
+        const score = scoreCandidate(targetPath, index, stateDb2);
+        candidates.push({ result: enriched, score });
+      }
+    }
+  }
+  candidates.sort((a, b) => b.score - a.score);
+  return candidates.slice(0, cfg.maxBackfill).map((c) => c.result);
+}
+function scoreCandidate(path33, index, stateDb2) {
+  const note = index.notes.get(path33);
+  const decay = recencyDecay(note?.modified);
+  let hubScore = 1;
+  if (stateDb2) {
+    try {
+      const title = note?.title ?? path33.replace(/\.md$/, "").split("/").pop() ?? "";
+      const entity = getEntityByName3(stateDb2, title);
+      if (entity) hubScore = entity.hubScore ?? 1;
+    } catch {
+    }
+  }
+  return hubScore * decay;
+}
+function extractExpansionTerms(results, originalQuery, index) {
+  const queryLower = originalQuery.toLowerCase();
+  const terms = /* @__PURE__ */ new Set();
+  for (const r of results.slice(0, 5)) {
+    const outlinks = r.outlink_names;
+    if (outlinks) {
+      for (const name of outlinks) {
+        if (!queryLower.includes(name.toLowerCase()) && index.entities.has(name.toLowerCase())) {
+          terms.add(name);
+        }
+      }
+    }
+    const snippet = r.snippet;
+    if (snippet) {
+      const matches = snippet.match(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g);
+      if (matches) {
+        for (const wl of matches) {
+          const name = wl.replace(/\[\[|\]\]/g, "").split("|")[0];
+          if (!queryLower.includes(name.toLowerCase()) && index.entities.has(name.toLowerCase())) {
+            terms.add(name);
+          }
+        }
+      }
+    }
+  }
+  return Array.from(terms).slice(0, 10);
+}
+function expandQuery(expansionTerms, primaryResults, index, stateDb2) {
+  if (!stateDb2 || expansionTerms.length === 0) return [];
+  const seen = new Set(primaryResults.map((r) => r.path).filter(Boolean));
+  const results = [];
+  for (const term of expansionTerms) {
+    try {
+      const entities = searchEntities(stateDb2, term, 3);
+      for (const entity of entities) {
+        if (!entity.path || seen.has(entity.path)) continue;
+        seen.add(entity.path);
+        results.push(enrichResultCompact(
+          { path: entity.path, title: entity.name },
+          index,
+          stateDb2,
+          { via: "query_expansion" }
+        ));
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+
 // src/tools/read/query.ts
-init_wikilinkFeedback();
 function matchesFrontmatter(note, where) {
   for (const [key, value] of Object.entries(where)) {
     const noteValue = note.frontmatter[key];
@@ -10899,7 +11305,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb2) {
         const stateDbEntity = getStateDb2();
         if (stateDbEntity) {
           try {
-            entityResults = searchEntities(stateDbEntity, query, limit);
+            entityResults = searchEntities2(stateDbEntity, query, limit);
           } catch {
           }
         }
@@ -10971,46 +11377,22 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb2) {
             scored.sort((a, b) => b.rrf_score - a.rrf_score);
             const filtered = applyFolderFilter(scored);
             const stateDb2 = getStateDb2();
-            const results = filtered.slice(0, limit).map((item, i) => ({
-              ...(i < detailN ? enrichResult : enrichResultLight)({ path: item.path, title: item.title, snippet: item.snippet }, index, stateDb2),
+            const results2 = filtered.slice(0, limit).map((item) => ({
+              ...enrichResultCompact({ path: item.path, title: item.title, snippet: item.snippet }, index, stateDb2),
               rrf_score: item.rrf_score,
               in_fts5: item.in_fts5,
               in_semantic: item.in_semantic,
               in_entity: item.in_entity
             }));
-            if (stateDb2 && results.length < limit) {
-              const existingPaths = new Set(results.map((r) => r.path));
-              const backfill = [];
-              for (const r of results.slice(0, 3)) {
-                const rPath = r.path;
-                if (!rPath) continue;
-                try {
-                  const outlinks = getStoredNoteLinks(stateDb2, rPath);
-                  for (const target of outlinks) {
-                    const entityRow = stateDb2.db.prepare(
-                      "SELECT path FROM entities WHERE name_lower = ?"
-                    ).get(target);
-                    if (entityRow?.path && !existingPaths.has(entityRow.path)) {
-                      existingPaths.add(entityRow.path);
-                      backfill.push({
-                        ...enrichResultLight({ path: entityRow.path, title: target }, index, stateDb2),
-                        rrf_score: 0,
-                        in_fts5: false,
-                        in_semantic: false,
-                        in_entity: false
-                      });
-                    }
-                  }
-                } catch {
-                }
-              }
-              results.push(...backfill.slice(0, limit - results.length));
-            }
+            const hopResults2 = multiHopBackfill(results2, index, stateDb2, { maxBackfill: limit });
+            const expansionTerms2 = extractExpansionTerms(results2, query, index);
+            const expansionResults2 = expandQuery(expansionTerms2, [...results2, ...hopResults2], index, stateDb2);
+            results2.push(...hopResults2, ...expansionResults2);
             return { content: [{ type: "text", text: JSON.stringify({
               method: "hybrid",
               query,
               total_results: filtered.length,
-              results
+              results: results2
             }, null, 2) }] };
           } catch (err) {
             console.error("[Semantic] Hybrid search failed, falling back to FTS5:", err instanceof Error ? err.message : err);
@@ -11027,49 +11409,33 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb2) {
           const filtered = applyFolderFilter(mergedItems);
           const stateDb2 = getStateDb2();
           const sliced = filtered.slice(0, limit);
-          const results = sliced.map((item, i) => ({
-            ...(i < detailN ? enrichResult : enrichResultLight)({ path: item.path, title: item.title, snippet: item.snippet }, index, stateDb2),
+          const results2 = sliced.map((item) => ({
+            ...enrichResultCompact({ path: item.path, title: item.title, snippet: item.snippet }, index, stateDb2),
             ..."in_fts5" in item ? { in_fts5: true } : { in_entity: true }
           }));
-          if (stateDb2 && results.length < limit) {
-            const existingPaths = new Set(results.map((r) => r.path));
-            const backfill = [];
-            for (const r of results.slice(0, 3)) {
-              const rPath = r.path;
-              if (!rPath) continue;
-              try {
-                const outlinks = getStoredNoteLinks(stateDb2, rPath);
-                for (const target of outlinks) {
-                  const entityRow = stateDb2.db.prepare(
-                    "SELECT path FROM entities WHERE name_lower = ?"
-                  ).get(target);
-                  if (entityRow?.path && !existingPaths.has(entityRow.path)) {
-                    existingPaths.add(entityRow.path);
-                    backfill.push({
-                      ...enrichResultLight({ path: entityRow.path, title: target }, index, stateDb2)
-                    });
-                  }
-                }
-              } catch {
-              }
-            }
-            results.push(...backfill.slice(0, limit - results.length));
-          }
+          const hopResults2 = multiHopBackfill(results2, index, stateDb2, { maxBackfill: limit });
+          const expansionTerms2 = extractExpansionTerms(results2, query, index);
+          const expansionResults2 = expandQuery(expansionTerms2, [...results2, ...hopResults2], index, stateDb2);
+          results2.push(...hopResults2, ...expansionResults2);
           return { content: [{ type: "text", text: JSON.stringify({
             method: "fts5",
             query,
             total_results: filtered.length,
-            results
+            results: results2
           }, null, 2) }] };
         }
         const stateDbFts = getStateDb2();
         const fts5Filtered = applyFolderFilter(fts5Results);
-        const enrichedFts5 = fts5Filtered.map((r, i) => ({ ...(i < detailN ? enrichResult : enrichResultLight)({ path: r.path, title: r.title, snippet: r.snippet }, index, stateDbFts), in_fts5: true }));
+        const results = fts5Filtered.map((r) => ({ ...enrichResultCompact({ path: r.path, title: r.title, snippet: r.snippet }, index, stateDbFts), in_fts5: true }));
+        const hopResults = multiHopBackfill(results, index, stateDbFts, { maxBackfill: limit });
+        const expansionTerms = extractExpansionTerms(results, query, index);
+        const expansionResults = expandQuery(expansionTerms, [...results, ...hopResults], index, stateDbFts);
+        results.push(...hopResults, ...expansionResults);
         return { content: [{ type: "text", text: JSON.stringify({
           method: "fts5",
           query,
-          total_results: enrichedFts5.length,
-          results: enrichedFts5
+          total_results: results.length,
+          results
         }, null, 2) }] };
       }
       return { content: [{ type: "text", text: JSON.stringify({ error: "Provide a query or metadata filters (where, has_tag, folder, etc.)" }, null, 2) }] };
@@ -11795,7 +12161,7 @@ async function findSections(index, headingPattern, vaultPath2, folder) {
 }
 
 // src/tools/read/primitives.ts
-import { getEntityByName as getEntityByName3 } from "@velvetmonkey/vault-core";
+import { getEntityByName as getEntityByName4 } from "@velvetmonkey/vault-core";
 function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = () => ({}), getStateDb2 = () => null) {
   server2.registerTool(
     "get_note_structure",
@@ -11838,7 +12204,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
       const stateDb2 = getStateDb2();
       if (stateDb2 && note) {
         try {
-          const entity = getEntityByName3(stateDb2, note.title);
+          const entity = getEntityByName4(stateDb2, note.title);
           if (entity) {
             enriched.category = entity.category;
             enriched.hub_score = entity.hubScore;
@@ -12899,9 +13265,9 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb2
     "graph_analysis",
     {
       title: "Graph Analysis",
-      description: 'Analyze vault link graph structure. Use analysis to pick the mode:\n- "orphans": Notes with no backlinks (params: folder, limit, offset)\n- "dead_ends": Notes with backlinks but no outgoing links (params: folder, min_backlinks, limit, offset)\n- "sources": Notes with outgoing links but no backlinks (params: folder, min_outlinks, limit, offset)\n- "hubs": Highly connected notes (params: min_links, limit, offset)\n- "stale": Important notes not recently modified (params: days [required], min_backlinks, limit, offset)\n- "immature": Notes scored by maturity (params: folder, limit, offset)\n- "emerging_hubs": Entities growing fastest in connection count (params: days, limit, offset)',
+      description: 'Analyze vault link graph structure. Use analysis to pick the mode:\n- "orphans": Notes with no backlinks (params: folder, limit, offset)\n- "dead_ends": Notes with backlinks but no outgoing links (params: folder, min_backlinks, limit, offset)\n- "sources": Notes with outgoing links but no backlinks (params: folder, min_outlinks, limit, offset)\n- "hubs": Highly connected notes (params: min_links, limit, offset)\n- "stale": Important notes not recently modified (params: days [required], min_backlinks, limit, offset)\n- "immature": Notes scored by maturity (params: folder, limit, offset)\n- "emerging_hubs": Entities growing fastest in connection count (params: days, limit, offset)\n- "centrality": Degree, betweenness, and closeness centrality metrics (params: limit, offset)\n- "cycles": Detect circular link chains in the vault (params: limit)',
       inputSchema: {
-        analysis: z8.enum(["orphans", "dead_ends", "sources", "hubs", "stale", "immature", "emerging_hubs"]).describe("Type of graph analysis to perform"),
+        analysis: z8.enum(["orphans", "dead_ends", "sources", "hubs", "stale", "immature", "emerging_hubs", "centrality", "cycles"]).describe("Type of graph analysis to perform"),
         folder: z8.string().optional().describe("Limit to notes in this folder (orphans, dead_ends, sources, immature)"),
         min_links: z8.coerce.number().default(5).describe("Minimum total connections for hubs"),
         min_backlinks: z8.coerce.number().default(1).describe("Minimum backlinks (dead_ends, stale)"),
@@ -13100,6 +13466,28 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb2
             }, null, 2) }]
           };
         }
+        case "centrality": {
+          const results = computeCentralityMetrics(index, limit);
+          const paginated = results.slice(offset, offset + limit);
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              analysis: "centrality",
+              total_count: results.length,
+              returned_count: paginated.length,
+              notes: paginated
+            }, null, 2) }]
+          };
+        }
+        case "cycles": {
+          const cycles = detectCycles(index, 10, limit);
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              analysis: "cycles",
+              total_count: cycles.length,
+              cycles
+            }, null, 2) }]
+          };
+        }
       }
     }
   );
@@ -19068,13 +19456,13 @@ function registerRecallTools(server2, getStateDb2, getVaultPath, getIndex) {
               description: e.content,
               score: Math.round(e.score * 10) / 10,
               breakdown: e.breakdown,
-              ...enrichEntityResult(e.id, stateDb2, index)
+              ...enrichEntityCompact(e.id, stateDb2, index)
             })),
             notes: notes.map((n) => ({
               path: n.id,
               snippet: n.content,
               score: Math.round(n.score * 10) / 10,
-              ...enrichNoteResult(n.id, stateDb2, index)
+              ...enrichNoteCompact(n.id, stateDb2, index)
             })),
             memories: memories.map((m) => ({
               key: m.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.121",
+  "version": "2.0.123",
   "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",
@@ -49,11 +49,11 @@
     "lint": "tsc --noEmit",
     "clean": "rm -rf dist",
     "postinstall": "node -e \"['bin/flywheel-memory.js','dist/index.js'].forEach(f=>{try{require('fs').chmodSync(f,0o755)}catch{}})\"",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run lint && npm run build"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@velvetmonkey/vault-core": "^2.0.121",
+    "@velvetmonkey/vault-core": "^2.0.122",
     "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",