@velvetmonkey/flywheel-memory 2.0.124 → 2.0.126

package/dist/index.js

@@ -895,17 +895,17 @@ function updateSuppressionList(stateDb2, now) {
       `DELETE FROM wikilink_suppressions
        WHERE datetime(updated_at, '+' || ? || ' days') <= datetime('now')`
     ).run(SUPPRESSION_TTL_DAYS);
-    for (const stat4 of weightedStats) {
-      const posteriorMean = computePosteriorMean(stat4.weightedCorrect, stat4.weightedFp);
-      const totalObs = PRIOR_ALPHA + stat4.weightedCorrect + PRIOR_BETA + stat4.weightedFp;
+    for (const stat5 of weightedStats) {
+      const posteriorMean = computePosteriorMean(stat5.weightedCorrect, stat5.weightedFp);
+      const totalObs = PRIOR_ALPHA + stat5.weightedCorrect + PRIOR_BETA + stat5.weightedFp;
       if (totalObs < SUPPRESSION_MIN_OBSERVATIONS) {
         continue;
       }
       if (posteriorMean < SUPPRESSION_POSTERIOR_THRESHOLD) {
-        upsert.run(stat4.entity, 1 - posteriorMean);
+        upsert.run(stat5.entity, 1 - posteriorMean);
         updated++;
       } else {
-        remove.run(stat4.entity);
+        remove.run(stat5.entity);
       }
     }
   });
