@velvetmonkey/flywheel-memory 2.0.145 → 2.0.147

package/dist/index.js

@@ -5657,8 +5657,8 @@ function createContext(variables = {}) {
     steps: {}
   };
 }
-function resolvePath(obj, path37) {
-  const parts = path37.split(".");
+function resolvePath(obj, path39) {
+  const parts = path39.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === void 0 || current === null) {
@@ -6116,7 +6116,7 @@ __export(conditions_exports, {
   shouldStepExecute: () => shouldStepExecute
 });
 import fs28 from "fs/promises";
-import path29 from "path";
+import path30 from "path";
 async function evaluateCondition(condition, vaultPath2, context) {
   const interpolatedPath = condition.path ? interpolate(condition.path, context) : void 0;
   const interpolatedSection = condition.section ? interpolate(condition.section, context) : void 0;
@@ -6169,7 +6169,7 @@ async function evaluateCondition(condition, vaultPath2, context) {
   }
 }
 async function evaluateFileExists(vaultPath2, notePath, expectExists) {
-  const fullPath = path29.join(vaultPath2, notePath);
+  const fullPath = path30.join(vaultPath2, notePath);
   try {
     await fs28.access(fullPath);
     return {
@@ -6184,7 +6184,7 @@ async function evaluateFileExists(vaultPath2, notePath, expectExists) {
   }
 }
 async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectExists) {
-  const fullPath = path29.join(vaultPath2, notePath);
+  const fullPath = path30.join(vaultPath2, notePath);
   try {
     await fs28.access(fullPath);
   } catch {
@@ -6215,7 +6215,7 @@ async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectEx
   }
 }
 async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expectExists) {
-  const fullPath = path29.join(vaultPath2, notePath);
+  const fullPath = path30.join(vaultPath2, notePath);
   try {
     await fs28.access(fullPath);
   } catch {
@@ -6246,7 +6246,7 @@ async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expect
   }
 }
 async function evaluateFrontmatterEquals(vaultPath2, notePath, fieldName, expectedValue) {
-  const fullPath = path29.join(vaultPath2, notePath);
+  const fullPath = path30.join(vaultPath2, notePath);
   try {
     await fs28.access(fullPath);
   } catch {
@@ -6390,7 +6390,7 @@ var init_taskHelpers = __esm({
 });
 
 // src/index.ts
-import * as path36 from "path";
+import * as path38 from "path";
 import { readFileSync as readFileSync6, realpathSync, existsSync as existsSync3 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname7, join as join21 } from "path";
@@ -6628,8 +6628,8 @@ function updateIndexProgress(parsed, total) {
 function normalizeTarget(target) {
   return target.toLowerCase().replace(/\.md$/, "");
 }
-function normalizeNotePath(path37) {
-  return path37.toLowerCase().replace(/\.md$/, "");
+function normalizeNotePath(path39) {
+  return path39.toLowerCase().replace(/\.md$/, "");
 }
 async function buildVaultIndex(vaultPath2, options = {}) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
@@ -6798,7 +6798,7 @@ function findSimilarEntity(index, target) {
   }
   const maxDist = normalizedLen <= 10 ? 1 : 2;
   let bestMatch;
-  for (const [entity, path37] of index.entities) {
+  for (const [entity, path39] of index.entities) {
     const lenDiff = Math.abs(entity.length - normalizedLen);
     if (lenDiff > maxDist) {
       continue;
@@ -6806,7 +6806,7 @@ function findSimilarEntity(index, target) {
     const dist = levenshteinDistance(normalized, entity);
     if (dist > 0 && dist <= maxDist) {
       if (!bestMatch || dist < bestMatch.distance) {
-        bestMatch = { path: path37, entity, distance: dist };
+        bestMatch = { path: path39, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -7337,30 +7337,30 @@ var EventQueue = class {
    * Add a new event to the queue
    */
   push(type, rawPath) {
-    const path37 = normalizePath(rawPath);
+    const path39 = normalizePath(rawPath);
     const now = Date.now();
     const event = {
       type,
-      path: path37,
+      path: path39,
       timestamp: now
     };
-    let pending = this.pending.get(path37);
+    let pending = this.pending.get(path39);
     if (!pending) {
       pending = {
         events: [],
         timer: null,
         lastEvent: now
       };
-      this.pending.set(path37, pending);
+      this.pending.set(path39, pending);
     }
     pending.events.push(event);
     pending.lastEvent = now;
-    console.error(`[flywheel] QUEUE: pushed ${type} for ${path37}, pending=${this.pending.size}`);
+    console.error(`[flywheel] QUEUE: pushed ${type} for ${path39}, pending=${this.pending.size}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
     }
     pending.timer = setTimeout(() => {
-      this.flushPath(path37);
+      this.flushPath(path39);
     }, this.config.debounceMs);
     if (this.pending.size >= this.config.batchSize) {
       this.flush();
@@ -7381,10 +7381,10 @@ var EventQueue = class {
   /**
    * Flush a single path's events
    */
-  flushPath(path37) {
-    const pending = this.pending.get(path37);
+  flushPath(path39) {
+    const pending = this.pending.get(path39);
     if (!pending || pending.events.length === 0) return;
-    console.error(`[flywheel] QUEUE: flushing ${path37}, events=${pending.events.length}`);
+    console.error(`[flywheel] QUEUE: flushing ${path39}, events=${pending.events.length}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -7393,7 +7393,7 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path37,
+        path: path39,
         originalEvents: [...pending.events]
       };
       this.onBatch({
@@ -7402,7 +7402,7 @@ var EventQueue = class {
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path37);
+    this.pending.delete(path39);
   }
   /**
    * Flush all pending events
@@ -7414,7 +7414,7 @@ var EventQueue = class {
     }
     if (this.pending.size === 0) return;
     const events = [];
-    for (const [path37, pending] of this.pending) {
+    for (const [path39, pending] of this.pending) {
       if (pending.timer) {
         clearTimeout(pending.timer);
       }
@@ -7422,7 +7422,7 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path37,
+          path: path39,
           originalEvents: [...pending.events]
         });
       }
@@ -7808,31 +7808,31 @@ function createVaultWatcher(options) {
         usePolling: config.usePolling,
         interval: config.usePolling ? config.pollInterval : void 0
       });
-      watcher.on("add", (path37) => {
-        console.error(`[flywheel] RAW EVENT: add ${path37}`);
-        if (shouldWatch(path37, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: add ${path37}`);
-          eventQueue.push("add", path37);
+      watcher.on("add", (path39) => {
+        console.error(`[flywheel] RAW EVENT: add ${path39}`);
+        if (shouldWatch(path39, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: add ${path39}`);
+          eventQueue.push("add", path39);
         } else {
-          console.error(`[flywheel] FILTERED: add ${path37}`);
+          console.error(`[flywheel] FILTERED: add ${path39}`);
         }
       });
-      watcher.on("change", (path37) => {
-        console.error(`[flywheel] RAW EVENT: change ${path37}`);
-        if (shouldWatch(path37, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: change ${path37}`);
-          eventQueue.push("change", path37);
+      watcher.on("change", (path39) => {
+        console.error(`[flywheel] RAW EVENT: change ${path39}`);
+        if (shouldWatch(path39, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: change ${path39}`);
+          eventQueue.push("change", path39);
         } else {
-          console.error(`[flywheel] FILTERED: change ${path37}`);
+          console.error(`[flywheel] FILTERED: change ${path39}`);
         }
       });
-      watcher.on("unlink", (path37) => {
-        console.error(`[flywheel] RAW EVENT: unlink ${path37}`);
-        if (shouldWatch(path37, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: unlink ${path37}`);
-          eventQueue.push("unlink", path37);
+      watcher.on("unlink", (path39) => {
+        console.error(`[flywheel] RAW EVENT: unlink ${path39}`);
+        if (shouldWatch(path39, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: unlink ${path39}`);
+          eventQueue.push("unlink", path39);
         } else {
-          console.error(`[flywheel] FILTERED: unlink ${path37}`);
+          console.error(`[flywheel] FILTERED: unlink ${path39}`);
         }
       });
       watcher.on("ready", () => {
@@ -10324,8 +10324,8 @@ function getNoteAccessFrequency(stateDb2, daysBack = 30) {
       }
     }
   }
-  return Array.from(noteMap.entries()).map(([path37, stats]) => ({
-    path: path37,
+  return Array.from(noteMap.entries()).map(([path39, stats]) => ({
+    path: path39,
     access_count: stats.access_count,
     last_accessed: stats.last_accessed,
     tools_used: Array.from(stats.tools)
@@ -10627,7 +10627,7 @@ init_recency();
 init_cooccurrence();
 init_retrievalCooccurrence();
 import * as fs34 from "node:fs/promises";
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 
 // src/vault-registry.ts
 var VaultRegistry = class {
@@ -10874,7 +10874,9 @@ var TOOL_CATEGORY = {
   flywheel_trust_report: "diagnostics",
   flywheel_benchmark: "diagnostics",
   vault_session_history: "diagnostics",
-  vault_entity_history: "diagnostics"
+  vault_entity_history: "diagnostics",
+  flywheel_learning_report: "diagnostics",
+  flywheel_calibration_export: "diagnostics"
 };
 function generateInstructions(categories, registry) {
   const parts = [];
@@ -11001,11 +11003,11 @@ Use "note_intelligence" for per-note analysis (completeness, quality, suggestion
 }
 
 // src/tool-registry.ts
-import * as path35 from "path";
+import * as path37 from "path";
 import { dirname as dirname5, join as join19 } from "path";
 import { statSync as statSync6, readFileSync as readFileSync5 } from "fs";
 import { fileURLToPath } from "url";
-import { z as z38 } from "zod";
+import { z as z40 } from "zod";
 import { getSessionId } from "@velvetmonkey/vault-core";
 init_vault_scope();
 
@@ -12253,14 +12255,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath, getStateDb3 = ()
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path37] of entities) {
+    for (const [name, path39] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path37;
+        return path39;
       }
     }
-    for (const [name, path37] of entities) {
+    for (const [name, path39] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path37;
+        return path39;
       }
     }
     return void 0;
@@ -13098,8 +13100,8 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
       daily_counts: z4.record(z4.number())
     }).describe("Activity summary for the last 7 days")
   };
-  function isPeriodicNote3(path37) {
-    const filename = path37.split("/").pop() || "";
+  function isPeriodicNote3(path39) {
+    const filename = path39.split("/").pop() || "";
     const nameWithoutExt = filename.replace(/\.md$/, "");
     const patterns = [
       /^\d{4}-\d{2}-\d{2}$/,
@@ -13114,7 +13116,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
       // YYYY (yearly)
     ];
     const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
-    const folder = path37.split("/")[0]?.toLowerCase() || "";
+    const folder = path39.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   server2.registerTool(
@@ -13718,7 +13720,7 @@ 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;
+var COMPACT_OUTLINK_NAMES = 5;
 function enrichResultCompact(result, index, stateDb2, opts) {
   const note = index.notes.get(result.path);
   const normalizedPath = result.path.toLowerCase().replace(/\.md$/, "");
@@ -13963,13 +13965,13 @@ function multiHopBackfill(primaryResults, index, stateDb2, config = {}) {
   candidates.sort((a, b) => b.score - a.score);
   return candidates.slice(0, cfg.maxBackfill).map((c) => c.result);
 }
-function scoreCandidate(path37, index, stateDb2) {
-  const note = index.notes.get(path37);
+function scoreCandidate(path39, index, stateDb2) {
+  const note = index.notes.get(path39);
   const decay = recencyDecay(note?.modified);
   let hubScore = 1;
   if (stateDb2) {
     try {
-      const title = note?.title ?? path37.replace(/\.md$/, "").split("/").pop() ?? "";
+      const title = note?.title ?? path39.replace(/\.md$/, "").split("/").pop() ?? "";
       const entity = getEntityByName3(stateDb2, title);
       if (entity) hubScore = entity.hubScore ?? 1;
     } catch {
@@ -14045,26 +14047,59 @@ function stripFrontmatter(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);
+  let currentSection;
+  const withSections = [];
+  for (const paragraph of raw) {
+    const headingMatch = paragraph.match(/^#{1,6}\s+(.+)/);
+    if (headingMatch) {
+      currentSection = headingMatch[1].trim();
+    }
+    withSections.push({ text: paragraph, section: currentSection });
+  }
   const merged = [];
   let buffer2 = "";
-  for (const paragraph of raw) {
+  let bufferSection;
+  for (const { text: paragraph, section } of withSections) {
     if (buffer2) {
       buffer2 += "\n\n" + paragraph;
       if (buffer2.length >= MIN_PARAGRAPH_CHARS) {
-        merged.push(buffer2.slice(0, maxChunkChars));
+        merged.push({ text: buffer2.slice(0, maxChunkChars), section: bufferSection });
         buffer2 = "";
       }
     } else if (paragraph.length < MIN_PARAGRAPH_CHARS) {
       buffer2 = paragraph;
+      bufferSection = section;
     } else {
-      merged.push(paragraph.slice(0, maxChunkChars));
+      merged.push({ text: paragraph.slice(0, maxChunkChars), section });
     }
   }
   if (buffer2) {
-    merged.push(buffer2.slice(0, maxChunkChars));
+    merged.push({ text: buffer2.slice(0, maxChunkChars), section: bufferSection });
   }
   return merged;
 }
+function expandWindow(paragraphs, matchIdx, maxChars = 800) {
+  let result = paragraphs[matchIdx].text;
+  let lo = matchIdx;
+  let hi = matchIdx;
+  for (let step = 0; step < 2; step++) {
+    if (lo > 0) {
+      const candidate = paragraphs[lo - 1].text + "\n\n" + result;
+      if (candidate.length <= maxChars) {
+        result = candidate;
+        lo--;
+      }
+    }
+    if (hi < paragraphs.length - 1) {
+      const candidate = result + "\n\n" + paragraphs[hi + 1].text;
+      if (candidate.length <= maxChars) {
+        result = candidate;
+        hi++;
+      }
+    }
+  }
+  return result;
+}
 function scoreByKeywords(chunk, queryTokens, queryStems) {
   const chunkTokens = new Set(tokenize(chunk.toLowerCase()));
   const chunkStems = new Set([...chunkTokens].map((t) => stem(t)));
@@ -14080,7 +14115,7 @@ function scoreByKeywords(chunk, queryTokens, queryStems) {
 }
 async function extractBestSnippets(filePath, queryEmbedding, queryTokens, options) {
   const maxSnippets = options?.maxSnippets ?? 1;
-  const maxChunkChars = options?.maxChunkChars ?? 500;
+  const maxChunkChars = options?.maxChunkChars ?? 800;
   let content;
   try {
     content = fs13.readFileSync(filePath, "utf-8");
@@ -14089,35 +14124,83 @@ async function extractBestSnippets(filePath, queryEmbedding, queryTokens, option
   }
   const body = stripFrontmatter(content);
   if (body.length < 50) {
-    return body.length > 0 ? [{ text: body, score: 1 }] : [];
+    return body.length > 0 ? [{ text: body, score: 1, confidence: 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,
+  const scored = paragraphs.map((para, idx) => ({
+    ...para,
     idx,
-    keywordScore: scoreByKeywords(text, queryTokens, queryStems)
+    keywordScore: scoreByKeywords(para.text, queryTokens, queryStems)
   }));
   scored.sort((a, b) => b.keywordScore - a.keywordScore);
+  const maxPossibleScore = queryTokens.length * 10;
   const topKeyword = scored.slice(0, 5);
+  const buildSnippet = (match, score) => ({
+    text: expandWindow(paragraphs, match.idx, maxChunkChars),
+    score,
+    section: match.section,
+    confidence: maxPossibleScore > 0 ? Math.min(1, score / maxPossibleScore) : 0
+  });
   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.push({ match: chunk, sim });
       }
-      reranked.sort((a, b) => b.score - a.score);
-      return reranked.slice(0, maxSnippets);
+      reranked.sort((a, b) => b.sim - a.sim);
+      return reranked.slice(0, maxSnippets).map((r) => buildSnippet(r.match, r.sim));
     } catch {
     }
   }
-  return topKeyword.slice(0, maxSnippets).map((c) => ({
-    text: c.text,
-    score: c.keywordScore
-  }));
+  return topKeyword.slice(0, maxSnippets).map((c) => buildSnippet(c, c.keywordScore));
+}
+var MONTH_MAP = {
+  jan: "01",
+  feb: "02",
+  mar: "03",
+  apr: "04",
+  may: "05",
+  jun: "06",
+  jul: "07",
+  aug: "08",
+  sep: "09",
+  oct: "10",
+  nov: "11",
+  dec: "12",
+  january: "01",
+  february: "02",
+  march: "03",
+  april: "04",
+  june: "06",
+  july: "07",
+  august: "08",
+  september: "09",
+  october: "10",
+  november: "11",
+  december: "12"
+};
+function extractDates(text) {
+  const dates = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(/\b(\d{4})-(\d{2})-(\d{2})\b/g)) {
+    dates.add(m[0]);
+  }
+  for (const m of text.matchAll(/\b((?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\w*)\s+(\d{1,2}),?\s+(\d{4})\b/gi)) {
+    const month = MONTH_MAP[m[1].toLowerCase()];
+    if (month) dates.add(`${m[3]}-${month}-${m[2].padStart(2, "0")}`);
+  }
+  for (const m of text.matchAll(/\b(\d{1,2})\s+((?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\w*)\s+(\d{4})\b/gi)) {
+    const month = MONTH_MAP[m[2].toLowerCase()];
+    if (month) dates.add(`${m[3]}-${month}-${m[1].padStart(2, "0")}`);
+  }
+  for (const m of text.matchAll(/\b((?:January|February|March|April|May|June|July|August|September|October|November|December))\s+(\d{4})\b/gi)) {
+    const month = MONTH_MAP[m[1].toLowerCase()];
+    if (month) dates.add(`${m[2]}-${month}-01`);
+  }
+  return [...dates].sort();
 }
 
 // src/tools/read/query.ts
@@ -14152,6 +14235,53 @@ function applyGraphReranking(results, stateDb2) {
     (a, b) => (b._combined_score ?? b.rrf_score ?? 0) - (a._combined_score ?? a.rrf_score ?? 0)
   );
 }
+function applySandwichOrdering(results) {
+  if (results.length < 3) return;
+  const secondBest = results.splice(1, 1)[0];
+  results.push(secondBest);
+}
+function applyEntityBridging(results, stateDb2, maxBridgesPerResult = 3) {
+  if (!stateDb2 || results.length < 2) return;
+  const linkMap = /* @__PURE__ */ new Map();
+  try {
+    const paths = results.map((r) => r.path).filter(Boolean);
+    for (const path39 of paths) {
+      const rows = stateDb2.db.prepare(
+        "SELECT target FROM note_links WHERE note_path = ?"
+      ).all(path39);
+      linkMap.set(path39, new Set(rows.map((r) => r.target)));
+    }
+  } catch {
+    return;
+  }
+  for (const r of results) {
+    const myPath = r.path;
+    const myLinks = linkMap.get(myPath);
+    if (!myLinks || myLinks.size === 0) continue;
+    const bridges = [];
+    for (const other of results) {
+      const otherPath = other.path;
+      if (otherPath === myPath) continue;
+      const otherLinks = linkMap.get(otherPath);
+      if (!otherLinks) continue;
+      for (const entity of myLinks) {
+        if (otherLinks.has(entity) && bridges.length < maxBridgesPerResult) {
+          bridges.push({ entity, in_result: otherPath });
+        }
+      }
+      if (bridges.length >= maxBridgesPerResult) break;
+    }
+    if (bridges.length > 0) {
+      r.bridges = bridges;
+    }
+  }
+}
+function stripInternalFields(results) {
+  const INTERNAL = ["rrf_score", "in_fts5", "in_semantic", "in_entity", "graph_boost", "_combined_score"];
+  for (const r of results) {
+    for (const key of INTERNAL) delete r[key];
+  }
+}
 async function enhanceSnippets(results, query, vaultPath2) {
   if (!hasEmbeddingsIndex()) return;
   const queryTokens = tokenize(query).map((t) => t.toLowerCase());
@@ -14166,6 +14296,10 @@ async function enhanceSnippets(results, query, vaultPath2) {
       const snippets = await extractBestSnippets(`${vaultPath2}/${r.path}`, queryEmb, queryTokens);
       if (snippets.length > 0 && snippets[0].text.length > 0) {
         r.snippet = snippets[0].text;
+        if (snippets[0].section) r.section = snippets[0].section;
+        if (snippets[0].confidence != null) r.snippet_confidence = Math.round(snippets[0].confidence * 100) / 100;
+        const dates = extractDates(snippets[0].text);
+        if (dates.length > 0) r.dates_mentioned = dates;
       }
     } catch {
     }
@@ -14437,12 +14571,17 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb3) {
               in_semantic: item.in_semantic,
               in_entity: item.in_entity
             }));
-            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);
+            if (results2.length < 3) {
+              const hopResults = multiHopBackfill(results2, index, stateDb2, { maxBackfill: limit });
+              const expansionTerms = extractExpansionTerms(results2, query, index);
+              const expansionResults = expandQuery(expansionTerms, [...results2, ...hopResults], index, stateDb2);
+              results2.push(...hopResults, ...expansionResults);
+            }
             applyGraphReranking(results2, stateDb2);
+            applyEntityBridging(results2, stateDb2);
+            applySandwichOrdering(results2);
             await enhanceSnippets(results2, query, vaultPath2);
+            stripInternalFields(results2);
             return { content: [{ type: "text", text: JSON.stringify({
               method: "hybrid",
               query,
@@ -14474,12 +14613,17 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb3) {
             ...enrichResultCompact({ path: item.path, title: item.title, snippet: item.snippet }, index, stateDb2),
             ..."in_fts5" in item ? { in_fts5: true } : { in_entity: true }
           }));
-          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);
+          if (results2.length < 3) {
+            const hopResults = multiHopBackfill(results2, index, stateDb2, { maxBackfill: limit });
+            const expansionTerms = extractExpansionTerms(results2, query, index);
+            const expansionResults = expandQuery(expansionTerms, [...results2, ...hopResults], index, stateDb2);
+            results2.push(...hopResults, ...expansionResults);
+          }
           applyGraphReranking(results2, stateDb2);
+          applyEntityBridging(results2, stateDb2);
+          applySandwichOrdering(results2);
           await enhanceSnippets(results2, query, vaultPath2);
+          stripInternalFields(results2);
           return { content: [{ type: "text", text: JSON.stringify({
             method: "fts5",
             query,
@@ -14490,12 +14634,17 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb3) {
         const stateDbFts = getStateDb3();
         const fts5Filtered = applyFolderFilter(fts5Results);
         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);
+        if (results.length < 3) {
+          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);
+        }
         applyGraphReranking(results, stateDbFts);
+        applyEntityBridging(results, stateDbFts);
+        applySandwichOrdering(results);
         await enhanceSnippets(results, query, vaultPath2);
+        stripInternalFields(results);
         return { content: [{ type: "text", text: JSON.stringify({
           method: "fts5",
           query,
@@ -15238,30 +15387,30 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         include_content: z7.boolean().default(true).describe("Include the text content under each top-level section. Set false to get structure only.")
       }
     },
-    async ({ path: path37, include_content }) => {
+    async ({ path: path39, include_content }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path37, vaultPath2);
+      const result = await getNoteStructure(index, path39, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path37 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path39 }, null, 2) }]
         };
       }
       if (include_content) {
         for (const section of result.sections) {
-          const sectionResult = await getSectionContent(index, path37, section.heading.text, vaultPath2, true);
+          const sectionResult = await getSectionContent(index, path39, section.heading.text, vaultPath2, true);
           if (sectionResult) {
             section.content = sectionResult.content;
           }
         }
       }
-      const note = index.notes.get(path37);
+      const note = index.notes.get(path39);
       const enriched = { ...result };
       if (note) {
         enriched.frontmatter = note.frontmatter;
         enriched.tags = note.tags;
         enriched.aliases = note.aliases;
-        const normalizedPath = path37.toLowerCase().replace(/\.md$/, "");
+        const normalizedPath = path39.toLowerCase().replace(/\.md$/, "");
         const backlinks = index.backlinks.get(normalizedPath) || [];
         enriched.backlink_count = backlinks.length;
         enriched.outlink_count = note.outlinks.length;
@@ -15294,15 +15443,15 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         include_subheadings: z7.boolean().default(true).describe("Include content under subheadings")
       }
     },
-    async ({ path: path37, heading, include_subheadings }) => {
+    async ({ path: path39, heading, include_subheadings }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path37, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path39, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path37,
+            path: path39,
             heading
           }, null, 2) }]
         };
@@ -15356,16 +15505,16 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         offset: z7.coerce.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path37, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
+    async ({ path: path39, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
       const limit = Math.min(requestedLimit ?? 25, MAX_LIMIT);
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const config = getConfig2();
-      if (path37) {
-        const result2 = await getTasksFromNote(index, path37, vaultPath2, config.exclude_task_tags || []);
+      if (path39) {
+        const result2 = await getTasksFromNote(index, path39, vaultPath2, config.exclude_task_tags || []);
         if (!result2) {
           return {
-            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path37 }, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path39 }, null, 2) }]
           };
         }
         let filtered = result2;
@@ -15375,7 +15524,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         const paged2 = filtered.slice(offset, offset + limit);
         return {
           content: [{ type: "text", text: JSON.stringify({
-            path: path37,
+            path: path39,
             total_count: filtered.length,
             returned_count: paged2.length,
             open: result2.filter((t) => t.status === "open").length,
@@ -19110,6 +19259,7 @@ init_writer();
 init_wikilinks();
 import { z as z18 } from "zod";
 import fs26 from "fs/promises";
+import path28 from "path";
 function registerMergeTools(server2, getVaultPath) {
   server2.tool(
     "merge_entities",
@@ -19267,7 +19417,7 @@ ${trimmedSource}`;
   );
   server2.tool(
     "absorb_as_alias",
-    "Absorb an entity name as an alias of a target note: adds alias to target frontmatter and rewrites all [[source]] links to [[target|source]]. Lighter than merge_entities \u2014 no source note required, no content append, no deletion.",
+    "Absorb an entity name as an alias of a target note: adds alias to target frontmatter, rewrites all [[source]] links to [[target|source]], and deletes the source note if it exists. Lighter than merge_entities \u2014 no source note required, no content append.",
     {
       source_name: z18.string().describe('The entity name to absorb (e.g. "Foo")'),
       target_path: z18.string().describe('Vault-relative path of the target entity note (e.g. "entities/Bar.md")'),
@@ -19310,6 +19460,7 @@ ${trimmedSource}`;
         const backlinks = await findBacklinks(vaultPath2, source_name, []);
         let totalBacklinksUpdated = 0;
         const modifiedFiles = [];
+        const sourceNoteFile = await findSourceNote(vaultPath2, source_name, target_path);
         if (dry_run) {
           for (const backlink of backlinks) {
             if (backlink.path === target_path) continue;
@@ -19348,6 +19499,11 @@ ${trimmedSource}`;
               modifiedFiles.push(backlink.path);
             }
           }
+          let sourceDeleted = false;
+          if (sourceNoteFile) {
+            await fs26.unlink(`${vaultPath2}/${sourceNoteFile}`);
+            sourceDeleted = true;
+          }
           initializeEntityIndex(vaultPath2).catch((err) => {
             console.error(`[Flywheel] Entity cache rebuild failed: ${err}`);
           });
@@ -19356,7 +19512,8 @@ ${trimmedSource}`;
         const previewLines = [
           `${dry_run ? "Would absorb" : "Absorbed"}: "${source_name}" \u2192 "${targetTitle}"`,
           `Alias ${dry_run ? "to add" : "added"}: ${aliasAdded ? source_name : "no (matches target title)"}`,
-          `Backlinks ${dry_run ? "to update" : "updated"}: ${totalBacklinksUpdated}`
+          `Backlinks ${dry_run ? "to update" : "updated"}: ${totalBacklinksUpdated}`,
+          sourceNoteFile ? `Source note ${dry_run ? "to delete" : "deleted"}: ${sourceNoteFile}` : "Source note: none found"
         ];
         if (modifiedFiles.length > 0) {
           previewLines.push(`Files ${dry_run ? "to modify" : "modified"}: ${modifiedFiles.join(", ")}`);
@@ -19388,6 +19545,33 @@ ${trimmedSource}`;
     }
   );
 }
+async function findSourceNote(vaultPath2, sourceName, excludePath) {
+  const targetLower = sourceName.toLowerCase();
+  async function scanDir(dir) {
+    let entries;
+    try {
+      entries = await fs26.readdir(dir, { withFileTypes: true });
+    } catch {
+      return null;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const fullPath = path28.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const found = await scanDir(fullPath);
+        if (found) return found;
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const basename5 = path28.basename(entry.name, ".md");
+        if (basename5.toLowerCase() === targetLower) {
+          const relative3 = path28.relative(vaultPath2, fullPath).replace(/\\/g, "/");
+          if (relative3 !== excludePath) return relative3;
+        }
+      }
+    }
+    return null;
+  }
+  return scanDir(vaultPath2);
+}
 
 // src/tools/write/system.ts
 init_git();
@@ -19500,6 +19684,7 @@ Message: ${undoResult.undoneCommit.message}` : void 0
 }
 
 // src/tools/write/policy.ts
+import * as path33 from "path";
 import { z as z21 } from "zod";
 
 // src/core/write/policy/index.ts
@@ -19509,7 +19694,7 @@ init_schema();
 // src/core/write/policy/parser.ts
 init_schema();
 import fs27 from "fs/promises";
-import path28 from "path";
+import path29 from "path";
 import matter7 from "gray-matter";
 function parseYaml(content) {
   const parsed = matter7(`---
@@ -19558,13 +19743,13 @@ async function loadPolicyFile(filePath) {
   }
 }
 async function loadPolicy(vaultPath2, policyName) {
-  const policiesDir = path28.join(vaultPath2, ".claude", "policies");
-  const policyPath = path28.join(policiesDir, `${policyName}.yaml`);
+  const policiesDir = path29.join(vaultPath2, ".claude", "policies");
+  const policyPath = path29.join(policiesDir, `${policyName}.yaml`);
   try {
     await fs27.access(policyPath);
     return loadPolicyFile(policyPath);
   } catch {
-    const ymlPath = path28.join(policiesDir, `${policyName}.yml`);
+    const ymlPath = path29.join(policiesDir, `${policyName}.yml`);
     try {
       await fs27.access(ymlPath);
       return loadPolicyFile(ymlPath);
@@ -19707,7 +19892,7 @@ init_writer();
 init_git();
 init_wikilinks();
 import fs29 from "fs/promises";
-import path30 from "path";
+import path31 from "path";
 init_constants();
 async function executeStep(step, vaultPath2, context, conditionResults, searchFn) {
   const { execute, reason } = shouldStepExecute(step.when, conditionResults);
@@ -19915,7 +20100,7 @@ async function executeToggleTask(params, vaultPath2) {
   const notePath = String(params.path || "");
   const task = String(params.task || "");
   const section = params.section ? String(params.section) : void 0;
-  const fullPath = path30.join(vaultPath2, notePath);
+  const fullPath = path31.join(vaultPath2, notePath);
   try {
     await fs29.access(fullPath);
   } catch {
@@ -20198,7 +20383,7 @@ async function rollbackChanges(vaultPath2, originalContents, filesModified) {
     const pathCheck = await validatePathSecure(vaultPath2, filePath);
     if (!pathCheck.valid) continue;
     const original = originalContents.get(filePath);
-    const fullPath = path30.join(vaultPath2, filePath);
+    const fullPath = path31.join(vaultPath2, filePath);
     if (original === null) {
       try {
         await fs29.unlink(fullPath);
@@ -20253,9 +20438,9 @@ async function previewPolicy(policy, vaultPath2, variables) {
 
 // src/core/write/policy/storage.ts
 import fs30 from "fs/promises";
-import path31 from "path";
+import path32 from "path";
 function getPoliciesDir(vaultPath2) {
-  return path31.join(vaultPath2, ".claude", "policies");
+  return path32.join(vaultPath2, ".claude", "policies");
 }
 async function ensurePoliciesDir(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
@@ -20270,7 +20455,7 @@ async function listPolicies(vaultPath2) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
         continue;
       }
-      const filePath = path31.join(dir, file);
+      const filePath = path32.join(dir, file);
       const stat5 = await fs30.stat(filePath);
       const content = await fs30.readFile(filePath, "utf-8");
       const metadata = extractPolicyMetadata(content);
@@ -20295,7 +20480,7 @@ async function writePolicyRaw(vaultPath2, policyName, content, overwrite = false
   const dir = getPoliciesDir(vaultPath2);
   await ensurePoliciesDir(vaultPath2);
   const filename = `${policyName}.yaml`;
-  const filePath = path31.join(dir, filename);
+  const filePath = path32.join(dir, filename);
   if (!overwrite) {
     try {
       await fs30.access(filePath);
@@ -20409,6 +20594,8 @@ function registerPolicyTools(server2, getVaultPath, getSearchFn) {
             const policies = await listPolicies(vaultPath2);
             const response = {
               success: true,
+              vault: path33.basename(vaultPath2),
+              vault_path: vaultPath2,
               count: policies.length,
               policies: policies.map((p) => ({
                 name: p.name,
@@ -20841,7 +21028,7 @@ import { z as z22 } from "zod";
 
 // src/core/write/tagRename.ts
 import * as fs31 from "fs/promises";
-import * as path32 from "path";
+import * as path34 from "path";
 import matter8 from "gray-matter";
 import { getProtectedZones as getProtectedZones2 } from "@velvetmonkey/vault-core";
 function getNotesInFolder3(index, folder) {
@@ -20947,7 +21134,7 @@ async function renameTag(index, vaultPath2, oldTag, newTag, options) {
   const previews = [];
   let totalChanges = 0;
   for (const note of affectedNotes) {
-    const fullPath = path32.join(vaultPath2, note.path);
+    const fullPath = path34.join(vaultPath2, note.path);
     let fileContent;
     try {
       fileContent = await fs31.readFile(fullPath, "utf-8");
@@ -22186,7 +22373,11 @@ var VALID_CONFIG_KEYS = {
   adaptive_strictness: z28.boolean(),
   proactive_linking: z28.boolean(),
   proactive_min_score: z28.number(),
-  proactive_max_per_file: z28.number()
+  proactive_max_per_file: z28.number(),
+  proactive_max_per_day: z28.number(),
+  custom_categories: z28.record(z28.string(), z28.object({
+    type_boost: z28.number().optional()
+  }))
 };
 function registerConfigTools(server2, getConfig2, setConfig, getStateDb3) {
   server2.registerTool(
@@ -22255,7 +22446,7 @@ init_wikilinks();
 init_wikilinkFeedback();
 import { z as z29 } from "zod";
 import * as fs32 from "fs/promises";
-import * as path33 from "path";
+import * as path35 from "path";
 import { scanVaultEntities as scanVaultEntities3, SCHEMA_VERSION as SCHEMA_VERSION2 } from "@velvetmonkey/vault-core";
 init_embeddings();
 function hasSkipWikilinks(content) {
@@ -22271,13 +22462,13 @@ async function collectMarkdownFiles(dirPath, basePath, excludeFolders) {
     const entries = await fs32.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const fullPath = path33.join(dirPath, entry.name);
+      const fullPath = path35.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (excludeFolders.some((f) => entry.name.toLowerCase() === f.toLowerCase())) continue;
         const sub = await collectMarkdownFiles(fullPath, basePath, excludeFolders);
         results.push(...sub);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        results.push(path33.relative(basePath, fullPath));
+        results.push(path35.relative(basePath, fullPath));
       }
     }
   } catch {
@@ -22307,7 +22498,7 @@ var EXCLUDE_FOLDERS = [
 ];
 function buildStatusReport(stateDb2, vaultPath2) {
   const recommendations = [];
-  const dbPath = path33.join(vaultPath2, ".flywheel", "state.db");
+  const dbPath = path35.join(vaultPath2, ".flywheel", "state.db");
   const statedbExists = stateDb2 !== null;
   if (!statedbExists) {
     recommendations.push("StateDb not initialized \u2014 server needs restart");
@@ -22433,7 +22624,7 @@ async function executeRun(stateDb2, vaultPath2) {
       const allFiles = await collectMarkdownFiles(vaultPath2, vaultPath2, EXCLUDE_FOLDERS);
       let eligible = 0;
       for (const relativePath of allFiles) {
-        const fullPath = path33.join(vaultPath2, relativePath);
+        const fullPath = path35.join(vaultPath2, relativePath);
         let content;
         try {
           content = await fs32.readFile(fullPath, "utf-8");
@@ -22491,7 +22682,7 @@ async function executeEnrich(stateDb2, vaultPath2, dryRun, batchSize, offset) {
   const eligible = [];
   let notesSkipped = 0;
   for (const relativePath of allFiles) {
-    const fullPath = path33.join(vaultPath2, relativePath);
+    const fullPath = path35.join(vaultPath2, relativePath);
     let content;
     try {
       content = await fs32.readFile(fullPath, "utf-8");
@@ -22521,7 +22712,7 @@ async function executeEnrich(stateDb2, vaultPath2, dryRun, batchSize, offset) {
       match_count: result.linksAdded
     });
     if (!dryRun) {
-      const fullPath = path33.join(vaultPath2, relativePath);
+      const fullPath = path35.join(vaultPath2, relativePath);
       await fs32.writeFile(fullPath, result.content, "utf-8");
       notesModified++;
       if (stateDb2) {
@@ -22754,7 +22945,7 @@ import { z as z32 } from "zod";
 // src/core/read/similarity.ts
 init_embeddings();
 import * as fs33 from "fs";
-import * as path34 from "path";
+import * as path36 from "path";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
   "be",
@@ -22891,7 +23082,7 @@ function extractKeyTerms(content, maxTerms = 15) {
 }
 function findSimilarNotes(db4, vaultPath2, index, sourcePath, options = {}) {
   const limit = options.limit ?? 10;
-  const absPath = path34.join(vaultPath2, sourcePath);
+  const absPath = path36.join(vaultPath2, sourcePath);
   let content;
   try {
     content = fs33.readFileSync(absPath, "utf-8");
@@ -23033,7 +23224,7 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb3) {
         diversity: z32.number().min(0).max(1).optional().describe("Relevance vs diversity tradeoff (0=max diversity, 1=pure relevance, default: 0.7)")
       }
     },
-    async ({ path: path37, limit, diversity }) => {
+    async ({ path: path39, limit, diversity }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const stateDb2 = getStateDb3();
@@ -23042,10 +23233,10 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb3) {
           content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
         };
       }
-      if (!index.notes.has(path37)) {
+      if (!index.notes.has(path39)) {
         return {
           content: [{ type: "text", text: JSON.stringify({
-            error: `Note not found: ${path37}`,
+            error: `Note not found: ${path39}`,
             hint: "Use the full relative path including .md extension"
           }, null, 2) }]
         };
@@ -23057,12 +23248,12 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb3) {
       };
       const useHybrid = hasEmbeddingsIndex();
       const method = useHybrid ? "hybrid" : "bm25";
-      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path37, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path37, opts);
+      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path39, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path39, opts);
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
-            source: path37,
+            source: path39,
             method,
             count: results.length,
             similar: results
@@ -24188,6 +24379,492 @@ function registerEntityHistoryTools(server2, getStateDb3) {
   );
 }
 
+// src/tools/read/learningReport.ts
+import { z as z38 } from "zod";
+
+// src/core/read/learningReport.ts
+function isoDate(d) {
+  return d.toISOString().slice(0, 10);
+}
+function periodBounds(daysBack, now) {
+  const end = new Date(now);
+  end.setHours(23, 59, 59, 999);
+  const start = new Date(now);
+  start.setDate(start.getDate() - daysBack + 1);
+  start.setHours(0, 0, 0, 0);
+  return {
+    start: isoDate(start),
+    end: isoDate(end),
+    startMs: start.getTime(),
+    endMs: end.getTime() + 1
+    // exclusive upper bound
+  };
+}
+function queryApplicationsByDay(stateDb2, startIso, endIso) {
+  const rows = stateDb2.db.prepare(`
+    SELECT date(applied_at) as day,
+      SUM(CASE WHEN status='applied' THEN 1 ELSE 0 END) as applied,
+      SUM(CASE WHEN status='removed' THEN 1 ELSE 0 END) as removed
+    FROM wikilink_applications
+    WHERE applied_at >= ? AND applied_at <= ?
+    GROUP BY day ORDER BY day
+  `).all(startIso, endIso + " 23:59:59");
+  return rows.map((r) => ({ ...r, net: r.applied - r.removed }));
+}
+function queryFeedbackByDay(stateDb2, startIso, endIso) {
+  return stateDb2.db.prepare(`
+    SELECT date(created_at) as day,
+      SUM(CASE WHEN correct=1 THEN 1 ELSE 0 END) as positive,
+      SUM(CASE WHEN correct=0 THEN 1 ELSE 0 END) as negative,
+      COUNT(*) as total
+    FROM wikilink_feedback
+    WHERE created_at >= ? AND created_at <= ?
+    GROUP BY day ORDER BY day
+  `).all(startIso, endIso + " 23:59:59");
+}
+function querySurvival(stateDb2, startIso, endIso) {
+  const row = stateDb2.db.prepare(`
+    SELECT
+      COUNT(*) as total_applied,
+      SUM(CASE WHEN status='applied' THEN 1 ELSE 0 END) as still_active,
+      SUM(CASE WHEN status='removed' THEN 1 ELSE 0 END) as removed
+    FROM wikilink_applications
+    WHERE applied_at >= ? AND applied_at <= ?
+  `).get(startIso, endIso + " 23:59:59");
+  return {
+    ...row,
+    survival_rate: row.total_applied > 0 ? Math.round(row.still_active / row.total_applied * 1e3) / 1e3 : null
+  };
+}
+function queryTopRejected(stateDb2, startIso, endIso) {
+  return stateDb2.db.prepare(`
+    SELECT entity,
+      SUM(CASE WHEN status='removed' THEN 1 ELSE 0 END) as removed_count,
+      COUNT(*) as applied_count
+    FROM wikilink_applications
+    WHERE applied_at >= ? AND applied_at <= ?
+    GROUP BY entity COLLATE NOCASE
+    HAVING removed_count > 0
+    ORDER BY removed_count DESC
+    LIMIT 10
+  `).all(startIso, endIso + " 23:59:59").map((r) => ({
+    entity: r.entity,
+    removed_count: r.removed_count,
+    applied_count: r.applied_count,
+    rejection_rate: Math.round(r.removed_count / r.applied_count * 1e3) / 1e3
+  }));
+}
+function queryFunnel(stateDb2, startIso, endIso, startMs, endMs) {
+  const evalRow = stateDb2.db.prepare(`
+    SELECT
+      COUNT(*) as evaluations,
+      SUM(CASE WHEN passed=1 THEN 1 ELSE 0 END) as threshold_passes
+    FROM suggestion_events
+    WHERE timestamp >= ? AND timestamp < ?
+  `).get(startMs, endMs);
+  const appRow = stateDb2.db.prepare(`
+    SELECT
+      COUNT(*) as applications,
+      SUM(CASE WHEN status='applied' THEN 1 ELSE 0 END) as survivals
+    FROM wikilink_applications
+    WHERE applied_at >= ? AND applied_at <= ?
+  `).get(startIso, endIso + " 23:59:59");
+  return {
+    evaluations: evalRow.evaluations,
+    applications: appRow.applications,
+    survivals: appRow.survivals,
+    application_rate: evalRow.evaluations > 0 ? Math.round(appRow.applications / evalRow.evaluations * 1e5) / 1e5 : null,
+    survival_rate: appRow.applications > 0 ? Math.round(appRow.survivals / appRow.applications * 1e3) / 1e3 : null
+  };
+}
+function getLearningReport(stateDb2, entityCount, linkCount, daysBack = 7, compare = false) {
+  const now = /* @__PURE__ */ new Date();
+  const bounds = periodBounds(daysBack, now);
+  const report = {
+    period: { start: bounds.start, end: bounds.end, days: daysBack },
+    applications_by_day: queryApplicationsByDay(stateDb2, bounds.start, bounds.end),
+    feedback_by_day: queryFeedbackByDay(stateDb2, bounds.start, bounds.end),
+    survival: querySurvival(stateDb2, bounds.start, bounds.end),
+    top_rejected: queryTopRejected(stateDb2, bounds.start, bounds.end),
+    funnel: queryFunnel(stateDb2, bounds.start, bounds.end, bounds.startMs, bounds.endMs),
+    graph: { link_count: linkCount, entity_count: entityCount }
+  };
+  if (compare) {
+    const prevEnd = new Date(now);
+    prevEnd.setDate(prevEnd.getDate() - daysBack);
+    const prevBounds = periodBounds(daysBack, prevEnd);
+    const prevSurvival = querySurvival(stateDb2, prevBounds.start, prevBounds.end);
+    const prevFeedback = queryFeedbackByDay(stateDb2, prevBounds.start, prevBounds.end);
+    const prevApps = queryApplicationsByDay(stateDb2, prevBounds.start, prevBounds.end);
+    const currAppsTotal = report.applications_by_day.reduce((s, d) => s + d.applied, 0);
+    const prevAppsTotal = prevApps.reduce((s, d) => s + d.applied, 0);
+    const currFeedbackTotal = report.feedback_by_day.reduce((s, d) => s + d.total, 0);
+    const prevFeedbackTotal = prevFeedback.reduce((s, d) => s + d.total, 0);
+    report.comparison = {
+      previous_period: { start: prevBounds.start, end: prevBounds.end },
+      applications_delta: currAppsTotal - prevAppsTotal,
+      feedback_delta: currFeedbackTotal - prevFeedbackTotal,
+      survival_rate_delta: report.survival.survival_rate != null && prevSurvival.survival_rate != null ? Math.round((report.survival.survival_rate - prevSurvival.survival_rate) * 1e3) / 1e3 : null
+    };
+  }
+  return report;
+}
+
+// src/tools/read/learningReport.ts
+function registerLearningReportTools(server2, getIndex, getStateDb3) {
+  server2.tool(
+    "flywheel_learning_report",
+    "Get a narrative report of the flywheel auto-linking system's learning progress. Shows: applications by day, feedback (positive/negative), survival rate, top rejected entities, suggestion funnel (evaluations \u2192 applications \u2192 survivals), and graph growth. Use compare=true for period-over-period deltas.",
+    {
+      days_back: z38.number().min(1).max(365).optional().describe("Analysis window in days (default: 7). Use 1 for today, 2 for last 48h, etc."),
+      compare: z38.boolean().optional().describe("Include comparison with the preceding equal-length period (default: false)")
+    },
+    async (args) => {
+      const stateDb2 = getStateDb3();
+      if (!stateDb2) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }],
+          isError: true
+        };
+      }
+      const index = getIndex();
+      const metrics = computeMetrics(index, stateDb2);
+      const report = getLearningReport(
+        stateDb2,
+        metrics.entity_count,
+        metrics.link_count,
+        args.days_back ?? 7,
+        args.compare ?? false
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(report, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/read/calibrationExport.ts
+import { z as z39 } from "zod";
+
+// src/core/read/calibrationExport.ts
+init_wikilinkFeedback();
+init_embeddings();
+import { createHash as createHash3 } from "node:crypto";
+var LAYER_KEYS = [
+  "contentMatch",
+  "cooccurrenceBoost",
+  "typeBoost",
+  "contextBoost",
+  "recencyBoost",
+  "crossFolderBoost",
+  "hubBoost",
+  "feedbackAdjustment",
+  "suppressionPenalty",
+  "semanticBoost",
+  "edgeWeightBoost"
+];
+var THRESHOLD_SWEEP = [5, 8, 10, 12, 15, 18, 20, 25, 30];
+function sizeBucket(count) {
+  if (count < 50) return "tiny";
+  if (count < 200) return "small";
+  if (count < 1e3) return "medium";
+  if (count < 5e3) return "large";
+  return "huge";
+}
+function round(n, decimals = 3) {
+  const f = Math.pow(10, decimals);
+  return Math.round(n * f) / f;
+}
+function queryEntityDistribution(stateDb2) {
+  const rows = stateDb2.db.prepare(
+    "SELECT category, count(*) as cnt FROM entities GROUP BY category ORDER BY cnt DESC"
+  ).all();
+  const result = {};
+  for (const r of rows) result[r.category] = r.cnt;
+  return result;
+}
+function queryFunnel2(stateDb2, startMs, startIso, endIso) {
+  const evalRow = stateDb2.db.prepare(
+    "SELECT COUNT(*) as total FROM suggestion_events WHERE timestamp >= ?"
+  ).get(startMs);
+  const appRow = stateDb2.db.prepare(`
+    SELECT COUNT(*) as total,
+      SUM(CASE WHEN status='applied' THEN 1 ELSE 0 END) as survivals,
+      SUM(CASE WHEN status='removed' THEN 1 ELSE 0 END) as removals
+    FROM wikilink_applications WHERE applied_at >= ? AND applied_at <= ?
+  `).get(startIso, endIso + " 23:59:59");
+  return {
+    total_evaluations: evalRow.total,
+    total_applications: appRow.total,
+    total_survivals: appRow.survivals,
+    total_removals: appRow.removals,
+    survival_rate: appRow.total > 0 ? round(appRow.survivals / appRow.total) : null
+  };
+}
+function queryLayerContributions(stateDb2, startMs) {
+  const rows = stateDb2.db.prepare(
+    "SELECT breakdown_json FROM suggestion_events WHERE timestamp >= ?"
+  ).all(startMs);
+  const sums = {};
+  const topCounts = {};
+  for (const k of LAYER_KEYS) {
+    sums[k] = 0;
+    topCounts[k] = 0;
+  }
+  let count = 0;
+  for (const row of rows) {
+    let bd;
+    try {
+      bd = JSON.parse(row.breakdown_json);
+    } catch {
+      continue;
+    }
+    count++;
+    let topLayer = "";
+    let topVal = -Infinity;
+    for (const k of LAYER_KEYS) {
+      const v = Math.abs(bd[k] ?? 0);
+      sums[k] += v;
+      if (v > topVal) {
+        topVal = v;
+        topLayer = k;
+      }
+    }
+    if (topLayer) topCounts[topLayer] = (topCounts[topLayer] || 0) + 1;
+  }
+  const averages = {};
+  for (const k of LAYER_KEYS) averages[k] = count > 0 ? round(sums[k] / count) : 0;
+  return { averages, top_contributor_counts: topCounts, event_count: count };
+}
+function queryScoreDistribution(stateDb2, startMs) {
+  const rows = stateDb2.db.prepare(
+    "SELECT total_score FROM suggestion_events WHERE timestamp >= ? ORDER BY total_score"
+  ).all(startMs);
+  const bins = [];
+  for (let i = 0; i < 50; i += 5) {
+    bins.push({ min: i, max: i + 5, count: 0 });
+  }
+  bins.push({ min: 50, max: Infinity, count: 0 });
+  let sum = 0;
+  for (const r of rows) {
+    sum += r.total_score;
+    const binIdx = r.total_score >= 50 ? bins.length - 1 : Math.floor(r.total_score / 5);
+    if (binIdx >= 0 && binIdx < bins.length) bins[binIdx].count++;
+  }
+  const n = rows.length;
+  return {
+    bins: bins.map((b) => ({ min: b.min, max: b.max === Infinity ? 999 : b.max, count: b.count })),
+    mean_score: n > 0 ? round(sum / n) : 0,
+    median_score: n > 0 ? rows[Math.floor(n / 2)].total_score : 0
+  };
+}
+function querySurvivalByCategory(stateDb2, startIso, endIso) {
+  const rows = stateDb2.db.prepare(`
+    SELECT e.category,
+      COUNT(*) as applied,
+      SUM(CASE WHEN wa.status='applied' THEN 1 ELSE 0 END) as survived,
+      SUM(CASE WHEN wa.status='removed' THEN 1 ELSE 0 END) as removed
+    FROM wikilink_applications wa
+    JOIN entities e ON e.name_lower = LOWER(wa.entity)
+    WHERE wa.applied_at >= ? AND wa.applied_at <= ?
+    GROUP BY e.category
+  `).all(startIso, endIso + " 23:59:59");
+  const result = {};
+  for (const r of rows) {
+    result[r.category] = {
+      applied: r.applied,
+      survived: r.survived,
+      removed: r.removed,
+      survival_rate: r.applied > 0 ? round(r.survived / r.applied) : null
+    };
+  }
+  return result;
+}
+function queryFeedback(stateDb2, startIso, endIso) {
+  const row = stateDb2.db.prepare(`
+    SELECT
+      COUNT(*) as total,
+      SUM(CASE WHEN confidence >= 0.9 THEN 1 ELSE 0 END) as explicit_count,
+      SUM(CASE WHEN confidence < 0.9 THEN 1 ELSE 0 END) as implicit_count,
+      SUM(CASE WHEN confidence >= 0.9 AND correct=1 THEN 1 ELSE 0 END) as explicit_correct,
+      SUM(CASE WHEN confidence < 0.9 AND correct=1 THEN 1 ELSE 0 END) as implicit_correct
+    FROM wikilink_feedback WHERE created_at >= ? AND created_at <= ?
+  `).get(startIso, endIso + " 23:59:59");
+  return {
+    total: row.total,
+    explicit_count: row.explicit_count,
+    implicit_count: row.implicit_count,
+    explicit_accuracy: row.explicit_count > 0 ? round(row.explicit_correct / row.explicit_count) : null,
+    implicit_accuracy: row.implicit_count > 0 ? round(row.implicit_correct / row.implicit_count) : null
+  };
+}
+function querySuppression(stateDb2) {
+  const stats = getWeightedEntityStats(stateDb2);
+  const suppressed = getSuppressedCount(stateDb2);
+  return {
+    entities_suppressed: suppressed,
+    entities_with_feedback: stats.length,
+    suppression_rate: stats.length > 0 ? round(suppressed / stats.length) : null
+  };
+}
+function queryRecencyAnalysis(stateDb2, startMs, startIso, endIso) {
+  const rows = stateDb2.db.prepare(`
+    SELECT se.breakdown_json, wa.status
+    FROM suggestion_events se
+    JOIN wikilink_applications wa ON LOWER(se.entity) = LOWER(wa.entity)
+      AND se.note_path = wa.note_path
+    WHERE se.timestamp >= ? AND wa.applied_at >= ? AND wa.applied_at <= ?
+  `).all(startMs, startIso, endIso + " 23:59:59");
+  let survivedSum = 0, survivedCount = 0;
+  let removedSum = 0, removedCount = 0;
+  for (const r of rows) {
+    let bd;
+    try {
+      bd = JSON.parse(r.breakdown_json);
+    } catch {
+      continue;
+    }
+    const recency = bd.recencyBoost ?? 0;
+    if (r.status === "applied") {
+      survivedSum += recency;
+      survivedCount++;
+    } else {
+      removedSum += recency;
+      removedCount++;
+    }
+  }
+  return {
+    avg_recency_when_survived: survivedCount > 0 ? round(survivedSum / survivedCount) : 0,
+    avg_recency_when_removed: removedCount > 0 ? round(removedSum / removedCount) : 0
+  };
+}
+function queryCooccurrenceAnalysis(stateDb2, startMs, startIso, endIso) {
+  const rows = stateDb2.db.prepare(`
+    SELECT se.breakdown_json, wa.status
+    FROM suggestion_events se
+    LEFT JOIN wikilink_applications wa ON LOWER(se.entity) = LOWER(wa.entity)
+      AND se.note_path = wa.note_path
+      AND wa.applied_at >= ? AND wa.applied_at <= ?
+    WHERE se.timestamp >= ?
+  `).all(startIso, endIso + " 23:59:59", startMs);
+  let totalCount = 0, coocOnlyCount = 0;
+  let coocOnlyApplied = 0, coocOnlySurvived = 0;
+  let coocSum = 0;
+  for (const r of rows) {
+    let bd;
+    try {
+      bd = JSON.parse(r.breakdown_json);
+    } catch {
+      continue;
+    }
+    totalCount++;
+    coocSum += bd.cooccurrenceBoost ?? 0;
+    if ((bd.contentMatch ?? 0) === 0 && (bd.cooccurrenceBoost ?? 0) > 0) {
+      coocOnlyCount++;
+      if (r.status != null) {
+        coocOnlyApplied++;
+        if (r.status === "applied") coocOnlySurvived++;
+      }
+    }
+  }
+  return {
+    cooc_only_rate: totalCount > 0 ? round(coocOnlyCount / totalCount) : 0,
+    cooc_only_survival_rate: coocOnlyApplied > 0 ? round(coocOnlySurvived / coocOnlyApplied) : null,
+    avg_cooc_boost: totalCount > 0 ? round(coocSum / totalCount) : 0
+  };
+}
+function queryThresholdAnalysis(stateDb2, startMs) {
+  const rows = stateDb2.db.prepare(
+    "SELECT total_score FROM suggestion_events WHERE timestamp >= ?"
+  ).all(startMs);
+  const total = rows.length;
+  return {
+    pass_rates_at_thresholds: THRESHOLD_SWEEP.map((t) => ({
+      threshold: t,
+      pass_rate: total > 0 ? round(rows.filter((r) => r.total_score >= t).length / total, 4) : 0
+    }))
+  };
+}
+function queryFlywheelAgeDays(stateDb2) {
+  const row = stateDb2.db.prepare(
+    "SELECT MIN(timestamp) as first_ts FROM suggestion_events"
+  ).get();
+  if (!row?.first_ts) return 0;
+  return Math.floor((Date.now() - row.first_ts) / (24 * 60 * 60 * 1e3));
+}
+function getCalibrationExport(stateDb2, metrics, config, daysBack = 30, includeVaultId = true) {
+  const now = /* @__PURE__ */ new Date();
+  const start = new Date(now);
+  start.setDate(start.getDate() - daysBack + 1);
+  start.setHours(0, 0, 0, 0);
+  const startIso = start.toISOString().slice(0, 10);
+  const endIso = now.toISOString().slice(0, 10);
+  const startMs = start.getTime();
+  let vaultId;
+  if (includeVaultId) {
+    vaultId = createHash3("sha256").update(stateDb2.vaultPath).digest("hex").slice(0, 16);
+  }
+  return {
+    schema_version: 1,
+    exported_at: now.toISOString(),
+    vault_id: vaultId,
+    vault_profile: {
+      size_bucket: sizeBucket(metrics.note_count),
+      entity_bucket: sizeBucket(metrics.entity_count),
+      avg_links_per_note: round(metrics.avg_links_per_note, 1),
+      connected_ratio: round(metrics.connected_ratio),
+      semantic_enabled: hasEmbeddingsIndex(),
+      flywheel_age_days: queryFlywheelAgeDays(stateDb2),
+      strictness_mode: config.wikilink_strictness ?? "balanced",
+      adaptive_strictness: config.adaptive_strictness ?? true
+    },
+    entity_distribution: queryEntityDistribution(stateDb2),
+    funnel: queryFunnel2(stateDb2, startMs, startIso, endIso),
+    layer_contributions: queryLayerContributions(stateDb2, startMs),
+    score_distribution: queryScoreDistribution(stateDb2, startMs),
+    survival_by_category: querySurvivalByCategory(stateDb2, startIso, endIso),
+    feedback: queryFeedback(stateDb2, startIso, endIso),
+    suppression: querySuppression(stateDb2),
+    recency_analysis: queryRecencyAnalysis(stateDb2, startMs, startIso, endIso),
+    cooccurrence_analysis: queryCooccurrenceAnalysis(stateDb2, startMs, startIso, endIso),
+    threshold_analysis: queryThresholdAnalysis(stateDb2, startMs)
+  };
+}
+
+// src/tools/read/calibrationExport.ts
+function registerCalibrationExportTools(server2, getIndex, getStateDb3, getConfig2) {
+  server2.tool(
+    "flywheel_calibration_export",
+    "Export anonymized aggregate scoring data for cross-vault algorithm calibration. No entity names, note paths, or content \u2014 safe to share. Includes: suggestion funnel, per-layer contribution averages, survival rates by entity category, score distribution, suppression stats, recency/co-occurrence effectiveness, and threshold sweep.",
+    {
+      days_back: z39.number().min(1).max(365).optional().describe("Analysis window in days (default: 30)"),
+      include_vault_id: z39.boolean().optional().describe("Include anonymous vault ID for longitudinal tracking (default: true)")
+    },
+    async (args) => {
+      const stateDb2 = getStateDb3();
+      if (!stateDb2) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }],
+          isError: true
+        };
+      }
+      const index = getIndex();
+      const metrics = computeMetrics(index, stateDb2);
+      const config = getConfig2();
+      const report = getCalibrationExport(
+        stateDb2,
+        metrics,
+        config,
+        args.days_back ?? 30,
+        args.include_vault_id ?? true
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(report, null, 2) }]
+      };
+    }
+  );
+}
+
 // src/resources/vault.ts
 function registerVaultResources(server2, getIndex) {
   server2.registerResource(
@@ -24359,7 +25036,7 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
               let totalBytes = 0;
               for (const p of notePaths) {
                 try {
-                  totalBytes += statSync6(path35.join(vp, p)).size;
+                  totalBytes += statSync6(path37.join(vp, p)).size;
                 } catch {
                 }
               }
@@ -24448,7 +25125,7 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
     const schemaIdx = handlerIdx - 1;
     const schema = args[schemaIdx];
     if (schema && typeof schema === "object" && !Array.isArray(schema)) {
-      schema.vault = z38.string().optional().describe(
+      schema.vault = z40.string().optional().describe(
         `Vault name for multi-vault mode. Available: ${registry.getVaultNames().join(", ")}. Default: ${registry.primaryName}`
       );
     }
@@ -24571,6 +25248,8 @@ function registerAllTools(targetServer, ctx) {
   registerTemporalAnalysisTools(targetServer, gvi, gvp, gsd);
   registerSessionHistoryTools(targetServer, gsd);
   registerEntityHistoryTools(targetServer, gsd);
+  registerLearningReportTools(targetServer, gvi, gsd);
+  registerCalibrationExportTools(targetServer, gvi, gsd, gcf);
   registerMemoryTools(targetServer, gsd);
   registerRecallTools(targetServer, gsd, gvp, () => gvi() ?? null);
   registerBriefTools(targetServer, gsd);
@@ -24645,6 +25324,15 @@ registerAllTools(server, _registryCtx);
 var categoryList = Array.from(enabledCategories).sort().join(", ");
 serverLog("server", `Tool categories: ${categoryList}`);
 serverLog("server", `Registered ${_gatingResult.registered} tools, skipped ${_gatingResult.skipped}`);
+function loadVaultCooccurrence(ctx) {
+  if (!ctx.stateDb) return;
+  const cachedCooc = loadCooccurrenceFromStateDb(ctx.stateDb);
+  if (cachedCooc) {
+    ctx.cooccurrenceIndex = cachedCooc.index;
+    ctx.lastCooccurrenceRebuildAt = cachedCooc.builtAt;
+    serverLog("index", `[${ctx.name}] Co-occurrence: loaded from cache (${Object.keys(cachedCooc.index.associations).length} entities, ${cachedCooc.index._metadata.total_associations} associations)`);
+  }
+}
 async function initializeVault(name, vaultPathArg) {
   const ctx = {
     name,
@@ -24848,13 +25536,10 @@ async function main() {
   if (vaultConfigs) {
     vaultRegistry = new VaultRegistry(vaultConfigs[0].name);
     serverLog("server", `Multi-vault mode: ${vaultConfigs.map((v) => v.name).join(", ")}`);
-    for (const vc of vaultConfigs) {
-      const ctx = await initializeVault(vc.name, vc.path);
-      vaultRegistry.addContext(ctx);
-    }
-    const primary = vaultRegistry.getContext();
-    stateDb = primary.stateDb;
-    activateVault(primary);
+    const primaryCtx2 = await initializeVault(vaultConfigs[0].name, vaultConfigs[0].path);
+    vaultRegistry.addContext(primaryCtx2);
+    stateDb = primaryCtx2.stateDb;
+    activateVault(primaryCtx2);
   } else {
     vaultRegistry = new VaultRegistry("default");
     const ctx = await initializeVault("default", vaultPath);
@@ -24862,25 +25547,11 @@ async function main() {
     stateDb = ctx.stateDb;
     activateVault(ctx);
   }
-  for (const ctx of vaultRegistry.getAllContexts()) {
-    if (ctx.stateDb) {
-      const cachedCooc = loadCooccurrenceFromStateDb(ctx.stateDb);
-      if (cachedCooc) {
-        ctx.cooccurrenceIndex = cachedCooc.index;
-        ctx.lastCooccurrenceRebuildAt = cachedCooc.builtAt;
-        serverLog("index", `[${ctx.name}] Co-occurrence: loaded from cache (${Object.keys(cachedCooc.index.associations).length} entities, ${cachedCooc.index._metadata.total_associations} associations)`);
-      }
-    }
-  }
-  {
-    const primary = vaultRegistry.getContext();
-    activateVault(primary);
-  }
   const transportMode = (process.env.FLYWHEEL_TRANSPORT ?? "stdio").toLowerCase();
   if (transportMode === "stdio" || transportMode === "both") {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    serverLog("server", "MCP server connected (stdio)");
+    serverLog("server", `MCP server connected (stdio) in ${Date.now() - startTime}ms`);
   }
   if (transportMode === "http" || transportMode === "both") {
     const { createMcpExpressApp } = await import("@modelcontextprotocol/sdk/server/express.js");
@@ -24913,10 +25584,27 @@ async function main() {
       serverLog("server", `HTTP transport on ${httpHost}:${httpPort}`);
     });
   }
-  for (const vaultCtx of vaultRegistry.getAllContexts()) {
-    activateVault(vaultCtx);
-    stateDb = vaultCtx.stateDb;
-    await bootVault(vaultCtx, startTime);
+  const primaryCtx = vaultRegistry.getContext();
+  loadVaultCooccurrence(primaryCtx);
+  activateVault(primaryCtx);
+  await bootVault(primaryCtx, startTime);
+  if (vaultConfigs && vaultConfigs.length > 1) {
+    const secondaryConfigs = vaultConfigs.slice(1);
+    (async () => {
+      for (const vc of secondaryConfigs) {
+        try {
+          const ctx = await initializeVault(vc.name, vc.path);
+          vaultRegistry.addContext(ctx);
+          loadVaultCooccurrence(ctx);
+          activateVault(ctx);
+          await bootVault(ctx, startTime);
+          serverLog("server", `[${vc.name}] Secondary vault ready`);
+        } catch (err) {
+          serverLog("server", `[${vc.name}] Secondary vault boot failed: ${err}`, "error");
+        }
+      }
+      activateVault(vaultRegistry.getContext());
+    })();
   }
 }
 var DEFAULT_ENTITY_EXCLUDE_FOLDERS = ["node_modules", "templates", "attachments", "tmp"];
@@ -24946,7 +25634,7 @@ async function buildStartupCatchupBatch(vaultPath2, sinceMs) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path36.join(dir, entry.name);
+      const fullPath = path38.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
         await scanDir(fullPath);
@@ -24956,7 +25644,7 @@ async function buildStartupCatchupBatch(vaultPath2, sinceMs) {
           if (stat5.mtimeMs > sinceMs) {
             events.push({
               type: "upsert",
-              path: path36.relative(vaultPath2, fullPath),
+              path: path38.relative(vaultPath2, fullPath),
               originalEvents: []
             });
           }
@@ -25153,8 +25841,8 @@ async function runPostIndexWork(ctx) {
           }
         } catch {
           try {
-            const dir = path36.dirname(rawPath);
-            const base = path36.basename(rawPath);
+            const dir = path38.dirname(rawPath);
+            const base = path38.basename(rawPath);
             const resolvedDir = realpathSync(dir).replace(/\\/g, "/");
             for (const prefix of vaultPrefixes) {
               if (resolvedDir.startsWith(prefix + "/") || resolvedDir === prefix) {
@@ -25186,8 +25874,8 @@ async function runPostIndexWork(ctx) {
           continue;
         }
         try {
-          const content = await fs34.readFile(path36.join(vp, event.path), "utf-8");
-          const hash = createHash3("sha256").update(content).digest("hex").slice(0, 16);
+          const content = await fs34.readFile(path38.join(vp, event.path), "utf-8");
+          const hash = createHash4("sha256").update(content).digest("hex").slice(0, 16);
           if (lastContentHashes.get(event.path) === hash) {
             serverLog("watcher", `Hash unchanged, skipping: ${event.path}`);
             continue;