npm - @velvetmonkey/flywheel-memory - Versions diffs - 2.0.125 → 2.0.127 - Mend

@velvetmonkey/flywheel-memory 2.0.125 → 2.0.127

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +432 -329
package/package.json +2 -2

package/dist/index.js CHANGED Viewed

@@ -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 {
             }
@@ -10969,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);
@@ -10985,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();
@@ -11065,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 {
@@ -11449,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";
@@ -11763,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];
@@ -12023,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");
@@ -12078,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;
   }
@@ -12101,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;
   }
@@ -12143,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;
     }
@@ -12178,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;
@@ -12234,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) }]
         };
@@ -12296,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;
@@ -12315,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,
@@ -12470,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 = [];
@@ -12484,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;
@@ -12672,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
@@ -13386,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 {
@@ -14016,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;
   }
@@ -14200,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
@@ -14344,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(
@@ -14404,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({
@@ -14483,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}\*\*/;
@@ -14702,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);
@@ -14751,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(", ");
@@ -14763,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);
@@ -14941,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;
@@ -14985,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) {
@@ -15009,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}/;
@@ -15033,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 = `---
 ---
@@ -15045,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 = `---
 ---
@@ -15054,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) {
@@ -15095,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);
@@ -15106,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: [{
@@ -15593,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",
@@ -15620,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;
@@ -15655,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) {
@@ -15796,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}
@@ -15817,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, "\\$&");
@@ -15837,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")) {
@@ -15857,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) {
@@ -15944,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,
@@ -15957,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}`,
@@ -15966,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);
@@ -16026,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;
@@ -16102,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,
@@ -16118,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}`,
@@ -16128,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);
@@ -16188,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;
@@ -16236,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",
@@ -16363,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}`);
         });
@@ -16635,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(`---
@@ -16661,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") {
@@ -16685,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 {
@@ -16833,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);
@@ -17042,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 };
   }
@@ -17325,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 {
       }
     }
@@ -17379,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 || []
       });
@@ -17422,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,
@@ -17442,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,
@@ -17967,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) {
@@ -18074,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;
     }
@@ -18150,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");
       }
     }
   }
@@ -19085,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;
@@ -19131,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 [];
   }
@@ -19450,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",
@@ -19459,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)
         }]
@@ -19566,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)
@@ -19906,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) {
@@ -19920,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 {
@@ -19959,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");
@@ -20085,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;
         }
@@ -20143,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;
     }
@@ -20173,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);
@@ -20564,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",
@@ -20702,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 [];
   }
@@ -20844,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();
@@ -20853,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) }]
         };
@@ -20868,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
@@ -21748,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
@@ -22294,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 {
                 }
               }
@@ -22793,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: []
             });
           }
@@ -22998,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) {
@@ -23031,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}`);
@@ -23112,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);
@@ -23263,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++;
               }
@@ -23483,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())
@@ -23524,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 {
@@ -23604,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())
@@ -23637,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",
@@ -23661,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 = [];