@@ -974,31 +974,31 @@ function getAllFeedbackBoosts(stateDb2, folder, now) {
   if (folder !== void 0) {
     folderStatsMap = /* @__PURE__ */ new Map();
     for (const gs of globalStats) {
-      const fs33 = getWeightedFolderStats(stateDb2, gs.entity, folder, now);
-      if (fs33.rawTotal >= FEEDBACK_BOOST_MIN_SAMPLES) {
+      const fs34 = getWeightedFolderStats(stateDb2, gs.entity, folder, now);
+      if (fs34.rawTotal >= FEEDBACK_BOOST_MIN_SAMPLES) {
         folderStatsMap.set(gs.entity, {
-          weightedAccuracy: fs33.weightedAccuracy,
-          rawCount: fs33.rawTotal
+          weightedAccuracy: fs34.weightedAccuracy,
+          rawCount: fs34.rawTotal
         });
       }
     }
   }
   const boosts = /* @__PURE__ */ new Map();
-  for (const stat4 of globalStats) {
-    if (stat4.rawTotal < FEEDBACK_BOOST_MIN_SAMPLES) continue;
+  for (const stat5 of globalStats) {
+    if (stat5.rawTotal < FEEDBACK_BOOST_MIN_SAMPLES) continue;
     let accuracy;
     let sampleCount;
-    const fs33 = folderStatsMap?.get(stat4.entity);
-    if (fs33 && fs33.rawCount >= FEEDBACK_BOOST_MIN_SAMPLES) {
-      accuracy = fs33.weightedAccuracy;
-      sampleCount = fs33.rawCount;
+    const fs34 = folderStatsMap?.get(stat5.entity);
+    if (fs34 && fs34.rawCount >= FEEDBACK_BOOST_MIN_SAMPLES) {
+      accuracy = fs34.weightedAccuracy;
+      sampleCount = fs34.rawCount;
     } else {
-      accuracy = stat4.weightedAccuracy;
-      sampleCount = stat4.rawTotal;
+      accuracy = stat5.weightedAccuracy;
+      sampleCount = stat5.rawTotal;
     }
     const boost = computeBoostFromAccuracy(accuracy, sampleCount);
     if (boost !== 0) {
-      boosts.set(stat4.entity, boost);
+      boosts.set(stat5.entity, boost);
     }
   }
   return boosts;
@@ -1006,13 +1006,13 @@ function getAllFeedbackBoosts(stateDb2, folder, now) {
 function getAllSuppressionPenalties(stateDb2, now) {
   const penalties = /* @__PURE__ */ new Map();
   const weightedStats = getWeightedEntityStats(stateDb2, now);
-  for (const stat4 of weightedStats) {
-    const posteriorMean = computePosteriorMean(stat4.weightedCorrect, stat4.weightedFp);
-    const totalObs = PRIOR_ALPHA + stat4.weightedCorrect + PRIOR_BETA + stat4.weightedFp;
+  for (const stat5 of weightedStats) {
+    const posteriorMean = computePosteriorMean(stat5.weightedCorrect, stat5.weightedFp);
+    const totalObs = PRIOR_ALPHA + stat5.weightedCorrect + PRIOR_BETA + stat5.weightedFp;
     if (totalObs >= SUPPRESSION_MIN_OBSERVATIONS && posteriorMean < SUPPRESSION_POSTERIOR_THRESHOLD) {
       const penalty = Math.round(MAX_SUPPRESSION_PENALTY * (1 - posteriorMean / SUPPRESSION_POSTERIOR_THRESHOLD));
       if (penalty < 0) {
-        penalties.set(stat4.entity, penalty);
+        penalties.set(stat5.entity, penalty);
       }
     }
   }
@@ -1554,8 +1554,8 @@ function clearLastMutationCommit() {
 async function checkGitLock(vaultPath2) {
   const lockPath = path8.join(vaultPath2, ".git/index.lock");
   try {
-    const stat4 = await fs6.stat(lockPath);
-    const ageMs = Date.now() - stat4.mtimeMs;
+    const stat5 = await fs6.stat(lockPath);
+    const ageMs = Date.now() - stat5.mtimeMs;
     return {
       locked: true,
       stale: ageMs > STALE_LOCK_THRESHOLD_MS,
@@ -1577,8 +1577,8 @@ async function isGitRepo(vaultPath2) {
 async function checkLockFile(vaultPath2) {
   const lockPath = path8.join(vaultPath2, ".git/index.lock");
   try {
-    const stat4 = await fs6.stat(lockPath);
-    const ageMs = Date.now() - stat4.mtimeMs;
+    const stat5 = await fs6.stat(lockPath);
+    const ageMs = Date.now() - stat5.mtimeMs;
     return { stale: ageMs > STALE_LOCK_THRESHOLD_MS, ageMs };
   } catch {
     return null;
@@ -3282,6 +3282,7 @@ var init_edgeWeights = __esm({
 // src/core/write/wikilinks.ts
 var wikilinks_exports = {};
 __export(wikilinks_exports, {
+  applyProactiveSuggestions: () => applyProactiveSuggestions,
   checkAndRefreshIfStale: () => checkAndRefreshIfStale,
   checkPreflightSimilarity: () => checkPreflightSimilarity,
   detectAliasCollisions: () => detectAliasCollisions,
@@ -3289,6 +3290,7 @@ __export(wikilinks_exports, {
   getCooccurrenceIndex: () => getCooccurrenceIndex,
   getEntityIndex: () => getEntityIndex,
   getEntityIndexStats: () => getEntityIndexStats,
+  getNoteContext: () => getNoteContext,
   getWikilinkStrictness: () => getWikilinkStrictness,
   getWriteStateDb: () => getWriteStateDb,
   initializeEntityIndex: () => initializeEntityIndex,
@@ -3317,6 +3319,8 @@ import {
   getEntitiesByAlias,
   searchEntities as searchEntitiesDb
 } from "@velvetmonkey/vault-core";
+import path11 from "path";
+import * as fs7 from "fs/promises";
 function setWriteStateDb(stateDb2) {
   moduleStateDb5 = stateDb2;
   setGitStateDb(stateDb2);
@@ -4233,6 +4237,76 @@ async function checkPreflightSimilarity(noteName) {
   }
   return result;
 }
+async function applyProactiveSuggestions(filePath, vaultPath2, suggestions, config) {
+  const stateDb2 = getWriteStateDb();
+  const candidates = suggestions.filter((s) => s.score >= config.minScore && s.confidence === "high").slice(0, config.maxPerFile);
+  if (candidates.length === 0) {
+    return { applied: [], skipped: [] };
+  }
+  const fullPath = path11.join(vaultPath2, filePath);
+  try {
+    const stat5 = await fs7.stat(fullPath);
+    if (Date.now() - stat5.mtimeMs < 3e4) {
+      return { applied: [], skipped: candidates.map((c) => c.entity) };
+    }
+  } catch {
+    return { applied: [], skipped: candidates.map((c) => c.entity) };
+  }
+  let content;
+  try {
+    content = await fs7.readFile(fullPath, "utf-8");
+  } catch {
+    return { applied: [], skipped: candidates.map((c) => c.entity) };
+  }
+  const entityObjects = [];
+  for (const candidate of candidates) {
+    if (stateDb2 && isSuppressed(stateDb2, candidate.entity)) continue;
+    if (stateDb2) {
+      const entityObj = getEntityByName(stateDb2, candidate.entity);
+      if (entityObj) {
+        entityObjects.push({
+          name: entityObj.name,
+          path: entityObj.path,
+          aliases: entityObj.aliases ?? []
+        });
+        continue;
+      }
+    }
+    entityObjects.push(candidate.entity);
+  }
+  if (entityObjects.length === 0) {
+    return { applied: [], skipped: candidates.map((c) => c.entity) };
+  }
+  const result = applyWikilinks(content, entityObjects, {
+    firstOccurrenceOnly: true,
+    caseInsensitive: true
+  });
+  if (result.linksAdded === 0) {
+    return { applied: [], skipped: candidates.map((c) => c.entity) };
+  }
+  try {
+    await fs7.writeFile(fullPath, result.content, "utf-8");
+  } catch {
+    return { applied: [], skipped: candidates.map((c) => c.entity) };
+  }
+  if (stateDb2) {
+    trackWikilinkApplications(stateDb2, filePath, result.linkedEntities);
+    try {
+      const markApplied = stateDb2.db.prepare(
+        `UPDATE suggestion_events SET applied = 1
+         WHERE note_path = ? AND entity = ? AND applied = 0`
+      );
+      for (const entity of result.linkedEntities) {
+        markApplied.run(filePath, entity);
+      }
+    } catch {
+    }
+  }
+  return {
+    applied: result.linkedEntities,
+    skipped: candidates.map((c) => c.entity).filter((e) => !result.linkedEntities.includes(e))
+  };
+}
 var moduleStateDb5, moduleConfig, ALL_IMPLICIT_PATTERNS, entityIndex, indexReady, indexError2, lastLoadedAt, cooccurrenceIndex, recencyIndex, DEFAULT_EXCLUDE_FOLDERS, SUGGESTION_PATTERN, GENERIC_WORDS, MAX_ENTITY_LENGTH, MAX_ENTITY_WORDS, ARTICLE_PATTERNS, STRICTNESS_CONFIGS, TYPE_BOOST, CROSS_FOLDER_BOOST, SEMANTIC_MIN_SIMILARITY, SEMANTIC_MAX_BOOST, CONTEXT_BOOST, MIN_SUGGESTION_SCORE, MIN_MATCH_RATIO, FULL_ALIAS_MATCH_BONUS;
 var init_wikilinks = __esm({
   "src/core/write/wikilinks.ts"() {
@@ -4478,8 +4552,8 @@ var init_constants = __esm({
 });
 
 // src/core/write/writer.ts
-import fs18 from "fs/promises";
-import path20 from "path";
+import fs19 from "fs/promises";
+import path21 from "path";
 import matter5 from "gray-matter";
 import { createHash as createHash2 } from "node:crypto";
 function isSensitivePath(filePath) {
@@ -4807,13 +4881,13 @@ function validatePath(vaultPath2, notePath) {
   if (notePath.startsWith("\\")) {
     return false;
   }
-  const resolvedVault = path20.resolve(vaultPath2);
-  const resolvedNote = path20.resolve(vaultPath2, notePath);
+  const resolvedVault = path21.resolve(vaultPath2);
+  const resolvedNote = path21.resolve(vaultPath2, notePath);
   return resolvedNote.startsWith(resolvedVault);
 }
 function sanitizeNotePath(notePath) {
-  const dir = path20.dirname(notePath);
-  let filename = path20.basename(notePath);
+  const dir = path21.dirname(notePath);
+  let filename = path21.basename(notePath);
   const ext = filename.endsWith(".md") ? ".md" : "";
   let stem2 = ext ? filename.slice(0, -ext.length) : filename;
   stem2 = stem2.replace(/\s+/g, "-");
@@ -4822,7 +4896,7 @@ function sanitizeNotePath(notePath) {
   stem2 = stem2.replace(/-{2,}/g, "-");
   stem2 = stem2.replace(/^-+|-+$/g, "");
   filename = stem2 + (ext || ".md");
-  return dir === "." ? filename : path20.join(dir, filename).replace(/\\/g, "/");
+  return dir === "." ? filename : path21.join(dir, filename).replace(/\\/g, "/");
 }
 async function validatePathSecure(vaultPath2, notePath) {
   if (notePath.startsWith("/")) {
@@ -4849,8 +4923,8 @@ async function validatePathSecure(vaultPath2, notePath) {
       reason: "Path traversal not allowed"
     };
   }
-  const resolvedVault = path20.resolve(vaultPath2);
-  const resolvedNote = path20.resolve(vaultPath2, notePath);
+  const resolvedVault = path21.resolve(vaultPath2);
+  const resolvedNote = path21.resolve(vaultPath2, notePath);
   if (!resolvedNote.startsWith(resolvedVault)) {
     return {
       valid: false,
@@ -4864,18 +4938,18 @@ async function validatePathSecure(vaultPath2, notePath) {
     };
   }
   try {
-    const fullPath = path20.join(vaultPath2, notePath);
+    const fullPath = path21.join(vaultPath2, notePath);
     try {
-      await fs18.access(fullPath);
-      const realPath = await fs18.realpath(fullPath);
-      const realVaultPath = await fs18.realpath(vaultPath2);
+      await fs19.access(fullPath);
+      const realPath = await fs19.realpath(fullPath);
+      const realVaultPath = await fs19.realpath(vaultPath2);
       if (!realPath.startsWith(realVaultPath)) {
         return {
           valid: false,
           reason: "Symlink target is outside vault"
         };
       }
-      const relativePath = path20.relative(realVaultPath, realPath);
+      const relativePath = path21.relative(realVaultPath, realPath);
       if (isSensitivePath(relativePath)) {
         return {
           valid: false,
@@ -4883,11 +4957,11 @@ async function validatePathSecure(vaultPath2, notePath) {
         };
       }
     } catch {
-      const parentDir = path20.dirname(fullPath);
+      const parentDir = path21.dirname(fullPath);
       try {
-        await fs18.access(parentDir);
-        const realParentPath = await fs18.realpath(parentDir);
-        const realVaultPath = await fs18.realpath(vaultPath2);
+        await fs19.access(parentDir);
+        const realParentPath = await fs19.realpath(parentDir);
+        const realVaultPath = await fs19.realpath(vaultPath2);
         if (!realParentPath.startsWith(realVaultPath)) {
           return {
             valid: false,
@@ -4912,10 +4986,10 @@ async function readVaultFile(vaultPath2, notePath) {
   if (!validatePath(vaultPath2, notePath)) {
     throw new Error("Invalid path: path traversal not allowed");
   }
-  const fullPath = path20.join(vaultPath2, notePath);
-  const [rawContent, stat4] = await Promise.all([
-    fs18.readFile(fullPath, "utf-8"),
-    fs18.stat(fullPath)
+  const fullPath = path21.join(vaultPath2, notePath);
+  const [rawContent, stat5] = await Promise.all([
+    fs19.readFile(fullPath, "utf-8"),
+    fs19.stat(fullPath)
   ]);
   const contentHash2 = computeContentHash(rawContent);
   const lineEnding = detectLineEnding(rawContent);
@@ -4927,7 +5001,7 @@ async function readVaultFile(vaultPath2, notePath) {
     frontmatter,
     rawContent,
     lineEnding,
-    mtimeMs: stat4.mtimeMs,
+    mtimeMs: stat5.mtimeMs,
     contentHash: contentHash2
   };
 }
@@ -4967,9 +5041,9 @@ async function writeVaultFile(vaultPath2, notePath, content, frontmatter, lineEn
   if (!validation.valid) {
     throw new Error(`Invalid path: ${validation.reason}`);
   }
-  const fullPath = path20.join(vaultPath2, notePath);
+  const fullPath = path21.join(vaultPath2, notePath);
   if (expectedHash) {
-    const currentRaw = await fs18.readFile(fullPath, "utf-8");
+    const currentRaw = await fs19.readFile(fullPath, "utf-8");
     const currentHash = computeContentHash(currentRaw);
     if (currentHash !== expectedHash) {
       throw new WriteConflictError(notePath);
@@ -4978,7 +5052,7 @@ async function writeVaultFile(vaultPath2, notePath, content, frontmatter, lineEn
   let output = matter5.stringify(content, frontmatter);
   output = normalizeTrailingNewline(output);
   output = convertLineEndings(output, lineEnding);
-  await fs18.writeFile(fullPath, output, "utf-8");
+  await fs19.writeFile(fullPath, output, "utf-8");
 }
 function removeFromSection(content, section, pattern, mode = "first", useRegex = false) {
   const lines = content.split("\n");
@@ -5367,8 +5441,8 @@ function createContext(variables = {}) {
     steps: {}
   };
 }
-function resolvePath(obj, path33) {
-  const parts = path33.split(".");
+function resolvePath(obj, path34) {
+  const parts = path34.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === void 0 || current === null) {
@@ -5825,8 +5899,8 @@ __export(conditions_exports, {
   evaluateCondition: () => evaluateCondition,
   shouldStepExecute: () => shouldStepExecute
 });
-import fs25 from "fs/promises";
-import path26 from "path";
+import fs26 from "fs/promises";
+import path27 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;
@@ -5879,9 +5953,9 @@ async function evaluateCondition(condition, vaultPath2, context) {
   }
 }
 async function evaluateFileExists(vaultPath2, notePath, expectExists) {
-  const fullPath = path26.join(vaultPath2, notePath);
+  const fullPath = path27.join(vaultPath2, notePath);
   try {
-    await fs25.access(fullPath);
+    await fs26.access(fullPath);
     return {
       met: expectExists,
       reason: expectExists ? `File exists: ${notePath}` : `File exists (expected not to): ${notePath}`
@@ -5894,9 +5968,9 @@ async function evaluateFileExists(vaultPath2, notePath, expectExists) {
   }
 }
 async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectExists) {
-  const fullPath = path26.join(vaultPath2, notePath);
+  const fullPath = path27.join(vaultPath2, notePath);
   try {
-    await fs25.access(fullPath);
+    await fs26.access(fullPath);
   } catch {
     return {
       met: !expectExists,
@@ -5925,9 +5999,9 @@ async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectEx
   }
 }
 async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expectExists) {
-  const fullPath = path26.join(vaultPath2, notePath);
+  const fullPath = path27.join(vaultPath2, notePath);
   try {
-    await fs25.access(fullPath);
+    await fs26.access(fullPath);
   } catch {
     return {
       met: !expectExists,
@@ -5956,9 +6030,9 @@ async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expect
   }
 }
 async function evaluateFrontmatterEquals(vaultPath2, notePath, fieldName, expectedValue) {
-  const fullPath = path26.join(vaultPath2, notePath);
+  const fullPath = path27.join(vaultPath2, notePath);
   try {
-    await fs25.access(fullPath);
+    await fs26.access(fullPath);
   } catch {
     return {
       met: false,
@@ -6100,7 +6174,7 @@ var init_taskHelpers = __esm({
 });
 
 // src/index.ts
-import * as path32 from "path";
+import * as path33 from "path";
 import { readFileSync as readFileSync5, realpathSync, existsSync as existsSync3, statSync as statSync5 } from "fs";
 import { fileURLToPath } from "url";
 import { dirname as dirname6, join as join17 } from "path";
@@ -6339,8 +6413,8 @@ function updateIndexProgress(parsed, total) {
 function normalizeTarget(target) {
   return target.toLowerCase().replace(/\.md$/, "");
 }
-function normalizeNotePath(path33) {
-  return path33.toLowerCase().replace(/\.md$/, "");
+function normalizeNotePath(path34) {
+  return path34.toLowerCase().replace(/\.md$/, "");
 }
 async function buildVaultIndex(vaultPath2, options = {}) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
@@ -6509,7 +6583,7 @@ function findSimilarEntity(index, target) {
   }
   const maxDist = normalizedLen <= 10 ? 1 : 2;
   let bestMatch;
-  for (const [entity, path33] of index.entities) {
+  for (const [entity, path34] of index.entities) {
     const lenDiff = Math.abs(entity.length - normalizedLen);
     if (lenDiff > maxDist) {
       continue;
@@ -6517,7 +6591,7 @@ function findSimilarEntity(index, target) {
     const dist = levenshteinDistance(normalized, entity);
     if (dist > 0 && dist <= maxDist) {
       if (!bestMatch || dist < bestMatch.distance) {
-        bestMatch = { path: path33, entity, distance: dist };
+        bestMatch = { path: path34, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -7048,30 +7122,30 @@ var EventQueue = class {
    * Add a new event to the queue
    */
   push(type, rawPath) {
-    const path33 = normalizePath(rawPath);
+    const path34 = normalizePath(rawPath);
     const now = Date.now();
     const event = {
       type,
-      path: path33,
+      path: path34,
       timestamp: now
     };
-    let pending = this.pending.get(path33);
+    let pending = this.pending.get(path34);
     if (!pending) {
       pending = {
         events: [],
         timer: null,
         lastEvent: now
       };
-      this.pending.set(path33, pending);
+      this.pending.set(path34, pending);
     }
     pending.events.push(event);
     pending.lastEvent = now;
-    console.error(`[flywheel] QUEUE: pushed ${type} for ${path33}, pending=${this.pending.size}`);
+    console.error(`[flywheel] QUEUE: pushed ${type} for ${path34}, pending=${this.pending.size}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
     }
     pending.timer = setTimeout(() => {
-      this.flushPath(path33);
+      this.flushPath(path34);
     }, this.config.debounceMs);
     if (this.pending.size >= this.config.batchSize) {
       this.flush();
@@ -7092,10 +7166,10 @@ var EventQueue = class {
   /**
    * Flush a single path's events
    */
-  flushPath(path33) {
-    const pending = this.pending.get(path33);
+  flushPath(path34) {
+    const pending = this.pending.get(path34);
     if (!pending || pending.events.length === 0) return;
-    console.error(`[flywheel] QUEUE: flushing ${path33}, events=${pending.events.length}`);
+    console.error(`[flywheel] QUEUE: flushing ${path34}, events=${pending.events.length}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -7104,7 +7178,7 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path33,
+        path: path34,
         originalEvents: [...pending.events]
       };
       this.onBatch({
@@ -7113,7 +7187,7 @@ var EventQueue = class {
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path33);
+    this.pending.delete(path34);
   }
   /**
    * Flush all pending events
@@ -7125,7 +7199,7 @@ var EventQueue = class {
     }
     if (this.pending.size === 0) return;
     const events = [];
-    for (const [path33, pending] of this.pending) {
+    for (const [path34, pending] of this.pending) {
       if (pending.timer) {
         clearTimeout(pending.timer);
       }
@@ -7133,7 +7207,7 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path33,
+          path: path34,
           originalEvents: [...pending.events]
         });
       }
@@ -7326,8 +7400,8 @@ async function upsertNote(index, vaultPath2, notePath) {
       releasedKeys = removeNoteFromIndex(index, notePath);
     }
     const fullPath = path7.join(vaultPath2, notePath);
-    const fs33 = await import("fs/promises");
-    const stats = await fs33.stat(fullPath);
+    const fs34 = await import("fs/promises");
+    const stats = await fs34.stat(fullPath);
     const vaultFile = {
       path: notePath,
       absolutePath: fullPath,
@@ -7519,31 +7593,31 @@ function createVaultWatcher(options) {
         usePolling: config.usePolling,
         interval: config.usePolling ? config.pollInterval : void 0
       });
-      watcher.on("add", (path33) => {
-        console.error(`[flywheel] RAW EVENT: add ${path33}`);
-        if (shouldWatch(path33, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: add ${path33}`);
-          eventQueue.push("add", path33);
+      watcher.on("add", (path34) => {
+        console.error(`[flywheel] RAW EVENT: add ${path34}`);
+        if (shouldWatch(path34, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: add ${path34}`);
+          eventQueue.push("add", path34);
         } else {
-          console.error(`[flywheel] FILTERED: add ${path33}`);
+          console.error(`[flywheel] FILTERED: add ${path34}`);
         }
       });
-      watcher.on("change", (path33) => {
-        console.error(`[flywheel] RAW EVENT: change ${path33}`);
-        if (shouldWatch(path33, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: change ${path33}`);
-          eventQueue.push("change", path33);
+      watcher.on("change", (path34) => {
+        console.error(`[flywheel] RAW EVENT: change ${path34}`);
+        if (shouldWatch(path34, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: change ${path34}`);
+          eventQueue.push("change", path34);
         } else {
-          console.error(`[flywheel] FILTERED: change ${path33}`);
+          console.error(`[flywheel] FILTERED: change ${path34}`);
         }
       });
-      watcher.on("unlink", (path33) => {
-        console.error(`[flywheel] RAW EVENT: unlink ${path33}`);
-        if (shouldWatch(path33, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: unlink ${path33}`);
-          eventQueue.push("unlink", path33);
+      watcher.on("unlink", (path34) => {
+        console.error(`[flywheel] RAW EVENT: unlink ${path34}`);
+        if (shouldWatch(path34, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: unlink ${path34}`);
+          eventQueue.push("unlink", path34);
         } else {
-          console.error(`[flywheel] FILTERED: unlink ${path33}`);
+          console.error(`[flywheel] FILTERED: unlink ${path34}`);
         }
       });
       watcher.on("ready", () => {
@@ -7722,7 +7796,7 @@ async function flushLogs() {
 init_vault();
 init_serverLog();
 init_vault_scope();
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 var EXCLUDED_DIRS3 = /* @__PURE__ */ new Set([
   ".obsidian",
   ".trash",
@@ -7790,11 +7864,11 @@ async function buildFTS5Index(vaultPath2) {
     const rows = [];
     for (const file of indexableFiles) {
       try {
-        const stats = fs7.statSync(file.absolutePath);
+        const stats = fs8.statSync(file.absolutePath);
         if (stats.size > MAX_INDEX_FILE_SIZE) {
           continue;
         }
-        const raw = fs7.readFileSync(file.absolutePath, "utf-8");
+        const raw = fs8.readFileSync(file.absolutePath, "utf-8");
         const { frontmatter, body } = splitFrontmatter(raw);
         const title = file.path.replace(/\.md$/, "").split("/").pop() || file.path;
         rows.push([file.path, title, frontmatter, body]);
@@ -7921,11 +7995,11 @@ function countFTS5Mentions(term) {
 init_embeddings();
 
 // src/core/read/taskCache.ts
-import * as path12 from "path";
+import * as path13 from "path";
 
 // src/tools/read/tasks.ts
-import * as fs8 from "fs";
-import * as path11 from "path";
+import * as fs9 from "fs";
+import * as path12 from "path";
 var TASK_REGEX = /^(\s*)- \[([ xX\-])\]\s+(.+)$/;
 var TAG_REGEX2 = /#([a-zA-Z][a-zA-Z0-9_/-]*)/g;
 var DATE_REGEX = /\b(\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}\/\d{2,4})\b/;
@@ -7951,7 +8025,7 @@ function extractDueDate(text) {
 async function extractTasksFromNote(notePath, absolutePath) {
   let content;
   try {
-    content = await fs8.promises.readFile(absolutePath, "utf-8");
+    content = await fs9.promises.readFile(absolutePath, "utf-8");
   } catch {
     return [];
   }
@@ -7994,7 +8068,7 @@ async function getAllTasks(index, vaultPath2, options = {}) {
   const allTasks = [];
   for (const note of index.notes.values()) {
     if (folder && !note.path.startsWith(folder)) continue;
-    const absolutePath = path11.join(vaultPath2, note.path);
+    const absolutePath = path12.join(vaultPath2, note.path);
     const tasks = await extractTasksFromNote(note.path, absolutePath);
     allTasks.push(...tasks);
   }
@@ -8038,7 +8112,7 @@ async function getAllTasks(index, vaultPath2, options = {}) {
 async function getTasksFromNote(index, notePath, vaultPath2, excludeTags = []) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path11.join(vaultPath2, notePath);
+  const absolutePath = path12.join(vaultPath2, notePath);
   let tasks = await extractTasksFromNote(notePath, absolutePath);
   if (excludeTags.length > 0) {
     tasks = tasks.filter(
@@ -8100,7 +8174,7 @@ async function buildTaskCache(vaultPath2, index, excludeTags) {
     }
     const allRows = [];
     for (const notePath of notePaths) {
-      const absolutePath = path12.join(vaultPath2, notePath);
+      const absolutePath = path13.join(vaultPath2, notePath);
       const tasks = await extractTasksFromNote(notePath, absolutePath);
       for (const task of tasks) {
         if (excludeTags?.length && excludeTags.some((t) => task.tags.includes(t))) {
@@ -8143,7 +8217,7 @@ async function updateTaskCacheForFile(vaultPath2, relativePath) {
   const db4 = getDb3();
   if (!db4) return;
   db4.prepare("DELETE FROM tasks WHERE path = ?").run(relativePath);
-  const absolutePath = path12.join(vaultPath2, relativePath);
+  const absolutePath = path13.join(vaultPath2, relativePath);
   const tasks = await extractTasksFromNote(relativePath, absolutePath);
   if (tasks.length > 0) {
     const insertStmt = db4.prepare(`
@@ -8285,8 +8359,8 @@ function refreshIfStale(vaultPath2, index, excludeTags) {
 import { openStateDb, scanVaultEntities as scanVaultEntities4, getSessionId, getAllEntitiesFromDb as getAllEntitiesFromDb3, findEntityMatches as findEntityMatches2, getProtectedZones as getProtectedZones2, rangeOverlapsProtectedZone, detectImplicitEntities as detectImplicitEntities3, loadContentHashes, saveContentHashBatch, renameContentHash } from "@velvetmonkey/vault-core";
 
 // src/tools/read/graph.ts
-import * as fs9 from "fs";
-import * as path13 from "path";
+import * as fs10 from "fs";
+import * as path14 from "path";
 import { z } from "zod";
 
 // src/core/read/constants.ts
@@ -8737,8 +8811,8 @@ function requireIndex() {
 // src/tools/read/graph.ts
 async function getContext(vaultPath2, sourcePath, line, contextLines = 1) {
   try {
-    const fullPath = path13.join(vaultPath2, sourcePath);
-    const content = await fs9.promises.readFile(fullPath, "utf-8");
+    const fullPath = path14.join(vaultPath2, sourcePath);
+    const content = await fs10.promises.readFile(fullPath, "utf-8");
     const allLines = content.split("\n");
     let fmLines = 0;
     if (allLines[0]?.trimEnd() === "---") {
@@ -9211,15 +9285,15 @@ function registerWikilinkTools(server2, getIndex, getVaultPath, getStateDb2 = ()
               const weightedStats = getWeightedEntityStats(stateDb2);
               const statsMap = new Map(weightedStats.map((s) => [s.entity.toLowerCase(), s]));
               for (const suggestion of scored.detailed) {
-                const stat4 = statsMap.get(suggestion.entity.toLowerCase());
-                if (stat4) {
-                  const posteriorMean = computePosteriorMean(stat4.weightedCorrect, stat4.weightedFp);
-                  const totalObs = PRIOR_ALPHA + stat4.weightedCorrect + PRIOR_BETA + stat4.weightedFp;
+                const stat5 = statsMap.get(suggestion.entity.toLowerCase());
+                if (stat5) {
+                  const posteriorMean = computePosteriorMean(stat5.weightedCorrect, stat5.weightedFp);
+                  const totalObs = PRIOR_ALPHA + stat5.weightedCorrect + PRIOR_BETA + stat5.weightedFp;
                   suggestion.suppressionContext = {
                     posteriorMean: Math.round(posteriorMean * 1e3) / 1e3,
                     totalObservations: Math.round(totalObs * 10) / 10,
                     isSuppressed: totalObs >= SUPPRESSION_MIN_OBSERVATIONS && posteriorMean < SUPPRESSION_POSTERIOR_THRESHOLD,
-                    falsePositiveRate: Math.round(stat4.weightedFpRate * 1e3) / 1e3
+                    falsePositiveRate: Math.round(stat5.weightedFpRate * 1e3) / 1e3
                   };
                 }
               }
@@ -9264,14 +9338,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath, getStateDb2 = ()
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path33] of entities) {
+    for (const [name, path34] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path33;
+        return path34;
       }
     }
-    for (const [name, path33] of entities) {
+    for (const [name, path34] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path33;
+        return path34;
       }
     }
     return void 0;
@@ -9493,7 +9567,7 @@ function registerWikilinkTools(server2, getIndex, getVaultPath, getStateDb2 = ()
 }
 
 // src/tools/read/health.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import { z as z3 } from "zod";
 
 // src/tools/read/periodic.ts
@@ -10112,7 +10186,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
       const indexErrorObj = getIndexError();
       let vaultAccessible = false;
       try {
-        fs10.accessSync(vaultPath2, fs10.constants.R_OK);
+        fs11.accessSync(vaultPath2, fs11.constants.R_OK);
         vaultAccessible = true;
       } catch {
         vaultAccessible = false;
@@ -10354,8 +10428,8 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
       daily_counts: z3.record(z3.number())
     }).describe("Activity summary for the last 7 days")
   };
-  function isPeriodicNote3(path33) {
-    const filename = path33.split("/").pop() || "";
+  function isPeriodicNote3(path34) {
+    const filename = path34.split("/").pop() || "";
     const nameWithoutExt = filename.replace(/\.md$/, "");
     const patterns = [
       /^\d{4}-\d{2}-\d{2}$/,
@@ -10370,7 +10444,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
       // YYYY (yearly)
     ];
     const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
-    const folder = path33.split("/")[0]?.toLowerCase() || "";
+    const folder = path34.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   server2.registerTool(
@@ -10519,7 +10593,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
         detail: `Schema version ${SCHEMA_VERSION}`
       });
       try {
-        fs10.accessSync(vaultPath2, fs10.constants.R_OK | fs10.constants.W_OK);
+        fs11.accessSync(vaultPath2, fs11.constants.R_OK | fs11.constants.W_OK);
         checks.push({ name: "vault_access", status: "ok", detail: `Vault readable and writable at ${vaultPath2}` });
       } catch {
         checks.push({ name: "vault_access", status: "error", detail: `Vault not accessible at ${vaultPath2}`, fix: "Check PROJECT_PATH environment variable and directory permissions" });
@@ -10605,11 +10679,11 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
         try {
           const dbPath = stateDb2.db.name;
           if (dbPath && dbPath !== ":memory:") {
-            const dbStat = fs10.statSync(dbPath);
+            const dbStat = fs11.statSync(dbPath);
             const dbSizeMb = Math.round(dbStat.size / 1024 / 1024 * 10) / 10;
             let walSizeMb = 0;
             try {
-              const walStat = fs10.statSync(dbPath + "-wal");
+              const walStat = fs11.statSync(dbPath + "-wal");
               walSizeMb = Math.round(walStat.size / 1024 / 1024 * 10) / 10;
             } catch {
             }
@@ -10838,6 +10912,7 @@ function enrichResultCompact(result, index, stateDb2, opts) {
     if (preview) enriched.snippet = preview;
   }
   if (note) {
+    if (Object.keys(note.frontmatter).length > 0) enriched.frontmatter = note.frontmatter;
     enriched.backlink_count = backlinks.length;
     enriched.modified = note.modified.toISOString();
     if (note.tags.length > 0) enriched.tags = note.tags;
@@ -10968,6 +11043,7 @@ function enrichEntityCompact(entityName, stateDb2, index) {
       const backlinks = index.backlinks.get(normalizedPath) || [];
       enriched.backlink_count = backlinks.length;
       if (note) {
+        if (Object.keys(note.frontmatter).length > 0) enriched.frontmatter = note.frontmatter;
         if (note.tags.length > 0) enriched.tags = note.tags;
         if (note.outlinks.length > 0) {
           enriched.outlink_names = getOutlinkNames(note.outlinks, entityPath, index, stateDb2, COMPACT_OUTLINK_NAMES);
@@ -10984,6 +11060,7 @@ function enrichNoteCompact(notePath, stateDb2, index) {
   if (!note) return enriched;
   const normalizedPath = notePath.toLowerCase().replace(/\.md$/, "");
   const backlinks = index.backlinks.get(normalizedPath) || [];
+  if (Object.keys(note.frontmatter).length > 0) enriched.frontmatter = note.frontmatter;
   if (note.tags.length > 0) enriched.tags = note.tags;
   enriched.backlink_count = backlinks.length;
   enriched.modified = note.modified.toISOString();
@@ -11064,13 +11141,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(path33, index, stateDb2) {
-  const note = index.notes.get(path33);
+function scoreCandidate(path34, index, stateDb2) {
+  const note = index.notes.get(path34);
   const decay = recencyDecay(note?.modified);
   let hubScore = 1;
   if (stateDb2) {
     try {
-      const title = note?.title ?? path33.replace(/\.md$/, "").split("/").pop() ?? "";
+      const title = note?.title ?? path34.replace(/\.md$/, "").split("/").pop() ?? "";
       const entity = getEntityByName3(stateDb2, title);
       if (entity) hubScore = entity.hubScore ?? 1;
     } catch {
@@ -11448,8 +11525,8 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb2) {
 }
 
 // src/tools/read/system.ts
-import * as fs11 from "fs";
-import * as path14 from "path";
+import * as fs12 from "fs";
+import * as path15 from "path";
 import { z as z5 } from "zod";
 import { scanVaultEntities as scanVaultEntities2, getEntityIndexFromDb as getEntityIndexFromDb2 } from "@velvetmonkey/vault-core";
 
@@ -11762,8 +11839,8 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
           continue;
         }
         try {
-          const fullPath = path14.join(vaultPath2, note.path);
-          const content = await fs11.promises.readFile(fullPath, "utf-8");
+          const fullPath = path15.join(vaultPath2, note.path);
+          const content = await fs12.promises.readFile(fullPath, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
@@ -12022,8 +12099,8 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
 import { z as z6 } from "zod";
 
 // src/tools/read/structure.ts
-import * as fs12 from "fs";
-import * as path15 from "path";
+import * as fs13 from "fs";
+import * as path16 from "path";
 var HEADING_REGEX2 = /^(#{1,6})\s+(.+)$/;
 function extractHeadings2(content) {
   const lines = content.split("\n");
@@ -12077,10 +12154,10 @@ function buildSections(headings, totalLines) {
 async function getNoteStructure(index, notePath, vaultPath2) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path15.join(vaultPath2, notePath);
+  const absolutePath = path16.join(vaultPath2, notePath);
   let content;
   try {
-    content = await fs12.promises.readFile(absolutePath, "utf-8");
+    content = await fs13.promises.readFile(absolutePath, "utf-8");
   } catch {
     return null;
   }
@@ -12100,10 +12177,10 @@ async function getNoteStructure(index, notePath, vaultPath2) {
 async function getSectionContent(index, notePath, headingText, vaultPath2, includeSubheadings = true) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path15.join(vaultPath2, notePath);
+  const absolutePath = path16.join(vaultPath2, notePath);
   let content;
   try {
-    content = await fs12.promises.readFile(absolutePath, "utf-8");
+    content = await fs13.promises.readFile(absolutePath, "utf-8");
   } catch {
     return null;
   }
@@ -12142,10 +12219,10 @@ async function findSections(index, headingPattern, vaultPath2, folder) {
   const results = [];
   for (const note of index.notes.values()) {
     if (folder && !note.path.startsWith(folder)) continue;
-    const absolutePath = path15.join(vaultPath2, note.path);
+    const absolutePath = path16.join(vaultPath2, note.path);
     let content;
     try {
-      content = await fs12.promises.readFile(absolutePath, "utf-8");
+      content = await fs13.promises.readFile(absolutePath, "utf-8");
     } catch {
       continue;
     }
@@ -12177,30 +12254,30 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         include_content: z6.boolean().default(true).describe("Include the text content under each top-level section. Set false to get structure only.")
       }
     },
-    async ({ path: path33, include_content }) => {
+    async ({ path: path34, include_content }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path33, vaultPath2);
+      const result = await getNoteStructure(index, path34, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path33 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path34 }, null, 2) }]
         };
       }
       if (include_content) {
         for (const section of result.sections) {
-          const sectionResult = await getSectionContent(index, path33, section.heading.text, vaultPath2, true);
+          const sectionResult = await getSectionContent(index, path34, section.heading.text, vaultPath2, true);
           if (sectionResult) {
             section.content = sectionResult.content;
           }
         }
       }
-      const note = index.notes.get(path33);
+      const note = index.notes.get(path34);
       const enriched = { ...result };
       if (note) {
         enriched.frontmatter = note.frontmatter;
         enriched.tags = note.tags;
         enriched.aliases = note.aliases;
-        const normalizedPath = path33.toLowerCase().replace(/\.md$/, "");
+        const normalizedPath = path34.toLowerCase().replace(/\.md$/, "");
         const backlinks = index.backlinks.get(normalizedPath) || [];
         enriched.backlink_count = backlinks.length;
         enriched.outlink_count = note.outlinks.length;
@@ -12233,15 +12310,15 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         include_subheadings: z6.boolean().default(true).describe("Include content under subheadings")
       }
     },
-    async ({ path: path33, heading, include_subheadings }) => {
+    async ({ path: path34, heading, include_subheadings }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path33, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path34, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path33,
+            path: path34,
             heading
           }, null, 2) }]
         };
@@ -12295,16 +12372,16 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         offset: z6.coerce.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path33, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
+    async ({ path: path34, 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 (path33) {
-        const result2 = await getTasksFromNote(index, path33, vaultPath2, config.exclude_task_tags || []);
+      if (path34) {
+        const result2 = await getTasksFromNote(index, path34, vaultPath2, config.exclude_task_tags || []);
         if (!result2) {
           return {
-            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path33 }, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path34 }, null, 2) }]
           };
         }
         let filtered = result2;
@@ -12314,7 +12391,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         const paged2 = filtered.slice(offset, offset + limit);
         return {
           content: [{ type: "text", text: JSON.stringify({
-            path: path33,
+            path: path34,
             total_count: filtered.length,
             returned_count: paged2.length,
             open: result2.filter((t) => t.status === "open").length,
@@ -12469,8 +12546,8 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
 
 // src/tools/read/migrations.ts
 import { z as z7 } from "zod";
-import * as fs13 from "fs/promises";
-import * as path16 from "path";
+import * as fs14 from "fs/promises";
+import * as path17 from "path";
 import matter2 from "gray-matter";
 function getNotesInFolder(index, folder) {
   const notes = [];
@@ -12483,17 +12560,17 @@ function getNotesInFolder(index, folder) {
   return notes;
 }
 async function readFileContent(notePath, vaultPath2) {
-  const fullPath = path16.join(vaultPath2, notePath);
+  const fullPath = path17.join(vaultPath2, notePath);
   try {
-    return await fs13.readFile(fullPath, "utf-8");
+    return await fs14.readFile(fullPath, "utf-8");
   } catch {
     return null;
   }
 }
 async function writeFileContent(notePath, vaultPath2, content) {
-  const fullPath = path16.join(vaultPath2, notePath);
+  const fullPath = path17.join(vaultPath2, notePath);
   try {
-    await fs13.writeFile(fullPath, content, "utf-8");
+    await fs14.writeFile(fullPath, content, "utf-8");
     return true;
   } catch {
     return false;
@@ -12671,8 +12748,8 @@ function registerMigrationTools(server2, getIndex, getVaultPath) {
 }
 
 // src/tools/read/graphAnalysis.ts
-import fs14 from "node:fs";
-import path17 from "node:path";
+import fs15 from "node:fs";
+import path18 from "node:path";
 import { z as z8 } from "zod";
 
 // src/tools/read/schema.ts
@@ -13385,7 +13462,7 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb2
           const scored = allNotes.map((note) => {
             let wordCount = 0;
             try {
-              const content = fs14.readFileSync(path17.join(vaultPath2, note.path), "utf-8");
+              const content = fs15.readFileSync(path18.join(vaultPath2, note.path), "utf-8");
               const body = content.replace(/^---[\s\S]*?---\n?/, "");
               wordCount = body.split(/\s+/).filter((w) => w.length > 0).length;
             } catch {
@@ -14015,15 +14092,15 @@ function registerSemanticAnalysisTools(server2, getIndex, getVaultPath) {
 import { z as z11 } from "zod";
 
 // src/tools/read/bidirectional.ts
-import * as fs15 from "fs/promises";
-import * as path18 from "path";
+import * as fs16 from "fs/promises";
+import * as path19 from "path";
 import matter3 from "gray-matter";
 var PROSE_PATTERN_REGEX = /^([A-Za-z][A-Za-z0-9 _-]*):\s*(?:\[\[([^\]]+)\]\]|"([^"]+)"|([^\n]+?))\s*$/gm;
 var CODE_BLOCK_REGEX2 = /```[\s\S]*?```|`[^`\n]+`/g;
 async function readFileContent2(notePath, vaultPath2) {
-  const fullPath = path18.join(vaultPath2, notePath);
+  const fullPath = path19.join(vaultPath2, notePath);
   try {
-    return await fs15.readFile(fullPath, "utf-8");
+    return await fs16.readFile(fullPath, "utf-8");
   } catch {
     return null;
   }
@@ -14199,21 +14276,21 @@ async function suggestWikilinksInFrontmatter(index, notePath, vaultPath2) {
 }
 
 // src/tools/read/computed.ts
-import * as fs16 from "fs/promises";
-import * as path19 from "path";
+import * as fs17 from "fs/promises";
+import * as path20 from "path";
 import matter4 from "gray-matter";
 async function readFileContent3(notePath, vaultPath2) {
-  const fullPath = path19.join(vaultPath2, notePath);
+  const fullPath = path20.join(vaultPath2, notePath);
   try {
-    return await fs16.readFile(fullPath, "utf-8");
+    return await fs17.readFile(fullPath, "utf-8");
   } catch {
     return null;
   }
 }
 async function getFileStats(notePath, vaultPath2) {
-  const fullPath = path19.join(vaultPath2, notePath);
+  const fullPath = path20.join(vaultPath2, notePath);
   try {
-    const stats = await fs16.stat(fullPath);
+    const stats = await fs17.stat(fullPath);
     return {
       modified: stats.mtime,
       created: stats.birthtime
@@ -14343,7 +14420,7 @@ async function computeFrontmatter(index, notePath, vaultPath2, fields) {
 
 // src/tools/read/noteIntelligence.ts
 init_embeddings();
-import fs17 from "node:fs";
+import fs18 from "node:fs";
 import nodePath from "node:path";
 function registerNoteIntelligenceTools(server2, getIndex, getVaultPath, getConfig2) {
   server2.registerTool(
@@ -14403,7 +14480,7 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath, getConfi
           }
           let noteContent;
           try {
-            noteContent = fs17.readFileSync(nodePath.join(vaultPath2, notePath), "utf-8");
+            noteContent = fs18.readFileSync(nodePath.join(vaultPath2, notePath), "utf-8");
           } catch {
             return {
               content: [{ type: "text", text: JSON.stringify({
@@ -14482,8 +14559,8 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath, getConfi
 // src/tools/write/mutations.ts
 init_writer();
 import { z as z12 } from "zod";
-import fs20 from "fs/promises";
-import path22 from "path";
+import fs21 from "fs/promises";
+import path23 from "path";
 
 // src/core/write/validator.ts
 var TIMESTAMP_PATTERN = /^\*\*\d{2}:\d{2}\*\*/;
@@ -14701,8 +14778,8 @@ init_constants();
 init_writer();
 init_wikilinks();
 init_wikilinkFeedback();
-import fs19 from "fs/promises";
-import path21 from "path";
+import fs20 from "fs/promises";
+import path22 from "path";
 function formatMcpResult(result) {
   if (result.tokensEstimate === void 0 || result.tokensEstimate === 0) {
     result.tokensEstimate = estimateTokens(result);
@@ -14750,8 +14827,8 @@ async function handleGitCommit(vaultPath2, notePath, commit, prefix) {
 }
 async function getPolicyHint(vaultPath2) {
   try {
-    const policiesDir = path21.join(vaultPath2, ".claude", "policies");
-    const files = await fs19.readdir(policiesDir);
+    const policiesDir = path22.join(vaultPath2, ".claude", "policies");
+    const files = await fs20.readdir(policiesDir);
     const yamlFiles = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
     if (yamlFiles.length > 0) {
       const names = yamlFiles.map((f) => f.replace(/\.ya?ml$/, "")).join(", ");
@@ -14762,9 +14839,9 @@ async function getPolicyHint(vaultPath2) {
   return "";
 }
 async function ensureFileExists(vaultPath2, notePath) {
-  const fullPath = path21.join(vaultPath2, notePath);
+  const fullPath = path22.join(vaultPath2, notePath);
   try {
-    await fs19.access(fullPath);
+    await fs20.access(fullPath);
     return null;
   } catch {
     const hint = await getPolicyHint(vaultPath2);
@@ -14940,17 +15017,17 @@ async function executeCreateNote(options) {
     if (!pathCheck.valid) {
       return { success: false, result: errorResult(notePath, `Path blocked: ${pathCheck.reason}`), filesWritten: [] };
     }
-    const fullPath = path21.join(vaultPath2, notePath);
+    const fullPath = path22.join(vaultPath2, notePath);
     let fileExists = false;
     try {
-      await fs19.access(fullPath);
+      await fs20.access(fullPath);
       fileExists = true;
     } catch {
     }
     if (fileExists && !overwrite) {
       return { success: false, result: errorResult(notePath, `File already exists: ${notePath}. Use overwrite=true to replace.`), filesWritten: [] };
     }
-    await fs19.mkdir(path21.dirname(fullPath), { recursive: true });
+    await fs20.mkdir(path22.dirname(fullPath), { recursive: true });
     const { maybeApplyWikilinks: maybeApplyWikilinks2 } = await Promise.resolve().then(() => (init_wikilinks(), wikilinks_exports));
     const { content: processedContent } = maybeApplyWikilinks2(content, skipWikilinks ?? false, notePath);
     let finalFrontmatter = frontmatter;
@@ -14984,13 +15061,13 @@ async function executeDeleteNote(options) {
     if (!pathCheck.valid) {
       return { success: false, result: errorResult(notePath, `Path blocked: ${pathCheck.reason}`), filesWritten: [] };
     }
-    const fullPath = path21.join(vaultPath2, notePath);
+    const fullPath = path22.join(vaultPath2, notePath);
     try {
-      await fs19.access(fullPath);
+      await fs20.access(fullPath);
     } catch {
       return { success: false, result: errorResult(notePath, `File not found: ${notePath}`), filesWritten: [] };
     }
-    await fs19.unlink(fullPath);
+    await fs20.unlink(fullPath);
     const result = successResult(notePath, `Deleted note: ${notePath}`, {});
     return { success: true, result, filesWritten: [notePath] };
   } catch (error) {
@@ -15008,10 +15085,10 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   if (!validation.valid) {
     throw new Error(`Path blocked: ${validation.reason}`);
   }
-  const fullPath = path22.join(vaultPath2, notePath);
-  await fs20.mkdir(path22.dirname(fullPath), { recursive: true });
+  const fullPath = path23.join(vaultPath2, notePath);
+  await fs21.mkdir(path23.dirname(fullPath), { recursive: true });
   const templates = config.templates || {};
-  const filename = path22.basename(notePath, ".md").toLowerCase();
+  const filename = path23.basename(notePath, ".md").toLowerCase();
   let templatePath;
   const dailyPattern = /^\d{4}-\d{2}-\d{2}/;
   const weeklyPattern = /^\d{4}-W\d{2}/;
@@ -15032,10 +15109,10 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   let templateContent;
   if (templatePath) {
     try {
-      const absTemplatePath = path22.join(vaultPath2, templatePath);
-      templateContent = await fs20.readFile(absTemplatePath, "utf-8");
+      const absTemplatePath = path23.join(vaultPath2, templatePath);
+      templateContent = await fs21.readFile(absTemplatePath, "utf-8");
     } catch {
-      const title = path22.basename(notePath, ".md");
+      const title = path23.basename(notePath, ".md");
       templateContent = `---
 ---
 
@@ -15044,7 +15121,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
       templatePath = void 0;
     }
   } else {
-    const title = path22.basename(notePath, ".md");
+    const title = path23.basename(notePath, ".md");
     templateContent = `---
 ---
 
@@ -15053,7 +15130,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   }
   const now = /* @__PURE__ */ new Date();
   const dateStr = now.toISOString().split("T")[0];
-  templateContent = templateContent.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, path22.basename(notePath, ".md"));
+  templateContent = templateContent.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, path23.basename(notePath, ".md"));
   const matter9 = (await import("gray-matter")).default;
   const parsed = matter9(templateContent);
   if (!parsed.data.date) {
@@ -15094,9 +15171,9 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
       let noteCreated = false;
       let templateUsed;
       if (create_if_missing && !dry_run) {
-        const fullPath = path22.join(vaultPath2, notePath);
+        const fullPath = path23.join(vaultPath2, notePath);
         try {
-          await fs20.access(fullPath);
+          await fs21.access(fullPath);
         } catch {
           const config = getConfig2();
           const result = await createNoteFromTemplate(vaultPath2, notePath, config);
@@ -15105,9 +15182,9 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
         }
       }
       if (create_if_missing && dry_run) {
-        const fullPath = path22.join(vaultPath2, notePath);
+        const fullPath = path23.join(vaultPath2, notePath);
         try {
-          await fs20.access(fullPath);
+          await fs21.access(fullPath);
         } catch {
           return {
             content: [{
@@ -15592,8 +15669,8 @@ Example: vault_update_frontmatter({ path: "projects/alpha.md", frontmatter: { st
 init_writer();
 init_wikilinks();
 import { z as z15 } from "zod";
-import fs21 from "fs/promises";
-import path23 from "path";
+import fs22 from "fs/promises";
+import path24 from "path";
 function registerNoteTools(server2, getVaultPath, getIndex) {
   server2.tool(
     "vault_create_note",
@@ -15619,23 +15696,23 @@ function registerNoteTools(server2, getVaultPath, getIndex) {
         if (!validatePath(vaultPath2, notePath)) {
           return formatMcpResult(errorResult(notePath, "Invalid path: path traversal not allowed"));
         }
-        const fullPath = path23.join(vaultPath2, notePath);
+        const fullPath = path24.join(vaultPath2, notePath);
         const existsCheck = await ensureFileExists(vaultPath2, notePath);
         if (existsCheck === null && !overwrite) {
           return formatMcpResult(errorResult(notePath, `File already exists: ${notePath}. Use overwrite=true to replace.`));
         }
-        const dir = path23.dirname(fullPath);
-        await fs21.mkdir(dir, { recursive: true });
+        const dir = path24.dirname(fullPath);
+        await fs22.mkdir(dir, { recursive: true });
         let effectiveContent = content;
         let effectiveFrontmatter = frontmatter;
         if (template) {
-          const templatePath = path23.join(vaultPath2, template);
+          const templatePath = path24.join(vaultPath2, template);
           try {
-            const raw = await fs21.readFile(templatePath, "utf-8");
+            const raw = await fs22.readFile(templatePath, "utf-8");
             const matter9 = (await import("gray-matter")).default;
             const parsed = matter9(raw);
             const dateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-            const title = path23.basename(notePath, ".md");
+            const title = path24.basename(notePath, ".md");
             let templateContent = parsed.content.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, title);
             if (content) {
               templateContent = templateContent.trimEnd() + "\n\n" + content;
@@ -15654,7 +15731,7 @@ function registerNoteTools(server2, getVaultPath, getIndex) {
           effectiveFrontmatter.created = now.toISOString();
         }
         const warnings = [];
-        const noteName = path23.basename(notePath, ".md");
+        const noteName = path24.basename(notePath, ".md");
         const existingAliases = Array.isArray(effectiveFrontmatter?.aliases) ? effectiveFrontmatter.aliases.filter((a) => typeof a === "string") : [];
         const preflight = await checkPreflightSimilarity(noteName);
         if (preflight.existingEntity) {
@@ -15795,8 +15872,8 @@ ${sources}`;
           }
           return formatMcpResult(errorResult(notePath, previewLines.join("\n")));
         }
-        const fullPath = path23.join(vaultPath2, notePath);
-        await fs21.unlink(fullPath);
+        const fullPath = path24.join(vaultPath2, notePath);
+        await fs22.unlink(fullPath);
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Flywheel:Delete]");
         const message = backlinkWarning ? `Deleted note: ${notePath}
 
@@ -15816,8 +15893,8 @@ init_writer();
 init_git();
 init_wikilinks();
 import { z as z16 } from "zod";
-import fs22 from "fs/promises";
-import path24 from "path";
+import fs23 from "fs/promises";
+import path25 from "path";
 import matter6 from "gray-matter";
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -15836,16 +15913,16 @@ function extractWikilinks2(content) {
   return wikilinks;
 }
 function getTitleFromPath(filePath) {
-  return path24.basename(filePath, ".md");
+  return path25.basename(filePath, ".md");
 }
 async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   const results = [];
   const allTargets = [targetTitle, ...targetAliases].map((t) => t.toLowerCase());
   async function scanDir(dir) {
     const files = [];
-    const entries = await fs22.readdir(dir, { withFileTypes: true });
+    const entries = await fs23.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path24.join(dir, entry.name);
+      const fullPath = path25.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         files.push(...await scanDir(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -15856,8 +15933,8 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   }
   const allFiles = await scanDir(vaultPath2);
   for (const filePath of allFiles) {
-    const relativePath = path24.relative(vaultPath2, filePath);
-    const content = await fs22.readFile(filePath, "utf-8");
+    const relativePath = path25.relative(vaultPath2, filePath);
+    const content = await fs23.readFile(filePath, "utf-8");
     const wikilinks = extractWikilinks2(content);
     const matchingLinks = [];
     for (const link of wikilinks) {
@@ -15943,10 +16020,10 @@ function registerMoveNoteTools(server2, getVaultPath) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const oldFullPath = path24.join(vaultPath2, oldPath);
-        const newFullPath = path24.join(vaultPath2, newPath);
+        const oldFullPath = path25.join(vaultPath2, oldPath);
+        const newFullPath = path25.join(vaultPath2, newPath);
         try {
-          await fs22.access(oldFullPath);
+          await fs23.access(oldFullPath);
         } catch {
           const result2 = {
             success: false,
@@ -15956,7 +16033,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
         try {
-          await fs22.access(newFullPath);
+          await fs23.access(newFullPath);
           const result2 = {
             success: false,
             message: `Destination already exists: ${newPath}`,
@@ -15965,7 +16042,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         } catch {
         }
-        const sourceContent = await fs22.readFile(oldFullPath, "utf-8");
+        const sourceContent = await fs23.readFile(oldFullPath, "utf-8");
         const parsed = matter6(sourceContent);
         const aliases = extractAliases2(parsed.data);
         const oldTitle = getTitleFromPath(oldPath);
@@ -16025,9 +16102,9 @@ function registerMoveNoteTools(server2, getVaultPath) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const destDir = path24.dirname(newFullPath);
-        await fs22.mkdir(destDir, { recursive: true });
-        await fs22.rename(oldFullPath, newFullPath);
+        const destDir = path25.dirname(newFullPath);
+        await fs23.mkdir(destDir, { recursive: true });
+        await fs23.rename(oldFullPath, newFullPath);
         let gitCommit;
         let undoAvailable;
         let staleLockDetected;
@@ -16101,12 +16178,12 @@ function registerMoveNoteTools(server2, getVaultPath) {
         if (sanitizedTitle !== newTitle) {
           console.error(`[Flywheel] Title sanitized: "${newTitle}" \u2192 "${sanitizedTitle}"`);
         }
-        const fullPath = path24.join(vaultPath2, notePath);
-        const dir = path24.dirname(notePath);
-        const newPath = dir === "." ? `${sanitizedTitle}.md` : path24.join(dir, `${sanitizedTitle}.md`);
-        const newFullPath = path24.join(vaultPath2, newPath);
+        const fullPath = path25.join(vaultPath2, notePath);
+        const dir = path25.dirname(notePath);
+        const newPath = dir === "." ? `${sanitizedTitle}.md` : path25.join(dir, `${sanitizedTitle}.md`);
+        const newFullPath = path25.join(vaultPath2, newPath);
         try {
-          await fs22.access(fullPath);
+          await fs23.access(fullPath);
         } catch {
           const result2 = {
             success: false,
@@ -16117,7 +16194,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
         }
         if (fullPath !== newFullPath) {
           try {
-            await fs22.access(newFullPath);
+            await fs23.access(newFullPath);
             const result2 = {
               success: false,
               message: `A note with this title already exists: ${newPath}`,
@@ -16127,7 +16204,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
           } catch {
           }
         }
-        const sourceContent = await fs22.readFile(fullPath, "utf-8");
+        const sourceContent = await fs23.readFile(fullPath, "utf-8");
         const parsed = matter6(sourceContent);
         const aliases = extractAliases2(parsed.data);
         const oldTitle = getTitleFromPath(notePath);
@@ -16187,7 +16264,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
         if (fullPath !== newFullPath) {
-          await fs22.rename(fullPath, newFullPath);
+          await fs23.rename(fullPath, newFullPath);
         }
         let gitCommit;
         let undoAvailable;
@@ -16235,7 +16312,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
 init_writer();
 init_wikilinks();
 import { z as z17 } from "zod";
-import fs23 from "fs/promises";
+import fs24 from "fs/promises";
 function registerMergeTools(server2, getVaultPath) {
   server2.tool(
     "merge_entities",
@@ -16362,7 +16439,7 @@ ${trimmedSource}`;
         }
         await writeVaultFile(vaultPath2, target_path, targetContent, targetFrontmatter, "LF", targetContentHash);
         const fullSourcePath = `${vaultPath2}/${source_path}`;
-        await fs23.unlink(fullSourcePath);
+        await fs24.unlink(fullSourcePath);
         initializeEntityIndex(vaultPath2).catch((err) => {
           console.error(`[Flywheel] Entity cache rebuild failed: ${err}`);
         });
@@ -16634,8 +16711,8 @@ init_schema();
 
 // src/core/write/policy/parser.ts
 init_schema();
-import fs24 from "fs/promises";
-import path25 from "path";
+import fs25 from "fs/promises";
+import path26 from "path";
 import matter7 from "gray-matter";
 function parseYaml(content) {
   const parsed = matter7(`---
@@ -16660,7 +16737,7 @@ function parsePolicyString(yamlContent) {
 }
 async function loadPolicyFile(filePath) {
   try {
-    const content = await fs24.readFile(filePath, "utf-8");
+    const content = await fs25.readFile(filePath, "utf-8");
     return parsePolicyString(content);
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -16684,15 +16761,15 @@ async function loadPolicyFile(filePath) {
   }
 }
 async function loadPolicy(vaultPath2, policyName) {
-  const policiesDir = path25.join(vaultPath2, ".claude", "policies");
-  const policyPath = path25.join(policiesDir, `${policyName}.yaml`);
+  const policiesDir = path26.join(vaultPath2, ".claude", "policies");
+  const policyPath = path26.join(policiesDir, `${policyName}.yaml`);
   try {
-    await fs24.access(policyPath);
+    await fs25.access(policyPath);
     return loadPolicyFile(policyPath);
   } catch {
-    const ymlPath = path25.join(policiesDir, `${policyName}.yml`);
+    const ymlPath = path26.join(policiesDir, `${policyName}.yml`);
     try {
-      await fs24.access(ymlPath);
+      await fs25.access(ymlPath);
       return loadPolicyFile(ymlPath);
     } catch {
       return {
@@ -16832,8 +16909,8 @@ init_schema();
 init_writer();
 init_git();
 init_wikilinks();
-import fs26 from "fs/promises";
-import path27 from "path";
+import fs27 from "fs/promises";
+import path28 from "path";
 init_constants();
 async function executeStep(step, vaultPath2, context, conditionResults, searchFn) {
   const { execute, reason } = shouldStepExecute(step.when, conditionResults);
@@ -17041,9 +17118,9 @@ 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 = path27.join(vaultPath2, notePath);
+  const fullPath = path28.join(vaultPath2, notePath);
   try {
-    await fs26.access(fullPath);
+    await fs27.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -17324,15 +17401,15 @@ async function rollbackChanges(vaultPath2, originalContents, filesModified) {
     const pathCheck = await validatePathSecure(vaultPath2, filePath);
     if (!pathCheck.valid) continue;
     const original = originalContents.get(filePath);
-    const fullPath = path27.join(vaultPath2, filePath);
+    const fullPath = path28.join(vaultPath2, filePath);
     if (original === null) {
       try {
-        await fs26.unlink(fullPath);
+        await fs27.unlink(fullPath);
       } catch {
       }
     } else if (original !== void 0) {
       try {
-        await fs26.writeFile(fullPath, original);
+        await fs27.writeFile(fullPath, original);
       } catch {
       }
     }
@@ -17378,33 +17455,33 @@ async function previewPolicy(policy, vaultPath2, variables) {
 }
 
 // src/core/write/policy/storage.ts
-import fs27 from "fs/promises";
-import path28 from "path";
+import fs28 from "fs/promises";
+import path29 from "path";
 function getPoliciesDir(vaultPath2) {
-  return path28.join(vaultPath2, ".claude", "policies");
+  return path29.join(vaultPath2, ".claude", "policies");
 }
 async function ensurePoliciesDir(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
-  await fs27.mkdir(dir, { recursive: true });
+  await fs28.mkdir(dir, { recursive: true });
 }
 async function listPolicies(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
   const policies = [];
   try {
-    const files = await fs27.readdir(dir);
+    const files = await fs28.readdir(dir);
     for (const file of files) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
         continue;
       }
-      const filePath = path28.join(dir, file);
-      const stat4 = await fs27.stat(filePath);
-      const content = await fs27.readFile(filePath, "utf-8");
+      const filePath = path29.join(dir, file);
+      const stat5 = await fs28.stat(filePath);
+      const content = await fs28.readFile(filePath, "utf-8");
       const metadata = extractPolicyMetadata(content);
       policies.push({
         name: metadata.name || file.replace(/\.ya?ml$/, ""),
         description: metadata.description || "No description",
         path: file,
-        lastModified: stat4.mtime,
+        lastModified: stat5.mtime,
         version: metadata.version || "1.0",
         requiredVariables: metadata.variables || []
       });
@@ -17421,10 +17498,10 @@ async function writePolicyRaw(vaultPath2, policyName, content, overwrite = false
   const dir = getPoliciesDir(vaultPath2);
   await ensurePoliciesDir(vaultPath2);
   const filename = `${policyName}.yaml`;
-  const filePath = path28.join(dir, filename);
+  const filePath = path29.join(dir, filename);
   if (!overwrite) {
     try {
-      await fs27.access(filePath);
+      await fs28.access(filePath);
       return {
         success: false,
         path: filename,
@@ -17441,7 +17518,7 @@ async function writePolicyRaw(vaultPath2, policyName, content, overwrite = false
       message: `Invalid policy: ${validation.errors.map((e) => e.message).join("; ")}`
     };
   }
-  await fs27.writeFile(filePath, content, "utf-8");
+  await fs28.writeFile(filePath, content, "utf-8");
   return {
     success: true,
     path: filename,
@@ -17966,8 +18043,8 @@ function registerPolicyTools(server2, getVaultPath, getSearchFn) {
 import { z as z21 } from "zod";
 
 // src/core/write/tagRename.ts
-import * as fs28 from "fs/promises";
-import * as path29 from "path";
+import * as fs29 from "fs/promises";
+import * as path30 from "path";
 import matter8 from "gray-matter";
 import { getProtectedZones } from "@velvetmonkey/vault-core";
 function getNotesInFolder3(index, folder) {
@@ -18073,10 +18150,10 @@ async function renameTag(index, vaultPath2, oldTag, newTag, options) {
   const previews = [];
   let totalChanges = 0;
   for (const note of affectedNotes) {
-    const fullPath = path29.join(vaultPath2, note.path);
+    const fullPath = path30.join(vaultPath2, note.path);
     let fileContent;
     try {
-      fileContent = await fs28.readFile(fullPath, "utf-8");
+      fileContent = await fs29.readFile(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -18149,7 +18226,7 @@ async function renameTag(index, vaultPath2, oldTag, newTag, options) {
       previews.push(preview);
       if (!dryRun) {
         const newContent = matter8.stringify(updatedContent, fm);
-        await fs28.writeFile(fullPath, newContent, "utf-8");
+        await fs29.writeFile(fullPath, newContent, "utf-8");
       }
     }
   }
@@ -19084,7 +19161,7 @@ function selectByMmr(candidates, limit, lambda = 0.7) {
 // src/core/read/snippets.ts
 init_embeddings();
 init_stemmer();
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 function stripFrontmatter(content) {
   const match = content.match(/^---[\s\S]*?---\n([\s\S]*)$/);
   return match ? match[1] : content;
@@ -19130,7 +19207,7 @@ async function extractBestSnippets(filePath, queryEmbedding, queryTokens, option
   const maxChunkChars = options?.maxChunkChars ?? 500;
   let content;
   try {
-    content = fs29.readFileSync(filePath, "utf-8");
+    content = fs30.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -19449,6 +19526,14 @@ function registerRecallTools(server2, getStateDb2, getVaultPath, getIndex) {
       const notes = results.filter((r) => r.type === "note");
       const memories = results.filter((r) => r.type === "memory");
       const index = getIndex?.() ?? null;
+      const enrichedNotes = notes.map((n) => ({
+        path: n.id,
+        snippet: n.content,
+        ...enrichNoteCompact(n.id, stateDb2, index)
+      }));
+      const hopResults = index ? multiHopBackfill(enrichedNotes, index, stateDb2, {
+        maxBackfill: Math.max(5, (args.max_results ?? 10) - notes.length)
+      }) : [];
       return {
         content: [{
           type: "text",
@@ -19458,20 +19543,12 @@ function registerRecallTools(server2, getStateDb2, getVaultPath, getIndex) {
             entities: entities.map((e) => ({
               name: e.id,
               description: e.content,
-              score: Math.round(e.score * 10) / 10,
-              breakdown: e.breakdown,
               ...enrichEntityCompact(e.id, stateDb2, index)
             })),
-            notes: notes.map((n) => ({
-              path: n.id,
-              snippet: n.content,
-              score: Math.round(n.score * 10) / 10,
-              ...enrichNoteCompact(n.id, stateDb2, index)
-            })),
+            notes: [...enrichedNotes, ...hopResults],
             memories: memories.map((m) => ({
               key: m.id,
-              value: m.content,
-              score: Math.round(m.score * 10) / 10
+              value: m.content
             }))
           }, null, 2)
         }]
@@ -19565,8 +19642,8 @@ function getNoteAccessFrequency(stateDb2, daysBack = 30) {
       }
     }
   }
-  return Array.from(noteMap.entries()).map(([path33, stats]) => ({
-    path: path33,
+  return Array.from(noteMap.entries()).map(([path34, stats]) => ({
+    path: path34,
     access_count: stats.access_count,
     last_accessed: stats.last_accessed,
     tools_used: Array.from(stats.tools)
@@ -19905,8 +19982,8 @@ function registerConfigTools(server2, getConfig2, setConfig, getStateDb2) {
 init_wikilinks();
 init_wikilinkFeedback();
 import { z as z28 } from "zod";
-import * as fs30 from "fs/promises";
-import * as path30 from "path";
+import * as fs31 from "fs/promises";
+import * as path31 from "path";
 import { scanVaultEntities as scanVaultEntities3, SCHEMA_VERSION as SCHEMA_VERSION2 } from "@velvetmonkey/vault-core";
 init_embeddings();
 function hasSkipWikilinks(content) {
@@ -19919,16 +19996,16 @@ function hasSkipWikilinks(content) {
 async function collectMarkdownFiles(dirPath, basePath, excludeFolders) {
   const results = [];
   try {
-    const entries = await fs30.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs31.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const fullPath = path30.join(dirPath, entry.name);
+      const fullPath = path31.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(path30.relative(basePath, fullPath));
+        results.push(path31.relative(basePath, fullPath));
       }
     }
   } catch {
@@ -19958,7 +20035,7 @@ var EXCLUDE_FOLDERS = [
 ];
 function buildStatusReport(stateDb2, vaultPath2) {
   const recommendations = [];
-  const dbPath = path30.join(vaultPath2, ".flywheel", "state.db");
+  const dbPath = path31.join(vaultPath2, ".flywheel", "state.db");
   const statedbExists = stateDb2 !== null;
   if (!statedbExists) {
     recommendations.push("StateDb not initialized \u2014 server needs restart");
@@ -20084,10 +20161,10 @@ async function executeRun(stateDb2, vaultPath2) {
       const allFiles = await collectMarkdownFiles(vaultPath2, vaultPath2, EXCLUDE_FOLDERS);
       let eligible = 0;
       for (const relativePath of allFiles) {
-        const fullPath = path30.join(vaultPath2, relativePath);
+        const fullPath = path31.join(vaultPath2, relativePath);
         let content;
         try {
-          content = await fs30.readFile(fullPath, "utf-8");
+          content = await fs31.readFile(fullPath, "utf-8");
         } catch {
           continue;
         }
@@ -20142,10 +20219,10 @@ async function executeEnrich(stateDb2, vaultPath2, dryRun, batchSize, offset) {
   const eligible = [];
   let notesSkipped = 0;
   for (const relativePath of allFiles) {
-    const fullPath = path30.join(vaultPath2, relativePath);
+    const fullPath = path31.join(vaultPath2, relativePath);
     let content;
     try {
-      content = await fs30.readFile(fullPath, "utf-8");
+      content = await fs31.readFile(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -20172,8 +20249,8 @@ async function executeEnrich(stateDb2, vaultPath2, dryRun, batchSize, offset) {
       match_count: result.linksAdded
     });
     if (!dryRun) {
-      const fullPath = path30.join(vaultPath2, relativePath);
-      await fs30.writeFile(fullPath, result.content, "utf-8");
+      const fullPath = path31.join(vaultPath2, relativePath);
+      await fs31.writeFile(fullPath, result.content, "utf-8");
       notesModified++;
       if (stateDb2) {
         trackWikilinkApplications(stateDb2, relativePath, entities);
@@ -20563,8 +20640,8 @@ import { z as z31 } from "zod";
 
 // src/core/read/similarity.ts
 init_embeddings();
-import * as fs31 from "fs";
-import * as path31 from "path";
+import * as fs32 from "fs";
+import * as path32 from "path";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
   "be",
@@ -20701,10 +20778,10 @@ function extractKeyTerms(content, maxTerms = 15) {
 }
 function findSimilarNotes(db4, vaultPath2, index, sourcePath, options = {}) {
   const limit = options.limit ?? 10;
-  const absPath = path31.join(vaultPath2, sourcePath);
+  const absPath = path32.join(vaultPath2, sourcePath);
   let content;
   try {
-    content = fs31.readFileSync(absPath, "utf-8");
+    content = fs32.readFileSync(absPath, "utf-8");
   } catch {
     return [];
   }
@@ -20843,7 +20920,7 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb2) {
         diversity: z31.number().min(0).max(1).optional().describe("Relevance vs diversity tradeoff (0=max diversity, 1=pure relevance, default: 0.7)")
       }
     },
-    async ({ path: path33, limit, diversity }) => {
+    async ({ path: path34, limit, diversity }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const stateDb2 = getStateDb2();
@@ -20852,10 +20929,10 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb2) {
           content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
         };
       }
-      if (!index.notes.has(path33)) {
+      if (!index.notes.has(path34)) {
         return {
           content: [{ type: "text", text: JSON.stringify({
-            error: `Note not found: ${path33}`,
+            error: `Note not found: ${path34}`,
             hint: "Use the full relative path including .md extension"
           }, null, 2) }]
         };
@@ -20867,12 +20944,12 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb2) {
       };
       const useHybrid = hasEmbeddingsIndex();
       const method = useHybrid ? "hybrid" : "bm25";
-      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path33, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path33, opts);
+      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path34, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path34, opts);
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
-            source: path33,
+            source: path34,
             method,
             count: results.length,
             similar: results
@@ -21747,7 +21824,7 @@ init_cooccurrence();
 init_retrievalCooccurrence();
 init_corrections();
 init_edgeWeights();
-import * as fs32 from "node:fs/promises";
+import * as fs33 from "node:fs/promises";
 import { createHash as createHash3 } from "node:crypto";
 
 // src/resources/vault.ts
@@ -22293,7 +22370,7 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
               let totalBytes = 0;
               for (const p of notePaths) {
                 try {
-                  totalBytes += statSync5(path32.join(vp, p)).size;
+                  totalBytes += statSync5(path33.join(vp, p)).size;
                 } catch {
                 }
               }
@@ -22792,22 +22869,22 @@ async function buildStartupCatchupBatch(vaultPath2, sinceMs) {
   async function scanDir(dir) {
     let entries;
     try {
-      entries = await fs32.readdir(dir, { withFileTypes: true });
+      entries = await fs33.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path32.join(dir, entry.name);
+      const fullPath = path33.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
         await scanDir(fullPath);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
         try {
-          const stat4 = await fs32.stat(fullPath);
-          if (stat4.mtimeMs > sinceMs) {
+          const stat5 = await fs33.stat(fullPath);
+          if (stat5.mtimeMs > sinceMs) {
             events.push({
               type: "upsert",
-              path: path32.relative(vaultPath2, fullPath),
+              path: path33.relative(vaultPath2, fullPath),
               originalEvents: []
             });
           }
@@ -22997,8 +23074,8 @@ async function runPostIndexWork(index) {
           }
         } catch {
           try {
-            const dir = path32.dirname(rawPath);
-            const base = path32.basename(rawPath);
+            const dir = path33.dirname(rawPath);
+            const base = path33.basename(rawPath);
             const resolvedDir = realpathSync(dir).replace(/\\/g, "/");
             for (const prefix of vaultPrefixes) {
               if (resolvedDir.startsWith(prefix + "/") || resolvedDir === prefix) {
@@ -23030,7 +23107,7 @@ async function runPostIndexWork(index) {
           continue;
         }
         try {
-          const content = await fs32.readFile(path32.join(vaultPath, event.path), "utf-8");
+          const content = await fs33.readFile(path33.join(vaultPath, event.path), "utf-8");
           const hash = createHash3("sha256").update(content).digest("hex").slice(0, 16);
           if (lastContentHashes.get(event.path) === hash) {
             serverLog("watcher", `Hash unchanged, skipping: ${event.path}`);
@@ -23111,7 +23188,7 @@ async function runPostIndexWork(index) {
             ...batch,
             events: filteredEvents.map((e) => ({
               ...e,
-              path: path32.join(vaultPath, e.path)
+              path: path33.join(vaultPath, e.path)
             }))
           };
           const batchResult = await processBatch(vaultIndex, vaultPath, absoluteBatch);
@@ -23262,7 +23339,7 @@ async function runPostIndexWork(index) {
                 removeEmbedding(event.path);
                 embRemoved++;
               } else if (event.path.endsWith(".md")) {
-                const absPath = path32.join(vaultPath, event.path);
+                const absPath = path33.join(vaultPath, event.path);
                 await updateEmbedding(event.path, absPath);
                 embUpdated++;
               }
@@ -23482,7 +23559,7 @@ async function runPostIndexWork(index) {
         for (const event of filteredEvents) {
           if (event.type === "delete" || !event.path.endsWith(".md")) continue;
           try {
-            const content = await fs32.readFile(path32.join(vaultPath, event.path), "utf-8");
+            const content = await fs33.readFile(path33.join(vaultPath, event.path), "utf-8");
             const zones = getProtectedZones2(content);
             const linked = new Set(
               (forwardLinkResults.find((r) => r.file === event.path)?.resolved ?? []).map((n) => n.toLowerCase())
@@ -23523,7 +23600,7 @@ async function runPostIndexWork(index) {
           for (const event of filteredEvents) {
             if (event.type === "delete" || !event.path.endsWith(".md")) continue;
             try {
-              const content = await fs32.readFile(path32.join(vaultPath, event.path), "utf-8");
+              const content = await fs33.readFile(path33.join(vaultPath, event.path), "utf-8");
               const removed = processImplicitFeedback(stateDb, event.path, content);
               for (const entity of removed) feedbackResults.push({ entity, file: event.path });
             } catch {
@@ -23603,7 +23680,7 @@ async function runPostIndexWork(index) {
         for (const event of filteredEvents) {
           if (event.type === "delete" || !event.path.endsWith(".md")) continue;
           try {
-            const content = await fs32.readFile(path32.join(vaultPath, event.path), "utf-8");
+            const content = await fs33.readFile(path33.join(vaultPath, event.path), "utf-8");
             const zones = getProtectedZones2(content);
             const linkedSet = new Set(
               (forwardLinkResults.find((r) => r.file === event.path)?.resolved ?? []).concat(forwardLinkResults.find((r) => r.file === event.path)?.dead ?? []).map((n) => n.toLowerCase())
@@ -23636,7 +23713,7 @@ async function runPostIndexWork(index) {
         for (const event of filteredEvents) {
           if (event.type === "delete" || !event.path.endsWith(".md")) continue;
           try {
-            const content = await fs32.readFile(path32.join(vaultPath, event.path), "utf-8");
+            const content = await fs33.readFile(path33.join(vaultPath, event.path), "utf-8");
             const result = await suggestRelatedLinks(content, {
               maxSuggestions: 5,
               strictness: "balanced",
@@ -23660,6 +23737,33 @@ async function runPostIndexWork(index) {
         if (suggestionResults.length > 0) {
           serverLog("watcher", `Suggestion scoring: ${suggestionResults.length} files scored`);
         }
+        if (flywheelConfig?.proactive_linking !== false && suggestionResults.length > 0) {
+          tracker.start("proactive_linking", { files: suggestionResults.length });
+          try {
+            const proactiveResults = [];
+            for (const { file, top } of suggestionResults) {
+              if (getNoteContext(file) === "daily") continue;
+              try {
+                const result = await applyProactiveSuggestions(file, vaultPath, top, {
+                  minScore: flywheelConfig?.proactive_min_score ?? 20,
+                  maxPerFile: flywheelConfig?.proactive_max_per_file ?? 3
+                });
+                if (result.applied.length > 0) {
+                  proactiveResults.push({ file, applied: result.applied });
+                }
+              } catch {
+              }
+            }
+            const totalApplied = proactiveResults.reduce((s, r) => s + r.applied.length, 0);
+            tracker.end({ files_modified: proactiveResults.length, total_applied: totalApplied, results: proactiveResults });
+            if (totalApplied > 0) {
+              serverLog("watcher", `Proactive linking: ${totalApplied} links in ${proactiveResults.length} files`);
+            }
+          } catch (e) {
+            tracker.end({ error: String(e) });
+            serverLog("watcher", `Proactive linking failed: ${e}`, "error");
+          }
+        }
         tracker.start("tag_scan", { files: filteredEvents.length });
         try {
           const tagDiffs = [];