@velvetmonkey/flywheel-memory 2.0.34 → 2.0.36

package/dist/index.js

@@ -59,7 +59,7 @@ var init_constants = __esm({
 
 // src/core/write/writer.ts
 import fs18 from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 import matter5 from "gray-matter";
 function isSensitivePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
@@ -386,8 +386,8 @@ function validatePath(vaultPath2, notePath) {
   if (notePath.startsWith("\\")) {
     return false;
   }
-  const resolvedVault = path18.resolve(vaultPath2);
-  const resolvedNote = path18.resolve(vaultPath2, notePath);
+  const resolvedVault = path19.resolve(vaultPath2);
+  const resolvedNote = path19.resolve(vaultPath2, notePath);
   return resolvedNote.startsWith(resolvedVault);
 }
 async function validatePathSecure(vaultPath2, notePath) {
@@ -415,8 +415,8 @@ async function validatePathSecure(vaultPath2, notePath) {
       reason: "Path traversal not allowed"
     };
   }
-  const resolvedVault = path18.resolve(vaultPath2);
-  const resolvedNote = path18.resolve(vaultPath2, notePath);
+  const resolvedVault = path19.resolve(vaultPath2);
+  const resolvedNote = path19.resolve(vaultPath2, notePath);
   if (!resolvedNote.startsWith(resolvedVault)) {
     return {
       valid: false,
@@ -430,7 +430,7 @@ async function validatePathSecure(vaultPath2, notePath) {
     };
   }
   try {
-    const fullPath = path18.join(vaultPath2, notePath);
+    const fullPath = path19.join(vaultPath2, notePath);
     try {
       await fs18.access(fullPath);
       const realPath = await fs18.realpath(fullPath);
@@ -441,7 +441,7 @@ async function validatePathSecure(vaultPath2, notePath) {
           reason: "Symlink target is outside vault"
         };
       }
-      const relativePath = path18.relative(realVaultPath, realPath);
+      const relativePath = path19.relative(realVaultPath, realPath);
       if (isSensitivePath(relativePath)) {
         return {
           valid: false,
@@ -449,7 +449,7 @@ async function validatePathSecure(vaultPath2, notePath) {
         };
       }
     } catch {
-      const parentDir = path18.dirname(fullPath);
+      const parentDir = path19.dirname(fullPath);
       try {
         await fs18.access(parentDir);
         const realParentPath = await fs18.realpath(parentDir);
@@ -475,7 +475,7 @@ async function readVaultFile(vaultPath2, notePath) {
   if (!validatePath(vaultPath2, notePath)) {
     throw new Error("Invalid path: path traversal not allowed");
   }
-  const fullPath = path18.join(vaultPath2, notePath);
+  const fullPath = path19.join(vaultPath2, notePath);
   const [rawContent, stat3] = await Promise.all([
     fs18.readFile(fullPath, "utf-8"),
     fs18.stat(fullPath)
@@ -528,7 +528,7 @@ async function writeVaultFile(vaultPath2, notePath, content, frontmatter, lineEn
   if (!validation.valid) {
     throw new Error(`Invalid path: ${validation.reason}`);
   }
-  const fullPath = path18.join(vaultPath2, notePath);
+  const fullPath = path19.join(vaultPath2, notePath);
   let output = matter5.stringify(content, frontmatter);
   output = normalizeTrailingNewline(output);
   output = convertLineEndings(output, lineEnding);
@@ -832,11 +832,12 @@ function createContext(variables = {}) {
       today: formatDate2(now),
       time: formatTime(now),
       date: formatDate2(now)
-    }
+    },
+    steps: {}
   };
 }
-function resolvePath(obj, path30) {
-  const parts = path30.split(".");
+function resolvePath(obj, path31) {
+  const parts = path31.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === void 0 || current === null) {
@@ -878,6 +879,9 @@ function resolveExpression(expr, context) {
   if (trimmed.startsWith("builtins.")) {
     return resolvePath(context.builtins, trimmed.slice("builtins.".length));
   }
+  if (trimmed.startsWith("steps.")) {
+    return resolvePath(context.steps, trimmed.slice("steps.".length));
+  }
   return resolvePath(context.variables, trimmed);
 }
 function interpolate(template, context) {
@@ -1056,7 +1060,7 @@ function validatePolicySchema(policy) {
         const match = ref.match(/\{\{(?:variables\.)?(\w+)/);
         if (match) {
           const varName = match[1];
-          if (["now", "today", "time", "date", "conditions"].includes(varName)) {
+          if (["now", "today", "time", "date", "conditions", "steps"].includes(varName)) {
             continue;
           }
           if (!varNames.has(varName)) {
@@ -1275,7 +1279,7 @@ __export(conditions_exports, {
   shouldStepExecute: () => shouldStepExecute
 });
 import fs25 from "fs/promises";
-import path24 from "path";
+import path25 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;
@@ -1328,7 +1332,7 @@ async function evaluateCondition(condition, vaultPath2, context) {
   }
 }
 async function evaluateFileExists(vaultPath2, notePath, expectExists) {
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
     await fs25.access(fullPath);
     return {
@@ -1343,7 +1347,7 @@ async function evaluateFileExists(vaultPath2, notePath, expectExists) {
   }
 }
 async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectExists) {
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
     await fs25.access(fullPath);
   } catch {
@@ -1374,7 +1378,7 @@ async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectEx
   }
 }
 async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expectExists) {
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
     await fs25.access(fullPath);
   } catch {
@@ -1405,7 +1409,7 @@ async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expect
   }
 }
 async function evaluateFrontmatterEquals(vaultPath2, notePath, fieldName, expectedValue) {
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
     await fs25.access(fullPath);
   } catch {
@@ -1548,7 +1552,10 @@ var init_taskHelpers = __esm({
 });
 
 // src/index.ts
-import * as path29 from "path";
+import * as path30 from "path";
+import { readFileSync as readFileSync4, realpathSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname4, join as join16 } from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -2209,8 +2216,8 @@ function updateIndexProgress(parsed, total) {
 function normalizeTarget(target) {
   return target.toLowerCase().replace(/\.md$/, "");
 }
-function normalizeNotePath(path30) {
-  return path30.toLowerCase().replace(/\.md$/, "");
+function normalizeNotePath(path31) {
+  return path31.toLowerCase().replace(/\.md$/, "");
 }
 async function buildVaultIndex(vaultPath2, options = {}) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
@@ -2260,7 +2267,10 @@ async function buildVaultIndexInternal(vaultPath2, startTime, onProgress) {
     }
   }
   if (parseErrors.length > 0) {
-    console.error(`Failed to parse ${parseErrors.length} files`);
+    console.error(`Failed to parse ${parseErrors.length} files:`);
+    for (const errorPath of parseErrors) {
+      console.error(`  - ${errorPath}`);
+    }
   }
   const entities = /* @__PURE__ */ new Map();
   for (const note of notes.values()) {
@@ -2376,7 +2386,7 @@ function findSimilarEntity(index, target) {
   }
   const maxDist = normalizedLen <= 10 ? 1 : 2;
   let bestMatch;
-  for (const [entity, path30] of index.entities) {
+  for (const [entity, path31] of index.entities) {
     const lenDiff = Math.abs(entity.length - normalizedLen);
     if (lenDiff > maxDist) {
       continue;
@@ -2384,7 +2394,7 @@ function findSimilarEntity(index, target) {
     const dist = levenshteinDistance(normalized, entity);
     if (dist > 0 && dist <= maxDist) {
       if (!bestMatch || dist < bestMatch.distance) {
-        bestMatch = { path: path30, entity, distance: dist };
+        bestMatch = { path: path31, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -2854,30 +2864,30 @@ var EventQueue = class {
    * Add a new event to the queue
    */
   push(type, rawPath) {
-    const path30 = normalizePath(rawPath);
+    const path31 = normalizePath(rawPath);
     const now = Date.now();
     const event = {
       type,
-      path: path30,
+      path: path31,
       timestamp: now
     };
-    let pending = this.pending.get(path30);
+    let pending = this.pending.get(path31);
     if (!pending) {
       pending = {
         events: [],
         timer: null,
         lastEvent: now
       };
-      this.pending.set(path30, pending);
+      this.pending.set(path31, pending);
     }
     pending.events.push(event);
     pending.lastEvent = now;
-    console.error(`[flywheel] QUEUE: pushed ${type} for ${path30}, pending=${this.pending.size}`);
+    console.error(`[flywheel] QUEUE: pushed ${type} for ${path31}, pending=${this.pending.size}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
     }
     pending.timer = setTimeout(() => {
-      this.flushPath(path30);
+      this.flushPath(path31);
     }, this.config.debounceMs);
     if (this.pending.size >= this.config.batchSize) {
       this.flush();
@@ -2898,10 +2908,10 @@ var EventQueue = class {
   /**
    * Flush a single path's events
    */
-  flushPath(path30) {
-    const pending = this.pending.get(path30);
+  flushPath(path31) {
+    const pending = this.pending.get(path31);
     if (!pending || pending.events.length === 0) return;
-    console.error(`[flywheel] QUEUE: flushing ${path30}, events=${pending.events.length}`);
+    console.error(`[flywheel] QUEUE: flushing ${path31}, events=${pending.events.length}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -2910,7 +2920,7 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path30,
+        path: path31,
         originalEvents: [...pending.events]
       };
       this.onBatch({
@@ -2918,7 +2928,7 @@ var EventQueue = class {
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path30);
+    this.pending.delete(path31);
   }
   /**
    * Flush all pending events
@@ -2930,7 +2940,7 @@ var EventQueue = class {
     }
     if (this.pending.size === 0) return;
     const events = [];
-    for (const [path30, pending] of this.pending) {
+    for (const [path31, pending] of this.pending) {
       if (pending.timer) {
         clearTimeout(pending.timer);
       }
@@ -2938,7 +2948,7 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path30,
+          path: path31,
           originalEvents: [...pending.events]
         });
       }
@@ -3013,6 +3023,208 @@ function parseWatcherConfig() {
   };
 }
 
+// src/core/read/watch/incrementalIndex.ts
+import path6 from "path";
+function normalizeTarget2(target) {
+  return target.toLowerCase().replace(/\.md$/, "");
+}
+function normalizeNotePath2(notePath) {
+  return notePath.toLowerCase().replace(/\.md$/, "");
+}
+function removeNoteFromIndex(index, notePath) {
+  const note = index.notes.get(notePath);
+  if (!note) {
+    return false;
+  }
+  index.notes.delete(notePath);
+  const normalizedTitle = normalizeTarget2(note.title);
+  const normalizedPath = normalizeNotePath2(notePath);
+  if (index.entities.get(normalizedTitle) === notePath) {
+    index.entities.delete(normalizedTitle);
+  }
+  if (index.entities.get(normalizedPath) === notePath) {
+    index.entities.delete(normalizedPath);
+  }
+  for (const alias of note.aliases) {
+    const normalizedAlias = normalizeTarget2(alias);
+    if (index.entities.get(normalizedAlias) === notePath) {
+      index.entities.delete(normalizedAlias);
+    }
+  }
+  for (const tag of note.tags) {
+    const tagPaths = index.tags.get(tag);
+    if (tagPaths) {
+      tagPaths.delete(notePath);
+      if (tagPaths.size === 0) {
+        index.tags.delete(tag);
+      }
+    }
+  }
+  for (const link of note.outlinks) {
+    const normalizedTarget = normalizeTarget2(link.target);
+    const targetPath = index.entities.get(normalizedTarget);
+    const key = targetPath ? normalizeNotePath2(targetPath) : normalizedTarget;
+    const backlinks = index.backlinks.get(key);
+    if (backlinks) {
+      const filtered = backlinks.filter((bl) => bl.source !== notePath);
+      if (filtered.length === 0) {
+        index.backlinks.delete(key);
+      } else {
+        index.backlinks.set(key, filtered);
+      }
+    }
+  }
+  return true;
+}
+function addNoteToIndex(index, note) {
+  index.notes.set(note.path, note);
+  const normalizedTitle = normalizeTarget2(note.title);
+  const normalizedPath = normalizeNotePath2(note.path);
+  if (!index.entities.has(normalizedTitle)) {
+    index.entities.set(normalizedTitle, note.path);
+  }
+  index.entities.set(normalizedPath, note.path);
+  for (const alias of note.aliases) {
+    const normalizedAlias = normalizeTarget2(alias);
+    if (!index.entities.has(normalizedAlias)) {
+      index.entities.set(normalizedAlias, note.path);
+    }
+  }
+  for (const tag of note.tags) {
+    if (!index.tags.has(tag)) {
+      index.tags.set(tag, /* @__PURE__ */ new Set());
+    }
+    index.tags.get(tag).add(note.path);
+  }
+  for (const link of note.outlinks) {
+    const normalizedTarget = normalizeTarget2(link.target);
+    const targetPath = index.entities.get(normalizedTarget);
+    const key = targetPath ? normalizeNotePath2(targetPath) : normalizedTarget;
+    if (!index.backlinks.has(key)) {
+      index.backlinks.set(key, []);
+    }
+    index.backlinks.get(key).push({
+      source: note.path,
+      line: link.line
+    });
+  }
+}
+async function upsertNote(index, vaultPath2, notePath) {
+  try {
+    const existed = index.notes.has(notePath);
+    if (existed) {
+      removeNoteFromIndex(index, notePath);
+    }
+    const fullPath = path6.join(vaultPath2, notePath);
+    const fs31 = await import("fs/promises");
+    const stats = await fs31.stat(fullPath);
+    const vaultFile = {
+      path: notePath,
+      absolutePath: fullPath,
+      modified: stats.mtime
+    };
+    const note = await parseNote(vaultFile);
+    addNoteToIndex(index, note);
+    return {
+      success: true,
+      action: existed ? "updated" : "added",
+      path: notePath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      action: "unchanged",
+      path: notePath,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+function deleteNote(index, notePath) {
+  const removed = removeNoteFromIndex(index, notePath);
+  return {
+    success: removed,
+    action: removed ? "removed" : "unchanged",
+    path: notePath
+  };
+}
+
+// src/core/read/watch/batchProcessor.ts
+var DEFAULT_CONCURRENCY = 4;
+var YIELD_INTERVAL = 10;
+async function processBatch(index, vaultPath2, batch, options = {}) {
+  const { concurrency = DEFAULT_CONCURRENCY, onProgress, onError } = options;
+  const startTime = Date.now();
+  const results = [];
+  let successful = 0;
+  let failed = 0;
+  let processed = 0;
+  const events = batch.events;
+  const total = events.length;
+  if (total === 0) {
+    return {
+      total: 0,
+      successful: 0,
+      failed: 0,
+      results: [],
+      durationMs: 0
+    };
+  }
+  console.error(`[flywheel] Processing ${total} file events`);
+  for (let i = 0; i < events.length; i += concurrency) {
+    const chunk = events.slice(i, i + concurrency);
+    const chunkResults = await Promise.allSettled(
+      chunk.map(async (event) => {
+        const relativePath = getRelativePath(vaultPath2, event.path);
+        if (event.type === "delete") {
+          return deleteNote(index, relativePath);
+        } else {
+          return upsertNote(index, vaultPath2, relativePath);
+        }
+      })
+    );
+    for (let j = 0; j < chunkResults.length; j++) {
+      const result = chunkResults[j];
+      processed++;
+      if (result.status === "fulfilled") {
+        results.push(result.value);
+        if (result.value.success) {
+          successful++;
+        } else {
+          failed++;
+          if (result.value.error && onError) {
+            onError(result.value.path, result.value.error);
+          }
+        }
+      } else {
+        failed++;
+        const event = chunk[j];
+        const relativePath = getRelativePath(vaultPath2, event.path);
+        const error = result.reason instanceof Error ? result.reason : new Error(String(result.reason));
+        results.push({
+          success: false,
+          action: "unchanged",
+          path: relativePath,
+          error
+        });
+        onError?.(relativePath, error);
+      }
+    }
+    onProgress?.(processed, total);
+    if (processed % YIELD_INTERVAL === 0 && processed < total) {
+      await new Promise((resolve2) => setImmediate(resolve2));
+    }
+  }
+  const durationMs = Date.now() - startTime;
+  console.error(`[flywheel] Processed ${successful}/${total} files in ${durationMs}ms`);
+  return {
+    total,
+    successful,
+    failed,
+    results,
+    durationMs
+  };
+}
+
 // src/core/read/watch/index.ts
 function createVaultWatcher(options) {
   const { vaultPath: vaultPath2, onBatch, onStateChange, onError } = options;
@@ -3087,31 +3299,31 @@ function createVaultWatcher(options) {
         usePolling: config.usePolling,
         interval: config.usePolling ? config.pollInterval : void 0
       });
-      watcher.on("add", (path30) => {
-        console.error(`[flywheel] RAW EVENT: add ${path30}`);
-        if (shouldWatch(path30, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: add ${path30}`);
-          eventQueue.push("add", path30);
+      watcher.on("add", (path31) => {
+        console.error(`[flywheel] RAW EVENT: add ${path31}`);
+        if (shouldWatch(path31, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: add ${path31}`);
+          eventQueue.push("add", path31);
         } else {
-          console.error(`[flywheel] FILTERED: add ${path30}`);
+          console.error(`[flywheel] FILTERED: add ${path31}`);
         }
       });
-      watcher.on("change", (path30) => {
-        console.error(`[flywheel] RAW EVENT: change ${path30}`);
-        if (shouldWatch(path30, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: change ${path30}`);
-          eventQueue.push("change", path30);
+      watcher.on("change", (path31) => {
+        console.error(`[flywheel] RAW EVENT: change ${path31}`);
+        if (shouldWatch(path31, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: change ${path31}`);
+          eventQueue.push("change", path31);
         } else {
-          console.error(`[flywheel] FILTERED: change ${path30}`);
+          console.error(`[flywheel] FILTERED: change ${path31}`);
         }
       });
-      watcher.on("unlink", (path30) => {
-        console.error(`[flywheel] RAW EVENT: unlink ${path30}`);
-        if (shouldWatch(path30, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: unlink ${path30}`);
-          eventQueue.push("unlink", path30);
+      watcher.on("unlink", (path31) => {
+        console.error(`[flywheel] RAW EVENT: unlink ${path31}`);
+        if (shouldWatch(path31, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: unlink ${path31}`);
+          eventQueue.push("unlink", path31);
         } else {
-          console.error(`[flywheel] FILTERED: unlink ${path30}`);
+          console.error(`[flywheel] FILTERED: unlink ${path31}`);
         }
       });
       watcher.on("ready", () => {
@@ -3241,9 +3453,14 @@ var FEEDBACK_BOOST_TIERS = [
   { minAccuracy: 0, minSamples: 5, boost: -4 }
 ];
 function recordFeedback(stateDb2, entity, context, notePath, correct) {
-  stateDb2.db.prepare(
-    "INSERT INTO wikilink_feedback (entity, context, note_path, correct) VALUES (?, ?, ?, ?)"
-  ).run(entity, context, notePath, correct ? 1 : 0);
+  try {
+    stateDb2.db.prepare(
+      "INSERT INTO wikilink_feedback (entity, context, note_path, correct) VALUES (?, ?, ?, ?)"
+    ).run(entity, context, notePath, correct ? 1 : 0);
+  } catch (e) {
+    console.error(`[Flywheel] recordFeedback failed for entity="${entity}": ${e}`);
+    throw e;
+  }
 }
 function getFeedback(stateDb2, entity, limit = 20) {
   let rows;
@@ -3554,10 +3771,163 @@ function getDashboardData(stateDb2) {
     }))
   };
 }
+function getEntityScoreTimeline(stateDb2, entityName, daysBack = 30, limit = 100) {
+  const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
+  const rows = stateDb2.db.prepare(`
+    SELECT timestamp, total_score, breakdown_json, note_path, passed, threshold
+    FROM suggestion_events
+    WHERE entity = ? AND timestamp >= ?
+    ORDER BY timestamp ASC
+    LIMIT ?
+  `).all(entityName, cutoff, limit);
+  return rows.map((r) => ({
+    timestamp: r.timestamp,
+    score: r.total_score,
+    breakdown: JSON.parse(r.breakdown_json),
+    notePath: r.note_path,
+    passed: r.passed === 1,
+    threshold: r.threshold
+  }));
+}
+function getLayerContributionTimeseries(stateDb2, granularity = "day", daysBack = 30) {
+  const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
+  const rows = stateDb2.db.prepare(`
+    SELECT timestamp, breakdown_json
+    FROM suggestion_events
+    WHERE timestamp >= ?
+    ORDER BY timestamp ASC
+  `).all(cutoff);
+  const buckets = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const date = new Date(row.timestamp);
+    let bucket;
+    if (granularity === "week") {
+      const jan4 = new Date(date.getFullYear(), 0, 4);
+      const weekNum = Math.ceil(((date.getTime() - jan4.getTime()) / 864e5 + jan4.getDay() + 1) / 7);
+      bucket = `${date.getFullYear()}-W${String(weekNum).padStart(2, "0")}`;
+    } else {
+      bucket = date.toISOString().slice(0, 10);
+    }
+    if (!buckets.has(bucket)) {
+      buckets.set(bucket, { count: 0, layers: {} });
+    }
+    const acc = buckets.get(bucket);
+    acc.count++;
+    const breakdown = JSON.parse(row.breakdown_json);
+    const layerMap = {
+      contentMatch: breakdown.contentMatch,
+      cooccurrenceBoost: breakdown.cooccurrenceBoost,
+      typeBoost: breakdown.typeBoost,
+      contextBoost: breakdown.contextBoost,
+      recencyBoost: breakdown.recencyBoost,
+      crossFolderBoost: breakdown.crossFolderBoost,
+      hubBoost: breakdown.hubBoost,
+      feedbackAdjustment: breakdown.feedbackAdjustment
+    };
+    if (breakdown.semanticBoost !== void 0) {
+      layerMap.semanticBoost = breakdown.semanticBoost;
+    }
+    for (const [layer, value] of Object.entries(layerMap)) {
+      acc.layers[layer] = (acc.layers[layer] ?? 0) + value;
+    }
+  }
+  const result = [];
+  for (const [bucket, acc] of buckets) {
+    const avgLayers = {};
+    for (const [layer, sum] of Object.entries(acc.layers)) {
+      avgLayers[layer] = Math.round(sum / acc.count * 1e3) / 1e3;
+    }
+    result.push({ bucket, layers: avgLayers });
+  }
+  return result;
+}
+function getExtendedDashboardData(stateDb2) {
+  const base = getDashboardData(stateDb2);
+  const recentCutoff = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+  const eventRows = stateDb2.db.prepare(`
+    SELECT breakdown_json FROM suggestion_events WHERE timestamp >= ?
+  `).all(recentCutoff);
+  const layerSums = {};
+  const LAYER_NAMES = [
+    "contentMatch",
+    "cooccurrenceBoost",
+    "typeBoost",
+    "contextBoost",
+    "recencyBoost",
+    "crossFolderBoost",
+    "hubBoost",
+    "feedbackAdjustment",
+    "semanticBoost"
+  ];
+  for (const name of LAYER_NAMES) {
+    layerSums[name] = { sum: 0, count: 0 };
+  }
+  for (const row of eventRows) {
+    const breakdown = JSON.parse(row.breakdown_json);
+    for (const name of LAYER_NAMES) {
+      const val = breakdown[name];
+      if (val !== void 0) {
+        layerSums[name].sum += Math.abs(val);
+        layerSums[name].count++;
+      }
+    }
+  }
+  const layerHealth = LAYER_NAMES.map((layer) => {
+    const s = layerSums[layer];
+    const avg = s.count > 0 ? Math.round(s.sum / s.count * 1e3) / 1e3 : 0;
+    let status;
+    if (s.count === 0) status = "zero-data";
+    else if (avg > 0) status = "contributing";
+    else status = "dormant";
+    return { layer, status, avgContribution: avg, eventCount: s.count };
+  });
+  const topEntityRows = stateDb2.db.prepare(`
+    SELECT entity, COUNT(*) as cnt, AVG(total_score) as avg_score,
+           SUM(CASE WHEN passed = 1 THEN 1 ELSE 0 END) * 1.0 / COUNT(*) as pass_rate
+    FROM suggestion_events
+    GROUP BY entity
+    ORDER BY cnt DESC
+    LIMIT 10
+  `).all();
+  const topEntities = topEntityRows.map((r) => ({
+    entity: r.entity,
+    suggestionCount: r.cnt,
+    avgScore: Math.round(r.avg_score * 100) / 100,
+    passRate: Math.round(r.pass_rate * 1e3) / 1e3
+  }));
+  const feedbackTrendRows = stateDb2.db.prepare(`
+    SELECT date(created_at) as day, COUNT(*) as count
+    FROM wikilink_feedback
+    WHERE created_at >= datetime('now', '-30 days')
+    GROUP BY day
+    ORDER BY day
+  `).all();
+  const feedbackTrend = feedbackTrendRows.map((r) => ({
+    day: r.day,
+    count: r.count
+  }));
+  const suppressionRows = stateDb2.db.prepare(`
+    SELECT entity, false_positive_rate, updated_at
+    FROM wikilink_suppressions
+    ORDER BY updated_at DESC
+  `).all();
+  const suppressionChanges = suppressionRows.map((r) => ({
+    entity: r.entity,
+    falsePositiveRate: r.false_positive_rate,
+    updatedAt: r.updated_at
+  }));
+  return {
+    ...base,
+    layerHealth,
+    topEntities,
+    feedbackTrend,
+    suppressionChanges
+  };
+}
 
 // src/core/write/git.ts
 import { simpleGit, CheckRepoActions } from "simple-git";
-import path6 from "path";
+import path7 from "path";
 import fs6 from "fs/promises";
 import {
   setWriteState,
@@ -3611,7 +3981,7 @@ function clearLastMutationCommit() {
   }
 }
 async function checkGitLock(vaultPath2) {
-  const lockPath = path6.join(vaultPath2, ".git/index.lock");
+  const lockPath = path7.join(vaultPath2, ".git/index.lock");
   try {
     const stat3 = await fs6.stat(lockPath);
     const ageMs = Date.now() - stat3.mtimeMs;
@@ -3634,7 +4004,7 @@ async function isGitRepo(vaultPath2) {
   }
 }
 async function checkLockFile(vaultPath2) {
-  const lockPath = path6.join(vaultPath2, ".git/index.lock");
+  const lockPath = path7.join(vaultPath2, ".git/index.lock");
   try {
     const stat3 = await fs6.stat(lockPath);
     const ageMs = Date.now() - stat3.mtimeMs;
@@ -3684,7 +4054,7 @@ async function commitChange(vaultPath2, filePath, messagePrefix, retryConfig = D
         }
       }
       await git.add(filePath);
-      const fileName = path6.basename(filePath);
+      const fileName = path7.basename(filePath);
       const commitMessage = `${messagePrefix} Update ${fileName}`;
       const result = await git.commit(commitMessage);
       if (result.commit) {
@@ -3878,7 +4248,7 @@ function setHintsStateDb(stateDb2) {
 
 // src/core/shared/recency.ts
 import { readdir, readFile, stat } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 import {
   getEntityName,
   recordEntityMention,
@@ -3900,9 +4270,9 @@ async function* walkMarkdownFiles(dir, baseDir) {
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path7.join(dir, entry.name);
-      const relativePath = path7.relative(baseDir, fullPath);
-      const topFolder = relativePath.split(path7.sep)[0];
+      const fullPath = path8.join(dir, entry.name);
+      const relativePath = path8.relative(baseDir, fullPath);
+      const topFolder = relativePath.split(path8.sep)[0];
       if (EXCLUDED_FOLDERS.has(topFolder)) {
         continue;
       }
@@ -3986,14 +4356,16 @@ function loadRecencyFromStateDb() {
 }
 function saveRecencyToStateDb(index) {
   if (!moduleStateDb3) {
-    console.error("[Flywheel] No StateDb available for saving recency");
+    console.error("[Flywheel] saveRecencyToStateDb: No StateDb available (moduleStateDb is null)");
     return;
   }
+  console.error(`[Flywheel] saveRecencyToStateDb: Saving ${index.lastMentioned.size} entries...`);
   try {
     for (const [entityNameLower, timestamp] of index.lastMentioned) {
       recordEntityMention(moduleStateDb3, entityNameLower, new Date(timestamp));
     }
-    console.error(`[Flywheel] Saved ${index.lastMentioned.size} recency entries to StateDb`);
+    const count = moduleStateDb3.db.prepare("SELECT COUNT(*) as cnt FROM recency").get();
+    console.error(`[Flywheel] Saved recency: ${index.lastMentioned.size} entries \u2192 ${count.cnt} rows in table`);
   } catch (e) {
     console.error("[Flywheel] Failed to save recency to StateDb:", e);
   }
@@ -4780,7 +5152,7 @@ function tokenize(text) {
 
 // src/core/shared/cooccurrence.ts
 import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 var DEFAULT_MIN_COOCCURRENCE = 2;
 var EXCLUDED_FOLDERS2 = /* @__PURE__ */ new Set([
   "templates",
@@ -4814,9 +5186,9 @@ async function* walkMarkdownFiles2(dir, baseDir) {
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path8.join(dir, entry.name);
-      const relativePath = path8.relative(baseDir, fullPath);
-      const topFolder = relativePath.split(path8.sep)[0];
+      const fullPath = path9.join(dir, entry.name);
+      const relativePath = path9.relative(baseDir, fullPath);
+      const topFolder = relativePath.split(path9.sep)[0];
       if (EXCLUDED_FOLDERS2.has(topFolder)) {
         continue;
       }
@@ -5079,12 +5451,15 @@ function processWikilinks(content, notePath) {
   const resolved = resolveAliasWikilinks(content, sortedEntities, {
     caseInsensitive: true
   });
+  const step1LinkedEntities = new Set(resolved.linkedEntities.map((e) => e.toLowerCase()));
   const result = applyWikilinks(resolved.content, sortedEntities, {
     firstOccurrenceOnly: true,
-    caseInsensitive: true
+    caseInsensitive: true,
+    alreadyLinked: step1LinkedEntities
   });
   const implicitEnabled = moduleConfig?.implicit_detection !== false;
-  const implicitPatterns = moduleConfig?.implicit_patterns?.length ? moduleConfig.implicit_patterns : [...ALL_IMPLICIT_PATTERNS];
+  const validPatterns = new Set(ALL_IMPLICIT_PATTERNS);
+  const implicitPatterns = moduleConfig?.implicit_patterns?.length ? moduleConfig.implicit_patterns.filter((p) => validPatterns.has(p)) : [...ALL_IMPLICIT_PATTERNS];
   const implicitMatches = detectImplicitEntities(result.content, {
     detectImplicit: implicitEnabled,
     implicitPatterns,
@@ -5505,8 +5880,10 @@ async function suggestRelatedLinks(content, options = {}) {
     excludeLinked = true,
     strictness = getEffectiveStrictness(options.notePath),
     notePath,
-    detail = false
+    detail = false,
+    disabledLayers = []
   } = options;
+  const disabled = new Set(disabledLayers);
   const config = STRICTNESS_CONFIGS[strictness];
   const adaptiveMinScore = getAdaptiveMinScore(content.length, config.minSuggestionScore);
   const noteContext = notePath ? getNoteContext(notePath) : "general";
@@ -5547,31 +5924,31 @@ async function suggestRelatedLinks(content, options = {}) {
   for (const { entity, category } of entitiesWithTypes) {
     const entityName = entity.name;
     if (!entityName) continue;
-    if (entityName.length > MAX_ENTITY_LENGTH) {
+    if (!disabled.has("length_filter") && entityName.length > MAX_ENTITY_LENGTH) {
       continue;
     }
-    if (isLikelyArticleTitle(entityName)) {
+    if (!disabled.has("article_filter") && isLikelyArticleTitle(entityName)) {
       continue;
     }
     if (linkedEntities.has(entityName.toLowerCase())) {
       continue;
     }
-    const contentScore = scoreEntity(entity, contentTokens, contentStems, config);
+    const contentScore = disabled.has("exact_match") && disabled.has("stem_match") ? 0 : scoreEntity(entity, contentTokens, contentStems, config);
     let score = contentScore;
     if (contentScore > 0) {
       entitiesWithContentMatch.add(entityName);
     }
-    const layerTypeBoost = TYPE_BOOST[category] || 0;
+    const layerTypeBoost = disabled.has("type_boost") ? 0 : TYPE_BOOST[category] || 0;
     score += layerTypeBoost;
-    const layerContextBoost = contextBoosts[category] || 0;
+    const layerContextBoost = disabled.has("context_boost") ? 0 : contextBoosts[category] || 0;
     score += layerContextBoost;
-    const layerRecencyBoost = recencyIndex ? getRecencyBoost(entityName, recencyIndex) : 0;
+    const layerRecencyBoost = disabled.has("recency") ? 0 : recencyIndex ? getRecencyBoost(entityName, recencyIndex) : 0;
     score += layerRecencyBoost;
-    const layerCrossFolderBoost = notePath && entity.path ? getCrossFolderBoost(entity.path, notePath) : 0;
+    const layerCrossFolderBoost = disabled.has("cross_folder") ? 0 : notePath && entity.path ? getCrossFolderBoost(entity.path, notePath) : 0;
     score += layerCrossFolderBoost;
-    const layerHubBoost = getHubBoost(entity);
+    const layerHubBoost = disabled.has("hub_boost") ? 0 : getHubBoost(entity);
     score += layerHubBoost;
-    const layerFeedbackAdj = feedbackBoosts.get(entityName) ?? 0;
+    const layerFeedbackAdj = disabled.has("feedback") ? 0 : feedbackBoosts.get(entityName) ?? 0;
     score += layerFeedbackAdj;
     if (score > 0) {
       directlyMatchedEntities.add(entityName);
@@ -5595,12 +5972,12 @@ async function suggestRelatedLinks(content, options = {}) {
       });
     }
   }
-  if (cooccurrenceIndex && directlyMatchedEntities.size > 0) {
+  if (!disabled.has("cooccurrence") && cooccurrenceIndex && directlyMatchedEntities.size > 0) {
     for (const { entity, category } of entitiesWithTypes) {
       const entityName = entity.name;
       if (!entityName) continue;
-      if (entityName.length > MAX_ENTITY_LENGTH) continue;
-      if (isLikelyArticleTitle(entityName)) continue;
+      if (!disabled.has("length_filter") && entityName.length > MAX_ENTITY_LENGTH) continue;
+      if (!disabled.has("article_filter") && isLikelyArticleTitle(entityName)) continue;
       if (linkedEntities.has(entityName.toLowerCase())) continue;
       const boost = getCooccurrenceBoost(entityName, directlyMatchedEntities, cooccurrenceIndex, recencyIndex);
       if (boost > 0) {
@@ -5617,12 +5994,12 @@ async function suggestRelatedLinks(content, options = {}) {
             continue;
           }
           entitiesWithContentMatch.add(entityName);
-          const typeBoost = TYPE_BOOST[category] || 0;
-          const contextBoost = contextBoosts[category] || 0;
-          const recencyBoostVal = recencyIndex ? getRecencyBoost(entityName, recencyIndex) : 0;
-          const crossFolderBoost = notePath && entity.path ? getCrossFolderBoost(entity.path, notePath) : 0;
-          const hubBoost = getHubBoost(entity);
-          const feedbackAdj = feedbackBoosts.get(entityName) ?? 0;
+          const typeBoost = disabled.has("type_boost") ? 0 : TYPE_BOOST[category] || 0;
+          const contextBoost = disabled.has("context_boost") ? 0 : contextBoosts[category] || 0;
+          const recencyBoostVal = disabled.has("recency") ? 0 : recencyIndex ? getRecencyBoost(entityName, recencyIndex) : 0;
+          const crossFolderBoost = disabled.has("cross_folder") ? 0 : notePath && entity.path ? getCrossFolderBoost(entity.path, notePath) : 0;
+          const hubBoost = disabled.has("hub_boost") ? 0 : getHubBoost(entity);
+          const feedbackAdj = disabled.has("feedback") ? 0 : feedbackBoosts.get(entityName) ?? 0;
           const totalBoost = boost + typeBoost + contextBoost + recencyBoostVal + crossFolderBoost + hubBoost + feedbackAdj;
           if (totalBoost >= adaptiveMinScore) {
             scoredEntities.push({
@@ -5646,7 +6023,7 @@ async function suggestRelatedLinks(content, options = {}) {
       }
     }
   }
-  if (content.length >= 20 && hasEntityEmbeddingsIndex()) {
+  if (!disabled.has("semantic") && content.length >= 20 && hasEntityEmbeddingsIndex()) {
     try {
       const contentEmbedding = await embedTextCached(content);
       const alreadyScoredNames = new Set(scoredEntities.map((e) => e.name));
@@ -5668,14 +6045,14 @@ async function suggestRelatedLinks(content, options = {}) {
             (et) => et.entity.name === match.entityName
           );
           if (!entityWithType) continue;
-          if (match.entityName.length > MAX_ENTITY_LENGTH) continue;
-          if (isLikelyArticleTitle(match.entityName)) continue;
+          if (!disabled.has("length_filter") && match.entityName.length > MAX_ENTITY_LENGTH) continue;
+          if (!disabled.has("article_filter") && isLikelyArticleTitle(match.entityName)) continue;
           const { entity, category } = entityWithType;
-          const layerTypeBoost = TYPE_BOOST[category] || 0;
-          const layerContextBoost = contextBoosts[category] || 0;
-          const layerHubBoost = getHubBoost(entity);
-          const layerCrossFolderBoost = notePath && entity.path ? getCrossFolderBoost(entity.path, notePath) : 0;
-          const layerFeedbackAdj = feedbackBoosts.get(match.entityName) ?? 0;
+          const layerTypeBoost = disabled.has("type_boost") ? 0 : TYPE_BOOST[category] || 0;
+          const layerContextBoost = disabled.has("context_boost") ? 0 : contextBoosts[category] || 0;
+          const layerHubBoost = disabled.has("hub_boost") ? 0 : getHubBoost(entity);
+          const layerCrossFolderBoost = disabled.has("cross_folder") ? 0 : notePath && entity.path ? getCrossFolderBoost(entity.path, notePath) : 0;
+          const layerFeedbackAdj = disabled.has("feedback") ? 0 : feedbackBoosts.get(match.entityName) ?? 0;
           const totalScore = boost + layerTypeBoost + layerContextBoost + layerHubBoost + layerCrossFolderBoost + layerFeedbackAdj;
           if (totalScore >= adaptiveMinScore) {
             scoredEntities.push({
@@ -5717,7 +6094,51 @@ async function suggestRelatedLinks(content, options = {}) {
     }
     return 0;
   });
-  const topEntries = relevantEntities.slice(0, maxSuggestions);
+  if (moduleStateDb4 && notePath) {
+    try {
+      const now = Date.now();
+      const insertStmt = moduleStateDb4.db.prepare(`
+        INSERT OR IGNORE INTO suggestion_events
+          (timestamp, note_path, entity, total_score, breakdown_json, threshold, passed, strictness, applied, pipeline_event_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, NULL)
+      `);
+      const persistTransaction = moduleStateDb4.db.transaction(() => {
+        for (const e of relevantEntities) {
+          insertStmt.run(
+            now,
+            notePath,
+            e.name,
+            e.score,
+            JSON.stringify(e.breakdown),
+            adaptiveMinScore,
+            1,
+            // passed threshold (these are relevantEntities)
+            strictness
+          );
+        }
+        for (const e of scoredEntities) {
+          if (!entitiesWithContentMatch.has(e.name)) continue;
+          if (relevantEntities.some((r) => r.name === e.name)) continue;
+          insertStmt.run(
+            now,
+            notePath,
+            e.name,
+            e.score,
+            JSON.stringify(e.breakdown),
+            adaptiveMinScore,
+            0,
+            // did not pass threshold
+            strictness
+          );
+        }
+      });
+      persistTransaction();
+    } catch {
+    }
+  }
+  const currentNoteStem = notePath ? notePath.replace(/\.md$/, "").split("/").pop()?.toLowerCase() : null;
+  const filtered = currentNoteStem ? relevantEntities.filter((e) => e.name.toLowerCase() !== currentNoteStem) : relevantEntities;
+  const topEntries = filtered.slice(0, maxSuggestions);
   const topSuggestions = topEntries.map((e) => e.name);
   if (topSuggestions.length === 0) {
     return emptyResult;
@@ -6081,11 +6502,11 @@ function countFTS5Mentions(term) {
 }
 
 // src/core/read/taskCache.ts
-import * as path10 from "path";
+import * as path11 from "path";
 
 // src/tools/read/tasks.ts
 import * as fs8 from "fs";
-import * as path9 from "path";
+import * as path10 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/;
@@ -6154,7 +6575,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 = path9.join(vaultPath2, note.path);
+    const absolutePath = path10.join(vaultPath2, note.path);
     const tasks = await extractTasksFromNote(note.path, absolutePath);
     allTasks.push(...tasks);
   }
@@ -6198,7 +6619,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 = path9.join(vaultPath2, notePath);
+  const absolutePath = path10.join(vaultPath2, notePath);
   let tasks = await extractTasksFromNote(notePath, absolutePath);
   if (excludeTags.length > 0) {
     tasks = tasks.filter(
@@ -6290,7 +6711,7 @@ async function buildTaskCache(vaultPath2, index, excludeTags) {
     }
     const allRows = [];
     for (const notePath of notePaths) {
-      const absolutePath = path10.join(vaultPath2, notePath);
+      const absolutePath = path11.join(vaultPath2, notePath);
       const tasks = await extractTasksFromNote(notePath, absolutePath);
       for (const task of tasks) {
         if (excludeTags?.length && excludeTags.some((t) => task.tags.includes(t))) {
@@ -6332,7 +6753,7 @@ async function buildTaskCache(vaultPath2, index, excludeTags) {
 async function updateTaskCacheForFile(vaultPath2, relativePath) {
   if (!db3) return;
   db3.prepare("DELETE FROM tasks WHERE path = ?").run(relativePath);
-  const absolutePath = path10.join(vaultPath2, relativePath);
+  const absolutePath = path11.join(vaultPath2, relativePath);
   const tasks = await extractTasksFromNote(relativePath, absolutePath);
   if (tasks.length > 0) {
     const insertStmt = db3.prepare(`
@@ -6472,7 +6893,7 @@ import { openStateDb, scanVaultEntities as scanVaultEntities3, getSessionId, get
 
 // src/tools/read/graph.ts
 import * as fs9 from "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 import { z } from "zod";
 
 // src/core/read/constants.ts
@@ -6756,7 +7177,7 @@ function requireIndex() {
 // src/tools/read/graph.ts
 async function getContext(vaultPath2, sourcePath, line, contextLines = 1) {
   try {
-    const fullPath = path11.join(vaultPath2, sourcePath);
+    const fullPath = path12.join(vaultPath2, sourcePath);
     const content = await fs9.promises.readFile(fullPath, "utf-8");
     const allLines = content.split("\n");
     let fmLines = 0;
@@ -7070,14 +7491,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path30] of entities) {
+    for (const [name, path31] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path30;
+        return path31;
       }
     }
-    for (const [name, path30] of entities) {
+    for (const [name, path31] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path30;
+        return path31;
       }
     }
     return void 0;
@@ -8054,8 +8475,8 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       daily_counts: z3.record(z3.number())
     }).describe("Activity summary for the last 7 days")
   };
-  function isPeriodicNote2(path30) {
-    const filename = path30.split("/").pop() || "";
+  function isPeriodicNote2(path31) {
+    const filename = path31.split("/").pop() || "";
     const nameWithoutExt = filename.replace(/\.md$/, "");
     const patterns = [
       /^\d{4}-\d{2}-\d{2}$/,
@@ -8070,7 +8491,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       // YYYY (yearly)
     ];
     const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
-    const folder = path30.split("/")[0]?.toLowerCase() || "";
+    const folder = path31.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   server2.registerTool(
@@ -8478,7 +8899,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
 
 // src/tools/read/system.ts
 import * as fs11 from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 import { z as z5 } from "zod";
 import { scanVaultEntities as scanVaultEntities2, getEntityIndexFromDb as getEntityIndexFromDb2 } from "@velvetmonkey/vault-core";
 
@@ -8778,7 +9199,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
           continue;
         }
         try {
-          const fullPath = path12.join(vaultPath2, note.path);
+          const fullPath = path13.join(vaultPath2, note.path);
           const content = await fs11.promises.readFile(fullPath, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
@@ -8894,7 +9315,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
       let wordCount;
       if (include_word_count) {
         try {
-          const fullPath = path12.join(vaultPath2, resolvedPath);
+          const fullPath = path13.join(vaultPath2, resolvedPath);
           const content = await fs11.promises.readFile(fullPath, "utf-8");
           wordCount = content.split(/\s+/).filter((w) => w.length > 0).length;
         } catch {
@@ -9125,7 +9546,7 @@ import { z as z6 } from "zod";
 
 // src/tools/read/structure.ts
 import * as fs12 from "fs";
-import * as path13 from "path";
+import * as path14 from "path";
 var HEADING_REGEX2 = /^(#{1,6})\s+(.+)$/;
 function extractHeadings(content) {
   const lines = content.split("\n");
@@ -9179,7 +9600,7 @@ function buildSections(headings, totalLines) {
 async function getNoteStructure(index, notePath, vaultPath2) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path13.join(vaultPath2, notePath);
+  const absolutePath = path14.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs12.promises.readFile(absolutePath, "utf-8");
@@ -9202,7 +9623,7 @@ 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 = path13.join(vaultPath2, notePath);
+  const absolutePath = path14.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs12.promises.readFile(absolutePath, "utf-8");
@@ -9244,7 +9665,7 @@ 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 = path13.join(vaultPath2, note.path);
+    const absolutePath = path14.join(vaultPath2, note.path);
     let content;
     try {
       content = await fs12.promises.readFile(absolutePath, "utf-8");
@@ -9278,18 +9699,18 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         include_content: z6.boolean().default(false).describe("Include the text content under each top-level section")
       }
     },
-    async ({ path: path30, include_content }) => {
+    async ({ path: path31, include_content }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path30, vaultPath2);
+      const result = await getNoteStructure(index, path31, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path30 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path31 }, null, 2) }]
         };
       }
       if (include_content) {
         for (const section of result.sections) {
-          const sectionResult = await getSectionContent(index, path30, section.heading.text, vaultPath2, true);
+          const sectionResult = await getSectionContent(index, path31, section.heading.text, vaultPath2, true);
           if (sectionResult) {
             section.content = sectionResult.content;
           }
@@ -9311,15 +9732,15 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         include_subheadings: z6.boolean().default(true).describe("Include content under subheadings")
       }
     },
-    async ({ path: path30, heading, include_subheadings }) => {
+    async ({ path: path31, heading, include_subheadings }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path30, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path31, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path30,
+            path: path31,
             heading
           }, null, 2) }]
         };
@@ -9373,16 +9794,16 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         offset: z6.coerce.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path30, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
+    async ({ path: path31, 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 = getConfig();
-      if (path30) {
-        const result2 = await getTasksFromNote(index, path30, vaultPath2, config.exclude_task_tags || []);
+      if (path31) {
+        const result2 = await getTasksFromNote(index, path31, vaultPath2, config.exclude_task_tags || []);
         if (!result2) {
           return {
-            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path30 }, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path31 }, null, 2) }]
           };
         }
         let filtered = result2;
@@ -9392,7 +9813,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         const paged2 = filtered.slice(offset, offset + limit);
         return {
           content: [{ type: "text", text: JSON.stringify({
-            path: path30,
+            path: path31,
             total_count: filtered.length,
             returned_count: paged2.length,
             open: result2.filter((t) => t.status === "open").length,
@@ -9548,7 +9969,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
 // src/tools/read/migrations.ts
 import { z as z7 } from "zod";
 import * as fs13 from "fs/promises";
-import * as path14 from "path";
+import * as path15 from "path";
 import matter2 from "gray-matter";
 function getNotesInFolder(index, folder) {
   const notes = [];
@@ -9561,7 +9982,7 @@ function getNotesInFolder(index, folder) {
   return notes;
 }
 async function readFileContent(notePath, vaultPath2) {
-  const fullPath = path14.join(vaultPath2, notePath);
+  const fullPath = path15.join(vaultPath2, notePath);
   try {
     return await fs13.readFile(fullPath, "utf-8");
   } catch {
@@ -9569,7 +9990,7 @@ async function readFileContent(notePath, vaultPath2) {
   }
 }
 async function writeFileContent(notePath, vaultPath2, content) {
-  const fullPath = path14.join(vaultPath2, notePath);
+  const fullPath = path15.join(vaultPath2, notePath);
   try {
     await fs13.writeFile(fullPath, content, "utf-8");
     return true;
@@ -9750,7 +10171,7 @@ function registerMigrationTools(server2, getIndex, getVaultPath) {
 
 // src/tools/read/graphAnalysis.ts
 import fs14 from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 import { z as z8 } from "zod";
 
 // src/tools/read/schema.ts
@@ -10295,6 +10716,49 @@ function getEmergingHubs(stateDb2, daysBack = 30) {
   emerging.sort((a, b) => b.growth - a.growth);
   return emerging;
 }
+function compareGraphSnapshots(stateDb2, timestampBefore, timestampAfter) {
+  const SCALAR_METRICS = ["avg_degree", "max_degree", "cluster_count", "largest_cluster_size"];
+  function getSnapshotAt(ts) {
+    const row = stateDb2.db.prepare(
+      `SELECT DISTINCT timestamp FROM graph_snapshots WHERE timestamp <= ? ORDER BY timestamp DESC LIMIT 1`
+    ).get(ts);
+    if (!row) return null;
+    const rows = stateDb2.db.prepare(
+      `SELECT metric, value, details FROM graph_snapshots WHERE timestamp = ?`
+    ).all(row.timestamp);
+    return rows;
+  }
+  const beforeRows = getSnapshotAt(timestampBefore) ?? [];
+  const afterRows = getSnapshotAt(timestampAfter) ?? [];
+  const beforeMap = /* @__PURE__ */ new Map();
+  const afterMap = /* @__PURE__ */ new Map();
+  for (const r of beforeRows) beforeMap.set(r.metric, { value: r.value, details: r.details });
+  for (const r of afterRows) afterMap.set(r.metric, { value: r.value, details: r.details });
+  const metricChanges = SCALAR_METRICS.map((metric) => {
+    const before = beforeMap.get(metric)?.value ?? 0;
+    const after = afterMap.get(metric)?.value ?? 0;
+    const delta = after - before;
+    const deltaPercent = before !== 0 ? Math.round(delta / before * 1e4) / 100 : delta !== 0 ? 100 : 0;
+    return { metric, before, after, delta, deltaPercent };
+  });
+  const beforeHubs = beforeMap.get("hub_scores_top10")?.details ? JSON.parse(beforeMap.get("hub_scores_top10").details) : [];
+  const afterHubs = afterMap.get("hub_scores_top10")?.details ? JSON.parse(afterMap.get("hub_scores_top10").details) : [];
+  const beforeHubMap = /* @__PURE__ */ new Map();
+  for (const h of beforeHubs) beforeHubMap.set(h.entity, h.degree);
+  const afterHubMap = /* @__PURE__ */ new Map();
+  for (const h of afterHubs) afterHubMap.set(h.entity, h.degree);
+  const allHubEntities = /* @__PURE__ */ new Set([...beforeHubMap.keys(), ...afterHubMap.keys()]);
+  const hubScoreChanges = [];
+  for (const entity of allHubEntities) {
+    const before = beforeHubMap.get(entity) ?? 0;
+    const after = afterHubMap.get(entity) ?? 0;
+    if (before !== after) {
+      hubScoreChanges.push({ entity, before, after, delta: after - before });
+    }
+  }
+  hubScoreChanges.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
+  return { metricChanges, hubScoreChanges };
+}
 function purgeOldSnapshots(stateDb2, retentionDays = 90) {
   const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
   const result = stateDb2.db.prepare(
@@ -10469,7 +10933,7 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb,
           const scored = allNotes.map((note) => {
             let wordCount = 0;
             try {
-              const content = fs14.readFileSync(path15.join(vaultPath2, note.path), "utf-8");
+              const content = fs14.readFileSync(path16.join(vaultPath2, note.path), "utf-8");
               const body = content.replace(/^---[\s\S]*?---\n?/, "");
               wordCount = body.split(/\s+/).filter((w) => w.length > 0).length;
             } catch {
@@ -11049,12 +11513,12 @@ import { z as z10 } from "zod";
 
 // src/tools/read/bidirectional.ts
 import * as fs15 from "fs/promises";
-import * as path16 from "path";
+import * as path17 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 = path16.join(vaultPath2, notePath);
+  const fullPath = path17.join(vaultPath2, notePath);
   try {
     return await fs15.readFile(fullPath, "utf-8");
   } catch {
@@ -11233,10 +11697,10 @@ async function suggestWikilinksInFrontmatter(index, notePath, vaultPath2) {
 
 // src/tools/read/computed.ts
 import * as fs16 from "fs/promises";
-import * as path17 from "path";
+import * as path18 from "path";
 import matter4 from "gray-matter";
 async function readFileContent3(notePath, vaultPath2) {
-  const fullPath = path17.join(vaultPath2, notePath);
+  const fullPath = path18.join(vaultPath2, notePath);
   try {
     return await fs16.readFile(fullPath, "utf-8");
   } catch {
@@ -11244,7 +11708,7 @@ async function readFileContent3(notePath, vaultPath2) {
   }
 }
 async function getFileStats(notePath, vaultPath2) {
-  const fullPath = path17.join(vaultPath2, notePath);
+  const fullPath = path18.join(vaultPath2, notePath);
   try {
     const stats = await fs16.stat(fullPath);
     return {
@@ -11515,7 +11979,7 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath, getConfi
 init_writer();
 import { z as z11 } from "zod";
 import fs20 from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 
 // src/core/write/validator.ts
 var TIMESTAMP_PATTERN = /^\*\*\d{2}:\d{2}\*\*/;
@@ -11718,7 +12182,7 @@ function runValidationPipeline(content, format, options = {}) {
 // src/core/write/mutation-helpers.ts
 init_writer();
 import fs19 from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 init_constants();
 init_writer();
 function formatMcpResult(result) {
@@ -11767,7 +12231,7 @@ async function handleGitCommit(vaultPath2, notePath, commit, prefix) {
   return info;
 }
 async function ensureFileExists(vaultPath2, notePath) {
-  const fullPath = path19.join(vaultPath2, notePath);
+  const fullPath = path20.join(vaultPath2, notePath);
   try {
     await fs19.access(fullPath);
     return null;
@@ -11826,7 +12290,7 @@ async function withVaultFile(options, operation) {
     if ("error" in result) {
       return formatMcpResult(result.error);
     }
-    const fullPath = path19.join(vaultPath2, notePath);
+    const fullPath = path20.join(vaultPath2, notePath);
     const statBefore = await fs19.stat(fullPath);
     if (statBefore.mtimeMs !== result.mtimeMs) {
       console.warn(`[withVaultFile] External modification detected on ${notePath}, re-reading and retrying`);
@@ -11889,10 +12353,10 @@ async function withVaultFrontmatter(options, operation) {
 
 // src/tools/write/mutations.ts
 async function createNoteFromTemplate(vaultPath2, notePath, config) {
-  const fullPath = path20.join(vaultPath2, notePath);
-  await fs20.mkdir(path20.dirname(fullPath), { recursive: true });
+  const fullPath = path21.join(vaultPath2, notePath);
+  await fs20.mkdir(path21.dirname(fullPath), { recursive: true });
   const templates = config.templates || {};
-  const filename = path20.basename(notePath, ".md").toLowerCase();
+  const filename = path21.basename(notePath, ".md").toLowerCase();
   let templatePath;
   const dailyPattern = /^\d{4}-\d{2}-\d{2}/;
   const weeklyPattern = /^\d{4}-W\d{2}/;
@@ -11913,10 +12377,10 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   let templateContent;
   if (templatePath) {
     try {
-      const absTemplatePath = path20.join(vaultPath2, templatePath);
+      const absTemplatePath = path21.join(vaultPath2, templatePath);
       templateContent = await fs20.readFile(absTemplatePath, "utf-8");
     } catch {
-      const title = path20.basename(notePath, ".md");
+      const title = path21.basename(notePath, ".md");
       templateContent = `---
 ---
 
@@ -11925,7 +12389,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
       templatePath = void 0;
     }
   } else {
-    const title = path20.basename(notePath, ".md");
+    const title = path21.basename(notePath, ".md");
     templateContent = `---
 ---
 
@@ -11934,7 +12398,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, path20.basename(notePath, ".md"));
+  templateContent = templateContent.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, path21.basename(notePath, ".md"));
   const matter9 = (await import("gray-matter")).default;
   const parsed = matter9(templateContent);
   if (!parsed.data.date) {
@@ -11966,14 +12430,15 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
       validate: z11.boolean().default(true).describe("Check input for common issues (double timestamps, non-markdown bullets, etc.)"),
       normalize: z11.boolean().default(true).describe("Auto-fix common issues before formatting (replace \u2022 with -, trim excessive whitespace, etc.)"),
       guardrails: z11.enum(["warn", "strict", "off"]).default("warn").describe('Output validation mode: "warn" returns issues but proceeds, "strict" blocks on errors, "off" disables'),
+      linkedEntities: z11.array(z11.string()).optional().describe("Entity names already linked in the content. When skipWikilinks=true, these are tracked for feedback without re-processing the content."),
       agent_id: z11.string().optional().describe('Agent identifier for multi-agent scoping (e.g., "claude-opus", "planning-agent")'),
       session_id: z11.string().optional().describe('Session identifier for conversation scoping (e.g., "sess-abc123")')
     },
-    async ({ path: notePath, section, content, create_if_missing, position, format, commit, skipWikilinks, preserveListNesting, bumpHeadings, suggestOutgoingLinks, maxSuggestions, validate, normalize, guardrails, agent_id, session_id }) => {
+    async ({ path: notePath, section, content, create_if_missing, position, format, commit, skipWikilinks, preserveListNesting, bumpHeadings, suggestOutgoingLinks, maxSuggestions, validate, normalize, guardrails, linkedEntities, agent_id, session_id }) => {
       let noteCreated = false;
       let templateUsed;
       if (create_if_missing) {
-        const fullPath = path20.join(vaultPath2, notePath);
+        const fullPath = path21.join(vaultPath2, notePath);
         try {
           await fs20.access(fullPath);
         } catch {
@@ -12004,6 +12469,12 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
           }
           let workingContent = validationResult.content;
           let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(workingContent, skipWikilinks, notePath);
+          if (linkedEntities?.length) {
+            const stateDb2 = getWriteStateDb();
+            if (stateDb2) {
+              trackWikilinkApplications(stateDb2, notePath, linkedEntities);
+            }
+          }
           const _debug = {
             entityCount: getEntityIndexStats().totalEntities,
             indexReady: getEntityIndexStats().ready,
@@ -12426,7 +12897,7 @@ Example: vault_update_frontmatter({ path: "projects/alpha.md", frontmatter: { st
 init_writer();
 import { z as z14 } from "zod";
 import fs21 from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 function registerNoteTools(server2, vaultPath2, getIndex) {
   server2.tool(
     "vault_create_note",
@@ -12439,7 +12910,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
       overwrite: z14.boolean().default(false).describe("If true, overwrite existing file"),
       commit: z14.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
       skipWikilinks: z14.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)"),
-      suggestOutgoingLinks: z14.boolean().default(false).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]], [[Philosophy]]"). Disabled by default for templates; enable for content-rich notes.'),
+      suggestOutgoingLinks: z14.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]], [[Philosophy]]").'),
       maxSuggestions: z14.number().min(1).max(10).default(3).describe("Maximum number of suggested wikilinks to append (1-10, default: 3)"),
       agent_id: z14.string().optional().describe("Agent identifier for multi-agent scoping"),
       session_id: z14.string().optional().describe("Session identifier for conversation scoping")
@@ -12449,23 +12920,23 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
         if (!validatePath(vaultPath2, notePath)) {
           return formatMcpResult(errorResult(notePath, "Invalid path: path traversal not allowed"));
         }
-        const fullPath = path21.join(vaultPath2, notePath);
+        const fullPath = path22.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 = path21.dirname(fullPath);
+        const dir = path22.dirname(fullPath);
         await fs21.mkdir(dir, { recursive: true });
         let effectiveContent = content;
         let effectiveFrontmatter = frontmatter;
         if (template) {
-          const templatePath = path21.join(vaultPath2, template);
+          const templatePath = path22.join(vaultPath2, template);
           try {
             const raw = await fs21.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 = path21.basename(notePath, ".md");
+            const title = path22.basename(notePath, ".md");
             let templateContent = parsed.content.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, title);
             if (content) {
               templateContent = templateContent.trimEnd() + "\n\n" + content;
@@ -12484,7 +12955,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
           effectiveFrontmatter.created = now.toISOString();
         }
         const warnings = [];
-        const noteName = path21.basename(notePath, ".md");
+        const noteName = path22.basename(notePath, ".md");
         const existingAliases = Array.isArray(effectiveFrontmatter?.aliases) ? effectiveFrontmatter.aliases.filter((a) => typeof a === "string") : [];
         const preflight = await checkPreflightSimilarity(noteName);
         if (preflight.existingEntity) {
@@ -12601,7 +13072,7 @@ ${sources}`;
           }
           return formatMcpResult(errorResult(notePath, previewLines.join("\n")));
         }
-        const fullPath = path21.join(vaultPath2, notePath);
+        const fullPath = path22.join(vaultPath2, notePath);
         await fs21.unlink(fullPath);
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Flywheel:Delete]");
         const message = backlinkWarning ? `Deleted note: ${notePath}
@@ -12621,7 +13092,7 @@ Warning: ${backlinkWarning}` : `Deleted note: ${notePath}`;
 init_writer();
 import { z as z15 } from "zod";
 import fs22 from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 import matter6 from "gray-matter";
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -12640,7 +13111,7 @@ function extractWikilinks2(content) {
   return wikilinks;
 }
 function getTitleFromPath(filePath) {
-  return path22.basename(filePath, ".md");
+  return path23.basename(filePath, ".md");
 }
 async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   const results = [];
@@ -12649,7 +13120,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
     const files = [];
     const entries = await fs22.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path22.join(dir, entry.name);
+      const fullPath = path23.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         files.push(...await scanDir(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -12660,7 +13131,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   }
   const allFiles = await scanDir(vaultPath2);
   for (const filePath of allFiles) {
-    const relativePath = path22.relative(vaultPath2, filePath);
+    const relativePath = path23.relative(vaultPath2, filePath);
     const content = await fs22.readFile(filePath, "utf-8");
     const wikilinks = extractWikilinks2(content);
     const matchingLinks = [];
@@ -12680,7 +13151,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   return results;
 }
 async function updateBacklinksInFile(vaultPath2, filePath, oldTitles, newTitle) {
-  const fullPath = path22.join(vaultPath2, filePath);
+  const fullPath = path23.join(vaultPath2, filePath);
   const raw = await fs22.readFile(fullPath, "utf-8");
   const parsed = matter6(raw);
   let content = parsed.content;
@@ -12747,8 +13218,8 @@ function registerMoveNoteTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const oldFullPath = path22.join(vaultPath2, oldPath);
-        const newFullPath = path22.join(vaultPath2, newPath);
+        const oldFullPath = path23.join(vaultPath2, oldPath);
+        const newFullPath = path23.join(vaultPath2, newPath);
         try {
           await fs22.access(oldFullPath);
         } catch {
@@ -12798,7 +13269,7 @@ function registerMoveNoteTools(server2, vaultPath2) {
             }
           }
         }
-        const destDir = path22.dirname(newFullPath);
+        const destDir = path23.dirname(newFullPath);
         await fs22.mkdir(destDir, { recursive: true });
         await fs22.rename(oldFullPath, newFullPath);
         let gitCommit;
@@ -12884,10 +13355,10 @@ function registerMoveNoteTools(server2, vaultPath2) {
         if (sanitizedTitle !== newTitle) {
           console.error(`[Flywheel] Title sanitized: "${newTitle}" \u2192 "${sanitizedTitle}"`);
         }
-        const fullPath = path22.join(vaultPath2, notePath);
-        const dir = path22.dirname(notePath);
-        const newPath = dir === "." ? `${sanitizedTitle}.md` : path22.join(dir, `${sanitizedTitle}.md`);
-        const newFullPath = path22.join(vaultPath2, newPath);
+        const fullPath = path23.join(vaultPath2, notePath);
+        const dir = path23.dirname(notePath);
+        const newPath = dir === "." ? `${sanitizedTitle}.md` : path23.join(dir, `${sanitizedTitle}.md`);
+        const newFullPath = path23.join(vaultPath2, newPath);
         try {
           await fs22.access(fullPath);
         } catch {
@@ -13244,7 +13715,7 @@ init_schema();
 // src/core/write/policy/parser.ts
 init_schema();
 import fs24 from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 import matter7 from "gray-matter";
 function parseYaml(content) {
   const parsed = matter7(`---
@@ -13293,13 +13764,13 @@ async function loadPolicyFile(filePath) {
   }
 }
 async function loadPolicy(vaultPath2, policyName) {
-  const policiesDir = path23.join(vaultPath2, ".claude", "policies");
-  const policyPath = path23.join(policiesDir, `${policyName}.yaml`);
+  const policiesDir = path24.join(vaultPath2, ".claude", "policies");
+  const policyPath = path24.join(policiesDir, `${policyName}.yaml`);
   try {
     await fs24.access(policyPath);
     return loadPolicyFile(policyPath);
   } catch {
-    const ymlPath = path23.join(policiesDir, `${policyName}.yml`);
+    const ymlPath = path24.join(policiesDir, `${policyName}.yml`);
     try {
       await fs24.access(ymlPath);
       return loadPolicyFile(ymlPath);
@@ -13440,7 +13911,7 @@ init_conditions();
 init_schema();
 init_writer();
 import fs26 from "fs/promises";
-import path25 from "path";
+import path26 from "path";
 init_constants();
 async function executeStep(step, vaultPath2, context, conditionResults) {
   const { execute, reason } = shouldStepExecute(step.when, conditionResults);
@@ -13456,12 +13927,17 @@ async function executeStep(step, vaultPath2, context, conditionResults) {
   const resolvedParams = interpolateObject(step.params, context);
   try {
     const result = await executeToolCall(step.tool, resolvedParams, vaultPath2, context);
+    const outputs = {};
+    if (result.path) {
+      outputs.path = result.path;
+    }
     return {
       stepId: step.id,
       success: result.success,
       message: result.message,
       path: result.path,
-      preview: result.preview
+      preview: result.preview,
+      outputs
     };
   } catch (error) {
     return {
@@ -13509,7 +13985,7 @@ async function executeAddToSection(params, vaultPath2, context) {
   const preserveListNesting = params.preserveListNesting !== false;
   const suggestOutgoingLinks = params.suggestOutgoingLinks !== false;
   const maxSuggestions = Number(params.maxSuggestions) || 3;
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13549,7 +14025,7 @@ async function executeRemoveFromSection(params, vaultPath2) {
   const pattern = String(params.pattern || "");
   const mode = params.mode || "first";
   const useRegex = Boolean(params.useRegex);
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13580,7 +14056,7 @@ async function executeReplaceInSection(params, vaultPath2, context) {
   const mode = params.mode || "first";
   const useRegex = Boolean(params.useRegex);
   const skipWikilinks = Boolean(params.skipWikilinks);
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13623,7 +14099,7 @@ async function executeCreateNote(params, vaultPath2, context) {
   if (!validatePath(vaultPath2, notePath)) {
     return { success: false, message: "Invalid path: path traversal not allowed", path: notePath };
   }
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
     if (!overwrite) {
@@ -13631,7 +14107,7 @@ async function executeCreateNote(params, vaultPath2, context) {
     }
   } catch {
   }
-  const dir = path25.dirname(fullPath);
+  const dir = path26.dirname(fullPath);
   await fs26.mkdir(dir, { recursive: true });
   const { content: processedContent } = maybeApplyWikilinks(content, skipWikilinks, notePath);
   await writeVaultFile(vaultPath2, notePath, processedContent, frontmatter);
@@ -13651,7 +14127,7 @@ async function executeDeleteNote(params, vaultPath2) {
   if (!validatePath(vaultPath2, notePath)) {
     return { success: false, message: "Invalid path: path traversal not allowed", path: notePath };
   }
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13668,7 +14144,7 @@ async function executeToggleTask(params, vaultPath2) {
   const notePath = String(params.path || "");
   const task = String(params.task || "");
   const section = params.section ? String(params.section) : void 0;
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13711,7 +14187,7 @@ async function executeAddTask(params, vaultPath2, context) {
   const completed = Boolean(params.completed);
   const skipWikilinks = Boolean(params.skipWikilinks);
   const preserveListNesting = params.preserveListNesting !== false;
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13748,7 +14224,7 @@ async function executeAddTask(params, vaultPath2, context) {
 async function executeUpdateFrontmatter(params, vaultPath2) {
   const notePath = String(params.path || "");
   const updates = params.frontmatter || {};
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13770,7 +14246,7 @@ async function executeAddFrontmatterField(params, vaultPath2) {
   const notePath = String(params.path || "");
   const key = String(params.key || "");
   const value = params.value;
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13852,6 +14328,9 @@ async function executePolicy(policy, vaultPath2, variables, commit = false) {
     if (result.path && result.success && !result.skipped) {
       filesModified.add(result.path);
     }
+    if (result.success && !result.skipped && result.outputs) {
+      context.steps[step.id] = result.outputs;
+    }
     if (!result.success && !result.skipped) {
       if (commit && filesModified.size > 0) {
         await rollbackChanges(vaultPath2, originalContents, filesModified);
@@ -13930,7 +14409,7 @@ async function executePolicy(policy, vaultPath2, variables, commit = false) {
 async function rollbackChanges(vaultPath2, originalContents, filesModified) {
   for (const filePath of filesModified) {
     const original = originalContents.get(filePath);
-    const fullPath = path25.join(vaultPath2, filePath);
+    const fullPath = path26.join(vaultPath2, filePath);
     if (original === null) {
       try {
         await fs26.unlink(fullPath);
@@ -13985,9 +14464,9 @@ async function previewPolicy(policy, vaultPath2, variables) {
 
 // src/core/write/policy/storage.ts
 import fs27 from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 function getPoliciesDir(vaultPath2) {
-  return path26.join(vaultPath2, ".claude", "policies");
+  return path27.join(vaultPath2, ".claude", "policies");
 }
 async function ensurePoliciesDir(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
@@ -14002,7 +14481,7 @@ async function listPolicies(vaultPath2) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
         continue;
       }
-      const filePath = path26.join(dir, file);
+      const filePath = path27.join(dir, file);
       const stat3 = await fs27.stat(filePath);
       const content = await fs27.readFile(filePath, "utf-8");
       const metadata = extractPolicyMetadata(content);
@@ -14027,7 +14506,7 @@ async function writePolicyRaw(vaultPath2, policyName, content, overwrite = false
   const dir = getPoliciesDir(vaultPath2);
   await ensurePoliciesDir(vaultPath2);
   const filename = `${policyName}.yaml`;
-  const filePath = path26.join(dir, filename);
+  const filePath = path27.join(dir, filename);
   if (!overwrite) {
     try {
       await fs27.access(filePath);
@@ -14571,7 +15050,7 @@ import { z as z20 } from "zod";
 
 // src/core/write/tagRename.ts
 import * as fs28 from "fs/promises";
-import * as path27 from "path";
+import * as path28 from "path";
 import matter8 from "gray-matter";
 import { getProtectedZones } from "@velvetmonkey/vault-core";
 function getNotesInFolder3(index, folder) {
@@ -14677,7 +15156,7 @@ async function renameTag(index, vaultPath2, oldTag, newTag, options) {
   const previews = [];
   let totalChanges = 0;
   for (const note of affectedNotes) {
-    const fullPath = path27.join(vaultPath2, note.path);
+    const fullPath = path28.join(vaultPath2, note.path);
     let fileContent;
     try {
       fileContent = await fs28.readFile(fullPath, "utf-8");
@@ -14812,21 +15291,26 @@ function registerWikilinkFeedbackTools(server2, getStateDb) {
     "wikilink_feedback",
     {
       title: "Wikilink Feedback",
-      description: 'Report and query wikilink accuracy feedback. Modes: "report" (record feedback), "list" (view recent feedback), "stats" (entity accuracy statistics), "dashboard" (full feedback loop data for visualization). Entities with >=30% false positive rate (and >=10 samples) are auto-suppressed from future wikilink application.',
+      description: 'Report and query wikilink accuracy feedback. Modes: "report" (record feedback), "list" (view recent feedback), "stats" (entity accuracy statistics), "dashboard" (full feedback loop data), "entity_timeline" (score history for an entity), "layer_timeseries" (per-layer contribution over time), "snapshot_diff" (compare two graph snapshots).',
       inputSchema: {
-        mode: z21.enum(["report", "list", "stats", "dashboard"]).describe("Operation mode"),
-        entity: z21.string().optional().describe("Entity name (required for report mode, optional filter for list/stats)"),
+        mode: z21.enum(["report", "list", "stats", "dashboard", "entity_timeline", "layer_timeseries", "snapshot_diff"]).describe("Operation mode"),
+        entity: z21.string().optional().describe("Entity name (required for report and entity_timeline modes, optional filter for list/stats)"),
         note_path: z21.string().optional().describe("Note path where the wikilink appeared (for report mode)"),
         context: z21.string().optional().describe("Surrounding text context (for report mode)"),
         correct: z21.boolean().optional().describe("Whether the wikilink was correct (for report mode)"),
-        limit: z21.number().optional().describe("Max entries to return for list mode (default: 20)")
+        limit: z21.number().optional().describe("Max entries to return (default: 20 for list, 100 for entity_timeline)"),
+        days_back: z21.number().optional().describe("Days to look back (default: 30)"),
+        granularity: z21.enum(["day", "week"]).optional().describe("Time bucket granularity for layer_timeseries (default: day)"),
+        timestamp_before: z21.number().optional().describe("Earlier timestamp for snapshot_diff"),
+        timestamp_after: z21.number().optional().describe("Later timestamp for snapshot_diff")
       }
     },
-    async ({ mode, entity, note_path, context, correct, limit }) => {
+    async ({ mode, entity, note_path, context, correct, limit, days_back, granularity, timestamp_before, timestamp_after }) => {
       const stateDb2 = getStateDb();
       if (!stateDb2) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available \u2014 database not initialized yet" }) }],
+          isError: true
         };
       }
       let result;
@@ -14837,7 +15321,15 @@ function registerWikilinkFeedbackTools(server2, getStateDb) {
               content: [{ type: "text", text: JSON.stringify({ error: "entity and correct are required for report mode" }) }]
             };
           }
-          recordFeedback(stateDb2, entity, context || "", note_path || "", correct);
+          try {
+            recordFeedback(stateDb2, entity, context || "", note_path || "", correct);
+          } catch (e) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({
+                error: `Failed to record feedback: ${e instanceof Error ? e.message : String(e)}`
+              }) }]
+            };
+          }
           const suppressionUpdated = updateSuppressionList(stateDb2) > 0;
           result = {
             mode: "report",
@@ -14870,7 +15362,7 @@ function registerWikilinkFeedbackTools(server2, getStateDb) {
           break;
         }
         case "dashboard": {
-          const dashboard = getDashboardData(stateDb2);
+          const dashboard = getExtendedDashboardData(stateDb2);
           result = {
             mode: "dashboard",
             dashboard,
@@ -14879,6 +15371,44 @@ function registerWikilinkFeedbackTools(server2, getStateDb) {
           };
           break;
         }
+        case "entity_timeline": {
+          if (!entity) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "entity is required for entity_timeline mode" }) }]
+            };
+          }
+          const timeline = getEntityScoreTimeline(stateDb2, entity, days_back ?? 30, limit ?? 100);
+          result = {
+            mode: "entity_timeline",
+            entity,
+            timeline,
+            count: timeline.length
+          };
+          break;
+        }
+        case "layer_timeseries": {
+          const timeseries = getLayerContributionTimeseries(stateDb2, granularity ?? "day", days_back ?? 30);
+          result = {
+            mode: "layer_timeseries",
+            granularity: granularity ?? "day",
+            timeseries,
+            buckets: timeseries.length
+          };
+          break;
+        }
+        case "snapshot_diff": {
+          if (!timestamp_before || !timestamp_after) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "timestamp_before and timestamp_after are required for snapshot_diff mode" }) }]
+            };
+          }
+          const diff = compareGraphSnapshots(stateDb2, timestamp_before, timestamp_after);
+          result = {
+            mode: "snapshot_diff",
+            diff
+          };
+          break;
+        }
       }
       return {
         content: [
@@ -15264,8 +15794,8 @@ function getNoteAccessFrequency(stateDb2, daysBack = 30) {
       }
     }
   }
-  return Array.from(noteMap.entries()).map(([path30, stats]) => ({
-    path: path30,
+  return Array.from(noteMap.entries()).map(([path31, stats]) => ({
+    path: path31,
     access_count: stats.access_count,
     last_accessed: stats.last_accessed,
     tools_used: Array.from(stats.tools)
@@ -15418,7 +15948,7 @@ import { z as z25 } from "zod";
 
 // src/core/read/similarity.ts
 import * as fs29 from "fs";
-import * as path28 from "path";
+import * as path29 from "path";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
   "be",
@@ -15555,7 +16085,7 @@ function extractKeyTerms(content, maxTerms = 15) {
 }
 function findSimilarNotes(db4, vaultPath2, index, sourcePath, options = {}) {
   const limit = options.limit ?? 10;
-  const absPath = path28.join(vaultPath2, sourcePath);
+  const absPath = path29.join(vaultPath2, sourcePath);
   let content;
   try {
     content = fs29.readFileSync(absPath, "utf-8");
@@ -15683,7 +16213,7 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
         exclude_linked: z25.boolean().optional().describe("Exclude notes already linked to/from the source note (default: true)")
       }
     },
-    async ({ path: path30, limit, exclude_linked }) => {
+    async ({ path: path31, limit, exclude_linked }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const stateDb2 = getStateDb();
@@ -15692,10 +16222,10 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
           content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
         };
       }
-      if (!index.notes.has(path30)) {
+      if (!index.notes.has(path31)) {
         return {
           content: [{ type: "text", text: JSON.stringify({
-            error: `Note not found: ${path30}`,
+            error: `Note not found: ${path31}`,
             hint: "Use the full relative path including .md extension"
           }, null, 2) }]
         };
@@ -15706,12 +16236,12 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
       };
       const useHybrid = hasEmbeddingsIndex();
       const method = useHybrid ? "hybrid" : "bm25";
-      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path30, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path30, opts);
+      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path31, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path31, opts);
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
-            source: path30,
+            source: path31,
             method,
             exclude_linked: exclude_linked ?? true,
             count: results.length,
@@ -15949,6 +16479,7 @@ function registerMergeTools2(server2, getStateDb) {
 
 // src/index.ts
 import * as fs30 from "node:fs/promises";
+import { createHash as createHash2 } from "node:crypto";
 
 // src/resources/vault.ts
 function registerVaultResources(server2, getIndex) {
@@ -16054,7 +16585,16 @@ function registerVaultResources(server2, getIndex) {
 }
 
 // src/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname4(__filename);
+var pkg = JSON.parse(readFileSync4(join16(__dirname, "../package.json"), "utf-8"));
 var vaultPath = process.env.PROJECT_PATH || process.env.VAULT_PATH || findVaultRoot();
+var resolvedVaultPath;
+try {
+  resolvedVaultPath = realpathSync(vaultPath).replace(/\\/g, "/");
+} catch {
+  resolvedVaultPath = vaultPath.replace(/\\/g, "/");
+}
 var vaultIndex;
 var flywheelConfig = {};
 var stateDb = null;
@@ -16208,7 +16748,7 @@ var TOOL_CATEGORY = {
 };
 var server = new McpServer({
   name: "flywheel-memory",
-  version: "2.0.0"
+  version: pkg.version
 });
 var _registeredCount = 0;
 var _skippedCount = 0;
@@ -16337,7 +16877,7 @@ registerMergeTools2(server, () => stateDb);
 registerVaultResources(server, () => vaultIndex ?? null);
 serverLog("server", `Registered ${_registeredCount} tools, skipped ${_skippedCount}`);
 async function main() {
-  serverLog("server", "Starting Flywheel Memory server...");
+  serverLog("server", `Starting Flywheel Memory v${pkg.version}...`);
   serverLog("server", `Vault: ${vaultPath}`);
   const startTime = Date.now();
   try {
@@ -16349,6 +16889,7 @@ async function main() {
     serverLog("statedb", "Injected FTS5, embeddings, task cache handles");
     loadEntityEmbeddingsToMemory();
     setWriteStateDb(stateDb);
+    setRecencyStateDb(stateDb);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     serverLog("statedb", `StateDb initialization failed: ${msg}`, "error");
@@ -16549,21 +17090,105 @@ async function runPostIndexWork(index) {
   }
   if (process.env.FLYWHEEL_WATCH !== "false") {
     const config = parseWatcherConfig();
+    const lastContentHashes = /* @__PURE__ */ new Map();
     serverLog("watcher", `File watcher enabled (debounce: ${config.debounceMs}ms)`);
     const watcher = createVaultWatcher({
       vaultPath,
       config,
       onBatch: async (batch) => {
-        serverLog("watcher", `Processing ${batch.events.length} file changes`);
+        const vaultPrefixes = /* @__PURE__ */ new Set([
+          vaultPath.replace(/\\/g, "/"),
+          resolvedVaultPath
+        ]);
+        for (const event of batch.events) {
+          const normalized = event.path.replace(/\\/g, "/");
+          let matched = false;
+          for (const prefix of vaultPrefixes) {
+            if (normalized.startsWith(prefix + "/")) {
+              event.path = normalized.slice(prefix.length + 1);
+              matched = true;
+              break;
+            }
+          }
+          if (!matched) {
+            try {
+              const resolved = realpathSync(event.path).replace(/\\/g, "/");
+              for (const prefix of vaultPrefixes) {
+                if (resolved.startsWith(prefix + "/")) {
+                  event.path = resolved.slice(prefix.length + 1);
+                  matched = true;
+                  break;
+                }
+              }
+            } catch {
+              try {
+                const dir = path30.dirname(event.path);
+                const base = path30.basename(event.path);
+                const resolvedDir = realpathSync(dir).replace(/\\/g, "/");
+                for (const prefix of vaultPrefixes) {
+                  if (resolvedDir.startsWith(prefix + "/") || resolvedDir === prefix) {
+                    const relDir = resolvedDir === prefix ? "" : resolvedDir.slice(prefix.length + 1);
+                    event.path = relDir ? `${relDir}/${base}` : base;
+                    matched = true;
+                    break;
+                  }
+                }
+              } catch {
+              }
+            }
+          }
+        }
+        const filteredEvents = [];
+        for (const event of batch.events) {
+          if (event.type === "delete") {
+            filteredEvents.push(event);
+            lastContentHashes.delete(event.path);
+            continue;
+          }
+          try {
+            const content = await fs30.readFile(path30.join(vaultPath, event.path), "utf-8");
+            const hash = createHash2("md5").update(content).digest("hex");
+            if (lastContentHashes.get(event.path) === hash) {
+              serverLog("watcher", `Hash unchanged, skipping: ${event.path}`);
+              continue;
+            }
+            lastContentHashes.set(event.path, hash);
+            filteredEvents.push(event);
+          } catch {
+            filteredEvents.push(event);
+          }
+        }
+        if (filteredEvents.length === 0) {
+          serverLog("watcher", "All files unchanged (hash gate), skipping batch");
+          return;
+        }
+        serverLog("watcher", `Processing ${filteredEvents.length} file changes`);
         const batchStart = Date.now();
-        const changedPaths = batch.events.map((e) => e.path);
+        const changedPaths = filteredEvents.map((e) => e.path);
         const tracker = createStepTracker();
         try {
-          tracker.start("index_rebuild", { files_changed: batch.events.length, changed_paths: changedPaths });
-          vaultIndex = await buildVaultIndex(vaultPath);
+          tracker.start("index_rebuild", { files_changed: filteredEvents.length, changed_paths: changedPaths });
+          if (!vaultIndex) {
+            vaultIndex = await buildVaultIndex(vaultPath);
+            serverLog("watcher", `Index rebuilt (full): ${vaultIndex.notes.size} notes, ${vaultIndex.entities.size} entities`);
+          } else {
+            const absoluteBatch = {
+              ...batch,
+              events: filteredEvents.map((e) => ({
+                ...e,
+                path: path30.join(vaultPath, e.path)
+              }))
+            };
+            const batchResult = await processBatch(vaultIndex, vaultPath, absoluteBatch);
+            serverLog("watcher", `Incremental: ${batchResult.successful}/${batchResult.total} files in ${batchResult.durationMs}ms`);
+          }
           setIndexState("ready");
           tracker.end({ note_count: vaultIndex.notes.size, entity_count: vaultIndex.entities.size, tag_count: vaultIndex.tags.size });
-          serverLog("watcher", `Index rebuilt: ${vaultIndex.notes.size} notes, ${vaultIndex.entities.size} entities`);
+          const hubBefore = /* @__PURE__ */ new Map();
+          if (stateDb) {
+            const rows = stateDb.db.prepare("SELECT name, hub_score FROM entities").all();
+            for (const r of rows) hubBefore.set(r.name, r.hub_score);
+          }
           const entitiesBefore = stateDb ? getAllEntitiesFromDb3(stateDb) : [];
           tracker.start("entity_scan", { note_count: vaultIndex.notes.size });
           await updateEntitiesInStateDb();
@@ -16571,11 +17196,6 @@ async function runPostIndexWork(index) {
           const entityDiff = computeEntityDiff(entitiesBefore, entitiesAfter);
           tracker.end({ entity_count: entitiesAfter.length, ...entityDiff });
           serverLog("watcher", `Entity scan: ${entitiesAfter.length} entities`);
-          const hubBefore = /* @__PURE__ */ new Map();
-          if (stateDb) {
-            const rows = stateDb.db.prepare("SELECT name, hub_score FROM entities").all();
-            for (const r of rows) hubBefore.set(r.name, r.hub_score);
-          }
           tracker.start("hub_scores", { entity_count: entitiesAfter.length });
           const hubUpdated = await exportHubScores(vaultIndex, stateDb);
           const hubDiffs = [];
@@ -16588,17 +17208,35 @@ async function runPostIndexWork(index) {
           }
           tracker.end({ updated: hubUpdated ?? 0, diffs: hubDiffs.slice(0, 10) });
           serverLog("watcher", `Hub scores: ${hubUpdated ?? 0} updated`);
+          tracker.start("recency", { entity_count: entitiesAfter.length });
+          try {
+            const cachedRecency = loadRecencyFromStateDb();
+            const cacheAgeMs = cachedRecency ? Date.now() - (cachedRecency.lastUpdated ?? 0) : Infinity;
+            if (cacheAgeMs >= 60 * 60 * 1e3) {
+              const entities = entitiesAfter.map((e) => ({ name: e.name, path: e.path, aliases: e.aliases }));
+              const recencyIndex2 = await buildRecencyIndex(vaultPath, entities);
+              saveRecencyToStateDb(recencyIndex2);
+              tracker.end({ rebuilt: true, entities: recencyIndex2.lastMentioned.size });
+              serverLog("watcher", `Recency: rebuilt ${recencyIndex2.lastMentioned.size} entities`);
+            } else {
+              tracker.end({ rebuilt: false, cached_age_ms: cacheAgeMs });
+              serverLog("watcher", `Recency: cache valid (${Math.round(cacheAgeMs / 1e3)}s old)`);
+            }
+          } catch (e) {
+            tracker.end({ error: String(e) });
+            serverLog("watcher", `Recency: failed: ${e}`);
+          }
           if (hasEmbeddingsIndex()) {
-            tracker.start("note_embeddings", { files: batch.events.length });
+            tracker.start("note_embeddings", { files: filteredEvents.length });
             let embUpdated = 0;
             let embRemoved = 0;
-            for (const event of batch.events) {
+            for (const event of filteredEvents) {
               try {
                 if (event.type === "delete") {
                   removeEmbedding(event.path);
                   embRemoved++;
                 } else if (event.path.endsWith(".md")) {
-                  const absPath = path29.join(vaultPath, event.path);
+                  const absPath = path30.join(vaultPath, event.path);
                   await updateEmbedding(event.path, absPath);
                   embUpdated++;
                 }
@@ -16611,12 +17249,12 @@ async function runPostIndexWork(index) {
             tracker.skip("note_embeddings", "not built");
           }
           if (hasEntityEmbeddingsIndex() && stateDb) {
-            tracker.start("entity_embeddings", { files: batch.events.length });
+            tracker.start("entity_embeddings", { files: filteredEvents.length });
             let entEmbUpdated = 0;
             const entEmbNames = [];
             try {
               const allEntities = getAllEntitiesFromDb3(stateDb);
-              for (const event of batch.events) {
+              for (const event of filteredEvents) {
                 if (event.type === "delete" || !event.path.endsWith(".md")) continue;
                 const matching = allEntities.filter((e) => e.path === event.path);
                 for (const entity of matching) {
@@ -16650,10 +17288,10 @@ async function runPostIndexWork(index) {
           } else {
             tracker.skip("index_cache", "no stateDb");
           }
-          tracker.start("task_cache", { files: batch.events.length });
+          tracker.start("task_cache", { files: filteredEvents.length });
           let taskUpdated = 0;
           let taskRemoved = 0;
-          for (const event of batch.events) {
+          for (const event of filteredEvents) {
             try {
               if (event.type === "delete") {
                 removeTaskCacheForFile(event.path);
@@ -16667,10 +17305,42 @@ async function runPostIndexWork(index) {
           }
           tracker.end({ updated: taskUpdated, removed: taskRemoved });
           serverLog("watcher", `Task cache: ${taskUpdated} updated, ${taskRemoved} removed`);
-          tracker.start("wikilink_check", { files: batch.events.length });
+          tracker.start("forward_links", { files: filteredEvents.length });
+          const forwardLinkResults = [];
+          let totalResolved = 0;
+          let totalDead = 0;
+          for (const event of filteredEvents) {
+            if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+            try {
+              const links = getForwardLinksForNote(vaultIndex, event.path);
+              const resolved = [];
+              const dead = [];
+              const seen = /* @__PURE__ */ new Set();
+              for (const link of links) {
+                const name = link.target;
+                if (seen.has(name.toLowerCase())) continue;
+                seen.add(name.toLowerCase());
+                if (link.exists) resolved.push(name);
+                else dead.push(name);
+              }
+              if (resolved.length > 0 || dead.length > 0) {
+                forwardLinkResults.push({ file: event.path, resolved, dead });
+              }
+              totalResolved += resolved.length;
+              totalDead += dead.length;
+            } catch {
+            }
+          }
+          tracker.end({
+            total_resolved: totalResolved,
+            total_dead: totalDead,
+            links: forwardLinkResults
+          });
+          serverLog("watcher", `Forward links: ${totalResolved} resolved, ${totalDead} dead`);
+          tracker.start("wikilink_check", { files: filteredEvents.length });
           const trackedLinks = [];
           if (stateDb) {
-            for (const event of batch.events) {
+            for (const event of filteredEvents) {
               if (event.type === "delete" || !event.path.endsWith(".md")) continue;
               try {
                 const apps = getTrackedApplications(stateDb, event.path);
@@ -16681,13 +17351,13 @@ async function runPostIndexWork(index) {
           }
           tracker.end({ tracked: trackedLinks });
           serverLog("watcher", `Wikilink check: ${trackedLinks.reduce((s, t) => s + t.entities.length, 0)} tracked links in ${trackedLinks.length} files`);
-          tracker.start("implicit_feedback", { files: batch.events.length });
+          tracker.start("implicit_feedback", { files: filteredEvents.length });
           const feedbackResults = [];
           if (stateDb) {
-            for (const event of batch.events) {
+            for (const event of filteredEvents) {
               if (event.type === "delete" || !event.path.endsWith(".md")) continue;
               try {
-                const content = await fs30.readFile(path29.join(vaultPath, event.path), "utf-8");
+                const content = await fs30.readFile(path30.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 {
@@ -16704,12 +17374,12 @@ async function runPostIndexWork(index) {
               trigger: "watcher",
               duration_ms: duration,
               note_count: vaultIndex.notes.size,
-              files_changed: batch.events.length,
+              files_changed: filteredEvents.length,
               changed_paths: changedPaths,
               steps: tracker.steps
             });
           }
-          serverLog("watcher", `Batch complete: ${batch.events.length} files, ${duration}ms, ${tracker.steps.length} steps`);
+          serverLog("watcher", `Batch complete: ${filteredEvents.length} files, ${duration}ms, ${tracker.steps.length} steps`);
         } catch (err) {
           setIndexState("error");
           setIndexError(err instanceof Error ? err : new Error(String(err)));
@@ -16719,7 +17389,7 @@ async function runPostIndexWork(index) {
               trigger: "watcher",
               duration_ms: duration,
               success: false,
-              files_changed: batch.events.length,
+              files_changed: filteredEvents.length,
               changed_paths: changedPaths,
               error: err instanceof Error ? err.message : String(err),
               steps: tracker.steps