@velvetmonkey/flywheel-memory 2.0.35 → 2.0.37

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 path20 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 = path20.resolve(vaultPath2);
+  const resolvedNote = path20.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 = path20.resolve(vaultPath2);
+  const resolvedNote = path20.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 = path20.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 = path20.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 = path20.dirname(fullPath);
       try {
         await fs18.access(parentDir);
         const realParentPath = await fs18.realpath(parentDir);
@@ -475,8 +475,8 @@ 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 [rawContent, stat3] = await Promise.all([
+  const fullPath = path20.join(vaultPath2, notePath);
+  const [rawContent, stat4] = await Promise.all([
     fs18.readFile(fullPath, "utf-8"),
     fs18.stat(fullPath)
   ]);
@@ -489,7 +489,7 @@ async function readVaultFile(vaultPath2, notePath) {
     frontmatter,
     rawContent,
     lineEnding,
-    mtimeMs: stat3.mtimeMs
+    mtimeMs: stat4.mtimeMs
   };
 }
 function deepCloneFrontmatter(obj) {
@@ -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 = path20.join(vaultPath2, notePath);
   let output = matter5.stringify(content, frontmatter);
   output = normalizeTrailingNewline(output);
   output = convertLineEndings(output, lineEnding);
@@ -836,8 +836,8 @@ function createContext(variables = {}) {
     steps: {}
   };
 }
-function resolvePath(obj, path30) {
-  const parts = path30.split(".");
+function resolvePath(obj, path32) {
+  const parts = path32.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === void 0 || current === null) {
@@ -1279,7 +1279,7 @@ __export(conditions_exports, {
   shouldStepExecute: () => shouldStepExecute
 });
 import fs25 from "fs/promises";
-import path24 from "path";
+import path26 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;
@@ -1332,7 +1332,7 @@ async function evaluateCondition(condition, vaultPath2, context) {
   }
 }
 async function evaluateFileExists(vaultPath2, notePath, expectExists) {
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs25.access(fullPath);
     return {
@@ -1347,7 +1347,7 @@ async function evaluateFileExists(vaultPath2, notePath, expectExists) {
   }
 }
 async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectExists) {
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs25.access(fullPath);
   } catch {
@@ -1378,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 = path26.join(vaultPath2, notePath);
   try {
     await fs25.access(fullPath);
   } catch {
@@ -1409,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 = path26.join(vaultPath2, notePath);
   try {
     await fs25.access(fullPath);
   } catch {
@@ -1552,7 +1552,7 @@ var init_taskHelpers = __esm({
 });
 
 // src/index.ts
-import * as path29 from "path";
+import * as path31 from "path";
 import { readFileSync as readFileSync4, realpathSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname as dirname4, join as join16 } from "path";
@@ -2216,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(path32) {
+  return path32.toLowerCase().replace(/\.md$/, "");
 }
 async function buildVaultIndex(vaultPath2, options = {}) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
@@ -2386,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, path32] of index.entities) {
     const lenDiff = Math.abs(entity.length - normalizedLen);
     if (lenDiff > maxDist) {
       continue;
@@ -2394,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: path32, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -2667,6 +2667,9 @@ function findVaultRoot(startPath) {
 // src/core/read/watch/index.ts
 import chokidar from "chokidar";
 
+// src/core/read/watch/eventQueue.ts
+import * as path6 from "path";
+
 // src/core/read/watch/pathFilter.ts
 import path5 from "path";
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
@@ -2780,8 +2783,8 @@ function normalizePath(filePath) {
   return normalized;
 }
 function getRelativePath(vaultPath2, filePath) {
-  const relative = path5.relative(vaultPath2, filePath);
-  return normalizePath(relative);
+  const relative2 = path5.relative(vaultPath2, filePath);
+  return normalizePath(relative2);
 }
 function shouldWatch(filePath, vaultPath2) {
   const normalized = normalizePath(filePath);
@@ -2851,6 +2854,52 @@ function coalesceEvents(events) {
   }
   return null;
 }
+var RENAME_PROXIMITY_MS = 5e3;
+function fileStem(p) {
+  return path6.basename(p).replace(/\.[^.]+$/, "");
+}
+function detectRenames(events) {
+  const deletes = events.filter((e) => e.type === "delete");
+  const upserts = events.filter((e) => e.type === "upsert");
+  const others = events.filter((e) => e.type !== "delete" && e.type !== "upsert");
+  const usedDeletes = /* @__PURE__ */ new Set();
+  const usedUpserts = /* @__PURE__ */ new Set();
+  const renames = [];
+  for (const del of deletes) {
+    const stem2 = fileStem(del.path);
+    const delTimestamp = del.originalEvents.length > 0 ? Math.max(...del.originalEvents.map((e) => e.timestamp)) : 0;
+    const candidates = upserts.filter(
+      (u) => !usedUpserts.has(u.path) && fileStem(u.path) === stem2
+    );
+    if (candidates.length === 0) continue;
+    let bestCandidate = null;
+    let bestDelta = Infinity;
+    for (const candidate of candidates) {
+      const addTimestamp = candidate.originalEvents.length > 0 ? Math.max(...candidate.originalEvents.map((e) => e.timestamp)) : 0;
+      const delta = Math.abs(addTimestamp - delTimestamp);
+      if (delta <= RENAME_PROXIMITY_MS && delta < bestDelta) {
+        bestDelta = delta;
+        bestCandidate = candidate;
+      }
+    }
+    if (bestCandidate) {
+      usedDeletes.add(del.path);
+      usedUpserts.add(bestCandidate.path);
+      renames.push({
+        type: "rename",
+        oldPath: del.path,
+        newPath: bestCandidate.path,
+        timestamp: Date.now()
+      });
+    }
+  }
+  const nonRenameEvents = [
+    ...deletes.filter((e) => !usedDeletes.has(e.path)),
+    ...upserts.filter((e) => !usedUpserts.has(e.path)),
+    ...others
+  ];
+  return { nonRenameEvents, renames };
+}
 var EventQueue = class {
   pending = /* @__PURE__ */ new Map();
   config;
@@ -2864,30 +2913,30 @@ var EventQueue = class {
    * Add a new event to the queue
    */
   push(type, rawPath) {
-    const path30 = normalizePath(rawPath);
+    const path32 = normalizePath(rawPath);
     const now = Date.now();
     const event = {
       type,
-      path: path30,
+      path: path32,
       timestamp: now
     };
-    let pending = this.pending.get(path30);
+    let pending = this.pending.get(path32);
     if (!pending) {
       pending = {
         events: [],
         timer: null,
         lastEvent: now
       };
-      this.pending.set(path30, pending);
+      this.pending.set(path32, 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 ${path32}, pending=${this.pending.size}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
     }
     pending.timer = setTimeout(() => {
-      this.flushPath(path30);
+      this.flushPath(path32);
     }, this.config.debounceMs);
     if (this.pending.size >= this.config.batchSize) {
       this.flush();
@@ -2908,10 +2957,10 @@ var EventQueue = class {
   /**
    * Flush a single path's events
    */
-  flushPath(path30) {
-    const pending = this.pending.get(path30);
+  flushPath(path32) {
+    const pending = this.pending.get(path32);
     if (!pending || pending.events.length === 0) return;
-    console.error(`[flywheel] QUEUE: flushing ${path30}, events=${pending.events.length}`);
+    console.error(`[flywheel] QUEUE: flushing ${path32}, events=${pending.events.length}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -2920,15 +2969,16 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path30,
+        path: path32,
         originalEvents: [...pending.events]
       };
       this.onBatch({
         events: [coalesced],
+        renames: [],
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path30);
+    this.pending.delete(path32);
   }
   /**
    * Flush all pending events
@@ -2940,7 +2990,7 @@ var EventQueue = class {
     }
     if (this.pending.size === 0) return;
     const events = [];
-    for (const [path30, pending] of this.pending) {
+    for (const [path32, pending] of this.pending) {
       if (pending.timer) {
         clearTimeout(pending.timer);
       }
@@ -2948,15 +2998,17 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path30,
+          path: path32,
           originalEvents: [...pending.events]
         });
       }
     }
     this.pending.clear();
     if (events.length > 0) {
+      const { nonRenameEvents, renames } = detectRenames(events);
       this.onBatch({
-        events,
+        events: nonRenameEvents,
+        renames,
         timestamp: Date.now()
       });
     }
@@ -3023,6 +3075,208 @@ function parseWatcherConfig() {
   };
 }
 
+// src/core/read/watch/incrementalIndex.ts
+import path7 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 = path7.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;
@@ -3097,31 +3351,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", (path32) => {
+        console.error(`[flywheel] RAW EVENT: add ${path32}`);
+        if (shouldWatch(path32, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: add ${path32}`);
+          eventQueue.push("add", path32);
         } else {
-          console.error(`[flywheel] FILTERED: add ${path30}`);
+          console.error(`[flywheel] FILTERED: add ${path32}`);
         }
       });
-      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", (path32) => {
+        console.error(`[flywheel] RAW EVENT: change ${path32}`);
+        if (shouldWatch(path32, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: change ${path32}`);
+          eventQueue.push("change", path32);
         } else {
-          console.error(`[flywheel] FILTERED: change ${path30}`);
+          console.error(`[flywheel] FILTERED: change ${path32}`);
         }
       });
-      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", (path32) => {
+        console.error(`[flywheel] RAW EVENT: unlink ${path32}`);
+        if (shouldWatch(path32, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: unlink ${path32}`);
+          eventQueue.push("unlink", path32);
         } else {
-          console.error(`[flywheel] FILTERED: unlink ${path30}`);
+          console.error(`[flywheel] FILTERED: unlink ${path32}`);
         }
       });
       watcher.on("ready", () => {
@@ -3325,13 +3579,13 @@ function updateSuppressionList(stateDb2) {
     "DELETE FROM wikilink_suppressions WHERE entity = ?"
   );
   const transaction = stateDb2.db.transaction(() => {
-    for (const stat3 of stats) {
-      const fpRate = stat3.false_positives / stat3.total;
+    for (const stat4 of stats) {
+      const fpRate = stat4.false_positives / stat4.total;
       if (fpRate >= SUPPRESSION_THRESHOLD) {
-        upsert.run(stat3.entity, fpRate);
+        upsert.run(stat4.entity, fpRate);
         updated++;
       } else {
-        remove.run(stat3.entity);
+        remove.run(stat4.entity);
       }
     }
   });
@@ -3458,6 +3712,46 @@ function getTrackedApplications(stateDb2, notePath) {
   ).all(notePath);
   return rows.map((r) => r.entity);
 }
+function getStoredNoteLinks(stateDb2, notePath) {
+  const rows = stateDb2.db.prepare(
+    "SELECT target FROM note_links WHERE note_path = ?"
+  ).all(notePath);
+  return new Set(rows.map((r) => r.target));
+}
+function updateStoredNoteLinks(stateDb2, notePath, currentLinks) {
+  const del = stateDb2.db.prepare("DELETE FROM note_links WHERE note_path = ?");
+  const ins = stateDb2.db.prepare("INSERT INTO note_links (note_path, target) VALUES (?, ?)");
+  const tx = stateDb2.db.transaction(() => {
+    del.run(notePath);
+    for (const target of currentLinks) {
+      ins.run(notePath, target);
+    }
+  });
+  tx();
+}
+function diffNoteLinks(previous, current) {
+  return {
+    added: [...current].filter((l) => !previous.has(l)),
+    removed: [...previous].filter((l) => !current.has(l))
+  };
+}
+function getStoredNoteTags(stateDb2, notePath) {
+  const rows = stateDb2.db.prepare(
+    "SELECT tag FROM note_tags WHERE note_path = ?"
+  ).all(notePath);
+  return new Set(rows.map((r) => r.tag));
+}
+function updateStoredNoteTags(stateDb2, notePath, currentTags) {
+  const del = stateDb2.db.prepare("DELETE FROM note_tags WHERE note_path = ?");
+  const ins = stateDb2.db.prepare("INSERT INTO note_tags (note_path, tag) VALUES (?, ?)");
+  const tx = stateDb2.db.transaction(() => {
+    del.run(notePath);
+    for (const tag of currentTags) {
+      ins.run(notePath, tag);
+    }
+  });
+  tx();
+}
 function processImplicitFeedback(stateDb2, notePath, currentContent) {
   const tracked = getTrackedApplications(stateDb2, notePath);
   if (tracked.length === 0) return [];
@@ -3725,7 +4019,7 @@ function getExtendedDashboardData(stateDb2) {
 
 // src/core/write/git.ts
 import { simpleGit, CheckRepoActions } from "simple-git";
-import path6 from "path";
+import path8 from "path";
 import fs6 from "fs/promises";
 import {
   setWriteState,
@@ -3779,10 +4073,10 @@ function clearLastMutationCommit() {
   }
 }
 async function checkGitLock(vaultPath2) {
-  const lockPath = path6.join(vaultPath2, ".git/index.lock");
+  const lockPath = path8.join(vaultPath2, ".git/index.lock");
   try {
-    const stat3 = await fs6.stat(lockPath);
-    const ageMs = Date.now() - stat3.mtimeMs;
+    const stat4 = await fs6.stat(lockPath);
+    const ageMs = Date.now() - stat4.mtimeMs;
     return {
       locked: true,
       stale: ageMs > STALE_LOCK_THRESHOLD_MS,
@@ -3802,10 +4096,10 @@ async function isGitRepo(vaultPath2) {
   }
 }
 async function checkLockFile(vaultPath2) {
-  const lockPath = path6.join(vaultPath2, ".git/index.lock");
+  const lockPath = path8.join(vaultPath2, ".git/index.lock");
   try {
-    const stat3 = await fs6.stat(lockPath);
-    const ageMs = Date.now() - stat3.mtimeMs;
+    const stat4 = await fs6.stat(lockPath);
+    const ageMs = Date.now() - stat4.mtimeMs;
     return { stale: ageMs > STALE_LOCK_THRESHOLD_MS, ageMs };
   } catch {
     return null;
@@ -3852,7 +4146,7 @@ async function commitChange(vaultPath2, filePath, messagePrefix, retryConfig = D
         }
       }
       await git.add(filePath);
-      const fileName = path6.basename(filePath);
+      const fileName = path8.basename(filePath);
       const commitMessage = `${messagePrefix} Update ${fileName}`;
       const result = await git.commit(commitMessage);
       if (result.commit) {
@@ -4046,7 +4340,7 @@ function setHintsStateDb(stateDb2) {
 
 // src/core/shared/recency.ts
 import { readdir, readFile, stat } from "fs/promises";
-import path7 from "path";
+import path9 from "path";
 import {
   getEntityName,
   recordEntityMention,
@@ -4068,9 +4362,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 = path9.join(dir, entry.name);
+      const relativePath = path9.relative(baseDir, fullPath);
+      const topFolder = relativePath.split(path9.sep)[0];
       if (EXCLUDED_FOLDERS.has(topFolder)) {
         continue;
       }
@@ -4950,7 +5244,7 @@ function tokenize(text) {
 
 // src/core/shared/cooccurrence.ts
 import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
-import path8 from "path";
+import path10 from "path";
 var DEFAULT_MIN_COOCCURRENCE = 2;
 var EXCLUDED_FOLDERS2 = /* @__PURE__ */ new Set([
   "templates",
@@ -4984,9 +5278,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 = path10.join(dir, entry.name);
+      const relativePath = path10.relative(baseDir, fullPath);
+      const topFolder = relativePath.split(path10.sep)[0];
       if (EXCLUDED_FOLDERS2.has(topFolder)) {
         continue;
       }
@@ -5227,7 +5521,7 @@ function sortEntitiesByPriority(entities, notePath) {
     return priorityB - priorityA;
   });
 }
-function processWikilinks(content, notePath) {
+function processWikilinks(content, notePath, existingContent) {
   if (!isEntityIndexReady() || !entityIndex) {
     console.error("[Flywheel:DEBUG] Entity index not ready, entities:", entityIndex?._metadata?.total_entities ?? 0);
     return {
@@ -5249,9 +5543,16 @@ function processWikilinks(content, notePath) {
   const resolved = resolveAliasWikilinks(content, sortedEntities, {
     caseInsensitive: true
   });
+  const step1LinkedEntities = new Set(resolved.linkedEntities.map((e) => e.toLowerCase()));
+  if (existingContent) {
+    for (const match of existingContent.matchAll(/\[\[([^\]|]+?)(?:\|[^\]]+?)?\]\]/g)) {
+      step1LinkedEntities.add(match[1].toLowerCase());
+    }
+  }
   const result = applyWikilinks(resolved.content, sortedEntities, {
     firstOccurrenceOnly: true,
-    caseInsensitive: true
+    caseInsensitive: true,
+    alreadyLinked: step1LinkedEntities
   });
   const implicitEnabled = moduleConfig?.implicit_detection !== false;
   const validPatterns = new Set(ALL_IMPLICIT_PATTERNS);
@@ -5308,12 +5609,12 @@ function processWikilinks(content, notePath) {
     linkedEntities: [...resolved.linkedEntities, ...result.linkedEntities]
   };
 }
-function maybeApplyWikilinks(content, skipWikilinks, notePath) {
+function maybeApplyWikilinks(content, skipWikilinks, notePath, existingContent) {
   if (skipWikilinks) {
     return { content };
   }
   checkAndRefreshIfStale();
-  const result = processWikilinks(content, notePath);
+  const result = processWikilinks(content, notePath, existingContent);
   if (result.linksAdded > 0) {
     if (moduleStateDb4 && notePath) {
       trackWikilinkApplications(moduleStateDb4, notePath, result.linkedEntities);
@@ -6298,11 +6599,11 @@ function countFTS5Mentions(term) {
 }
 
 // src/core/read/taskCache.ts
-import * as path10 from "path";
+import * as path12 from "path";
 
 // src/tools/read/tasks.ts
 import * as fs8 from "fs";
-import * as path9 from "path";
+import * as path11 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/;
@@ -6371,7 +6672,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 = path11.join(vaultPath2, note.path);
     const tasks = await extractTasksFromNote(note.path, absolutePath);
     allTasks.push(...tasks);
   }
@@ -6415,7 +6716,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 = path11.join(vaultPath2, notePath);
   let tasks = await extractTasksFromNote(notePath, absolutePath);
   if (excludeTags.length > 0) {
     tasks = tasks.filter(
@@ -6507,7 +6808,7 @@ async function buildTaskCache(vaultPath2, index, excludeTags) {
     }
     const allRows = [];
     for (const notePath of notePaths) {
-      const absolutePath = path10.join(vaultPath2, notePath);
+      const absolutePath = path12.join(vaultPath2, notePath);
       const tasks = await extractTasksFromNote(notePath, absolutePath);
       for (const task of tasks) {
         if (excludeTags?.length && excludeTags.some((t) => task.tags.includes(t))) {
@@ -6549,7 +6850,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 = path12.join(vaultPath2, relativePath);
   const tasks = await extractTasksFromNote(relativePath, absolutePath);
   if (tasks.length > 0) {
     const insertStmt = db3.prepare(`
@@ -6689,7 +6990,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 path13 from "path";
 import { z } from "zod";
 
 // src/core/read/constants.ts
@@ -6973,7 +7274,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 = path13.join(vaultPath2, sourcePath);
     const content = await fs9.promises.readFile(fullPath, "utf-8");
     const allLines = content.split("\n");
     let fmLines = 0;
@@ -7287,14 +7588,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path30] of entities) {
+    for (const [name, path32] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path30;
+        return path32;
       }
     }
-    for (const [name, path30] of entities) {
+    for (const [name, path32] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path30;
+        return path32;
       }
     }
     return void 0;
@@ -8271,8 +8572,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(path32) {
+    const filename = path32.split("/").pop() || "";
     const nameWithoutExt = filename.replace(/\.md$/, "");
     const patterns = [
       /^\d{4}-\d{2}-\d{2}$/,
@@ -8287,7 +8588,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 = path32.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   server2.registerTool(
@@ -8695,7 +8996,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
 
 // src/tools/read/system.ts
 import * as fs11 from "fs";
-import * as path12 from "path";
+import * as path14 from "path";
 import { z as z5 } from "zod";
 import { scanVaultEntities as scanVaultEntities2, getEntityIndexFromDb as getEntityIndexFromDb2 } from "@velvetmonkey/vault-core";
 
@@ -8995,7 +9296,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
           continue;
         }
         try {
-          const fullPath = path12.join(vaultPath2, note.path);
+          const fullPath = path14.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++) {
@@ -9111,7 +9412,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
       let wordCount;
       if (include_word_count) {
         try {
-          const fullPath = path12.join(vaultPath2, resolvedPath);
+          const fullPath = path14.join(vaultPath2, resolvedPath);
           const content = await fs11.promises.readFile(fullPath, "utf-8");
           wordCount = content.split(/\s+/).filter((w) => w.length > 0).length;
         } catch {
@@ -9342,7 +9643,7 @@ import { z as z6 } from "zod";
 
 // src/tools/read/structure.ts
 import * as fs12 from "fs";
-import * as path13 from "path";
+import * as path15 from "path";
 var HEADING_REGEX2 = /^(#{1,6})\s+(.+)$/;
 function extractHeadings(content) {
   const lines = content.split("\n");
@@ -9396,7 +9697,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 = path15.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs12.promises.readFile(absolutePath, "utf-8");
@@ -9419,7 +9720,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 = path15.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs12.promises.readFile(absolutePath, "utf-8");
@@ -9461,7 +9762,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 = path15.join(vaultPath2, note.path);
     let content;
     try {
       content = await fs12.promises.readFile(absolutePath, "utf-8");
@@ -9495,18 +9796,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: path32, include_content }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path30, vaultPath2);
+      const result = await getNoteStructure(index, path32, 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: path32 }, 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, path32, section.heading.text, vaultPath2, true);
           if (sectionResult) {
             section.content = sectionResult.content;
           }
@@ -9528,15 +9829,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: path32, heading, include_subheadings }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path30, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path32, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path30,
+            path: path32,
             heading
           }, null, 2) }]
         };
@@ -9590,16 +9891,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: path32, 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 (path32) {
+        const result2 = await getTasksFromNote(index, path32, 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: path32 }, null, 2) }]
           };
         }
         let filtered = result2;
@@ -9609,7 +9910,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         const paged2 = filtered.slice(offset, offset + limit);
         return {
           content: [{ type: "text", text: JSON.stringify({
-            path: path30,
+            path: path32,
             total_count: filtered.length,
             returned_count: paged2.length,
             open: result2.filter((t) => t.status === "open").length,
@@ -9765,7 +10066,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 path16 from "path";
 import matter2 from "gray-matter";
 function getNotesInFolder(index, folder) {
   const notes = [];
@@ -9778,7 +10079,7 @@ function getNotesInFolder(index, folder) {
   return notes;
 }
 async function readFileContent(notePath, vaultPath2) {
-  const fullPath = path14.join(vaultPath2, notePath);
+  const fullPath = path16.join(vaultPath2, notePath);
   try {
     return await fs13.readFile(fullPath, "utf-8");
   } catch {
@@ -9786,7 +10087,7 @@ async function readFileContent(notePath, vaultPath2) {
   }
 }
 async function writeFileContent(notePath, vaultPath2, content) {
-  const fullPath = path14.join(vaultPath2, notePath);
+  const fullPath = path16.join(vaultPath2, notePath);
   try {
     await fs13.writeFile(fullPath, content, "utf-8");
     return true;
@@ -9967,7 +10268,7 @@ function registerMigrationTools(server2, getIndex, getVaultPath) {
 
 // src/tools/read/graphAnalysis.ts
 import fs14 from "node:fs";
-import path15 from "node:path";
+import path17 from "node:path";
 import { z as z8 } from "zod";
 
 // src/tools/read/schema.ts
@@ -10729,7 +11030,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(path17.join(vaultPath2, note.path), "utf-8");
               const body = content.replace(/^---[\s\S]*?---\n?/, "");
               wordCount = body.split(/\s+/).filter((w) => w.length > 0).length;
             } catch {
@@ -11309,12 +11610,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 path18 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 = path18.join(vaultPath2, notePath);
   try {
     return await fs15.readFile(fullPath, "utf-8");
   } catch {
@@ -11493,10 +11794,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 path19 from "path";
 import matter4 from "gray-matter";
 async function readFileContent3(notePath, vaultPath2) {
-  const fullPath = path17.join(vaultPath2, notePath);
+  const fullPath = path19.join(vaultPath2, notePath);
   try {
     return await fs16.readFile(fullPath, "utf-8");
   } catch {
@@ -11504,7 +11805,7 @@ async function readFileContent3(notePath, vaultPath2) {
   }
 }
 async function getFileStats(notePath, vaultPath2) {
-  const fullPath = path17.join(vaultPath2, notePath);
+  const fullPath = path19.join(vaultPath2, notePath);
   try {
     const stats = await fs16.stat(fullPath);
     return {
@@ -11775,7 +12076,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 path22 from "path";
 
 // src/core/write/validator.ts
 var TIMESTAMP_PATTERN = /^\*\*\d{2}:\d{2}\*\*/;
@@ -11978,7 +12279,7 @@ function runValidationPipeline(content, format, options = {}) {
 // src/core/write/mutation-helpers.ts
 init_writer();
 import fs19 from "fs/promises";
-import path19 from "path";
+import path21 from "path";
 init_constants();
 init_writer();
 function formatMcpResult(result) {
@@ -12027,7 +12328,7 @@ async function handleGitCommit(vaultPath2, notePath, commit, prefix) {
   return info;
 }
 async function ensureFileExists(vaultPath2, notePath) {
-  const fullPath = path19.join(vaultPath2, notePath);
+  const fullPath = path21.join(vaultPath2, notePath);
   try {
     await fs19.access(fullPath);
     return null;
@@ -12086,7 +12387,7 @@ async function withVaultFile(options, operation) {
     if ("error" in result) {
       return formatMcpResult(result.error);
     }
-    const fullPath = path19.join(vaultPath2, notePath);
+    const fullPath = path21.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`);
@@ -12149,10 +12450,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 = path22.join(vaultPath2, notePath);
+  await fs20.mkdir(path22.dirname(fullPath), { recursive: true });
   const templates = config.templates || {};
-  const filename = path20.basename(notePath, ".md").toLowerCase();
+  const filename = path22.basename(notePath, ".md").toLowerCase();
   let templatePath;
   const dailyPattern = /^\d{4}-\d{2}-\d{2}/;
   const weeklyPattern = /^\d{4}-W\d{2}/;
@@ -12173,10 +12474,10 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   let templateContent;
   if (templatePath) {
     try {
-      const absTemplatePath = path20.join(vaultPath2, templatePath);
+      const absTemplatePath = path22.join(vaultPath2, templatePath);
       templateContent = await fs20.readFile(absTemplatePath, "utf-8");
     } catch {
-      const title = path20.basename(notePath, ".md");
+      const title = path22.basename(notePath, ".md");
       templateContent = `---
 ---
 
@@ -12185,7 +12486,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
       templatePath = void 0;
     }
   } else {
-    const title = path20.basename(notePath, ".md");
+    const title = path22.basename(notePath, ".md");
     templateContent = `---
 ---
 
@@ -12194,7 +12495,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, path22.basename(notePath, ".md"));
   const matter9 = (await import("gray-matter")).default;
   const parsed = matter9(templateContent);
   if (!parsed.data.date) {
@@ -12234,7 +12535,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
       let noteCreated = false;
       let templateUsed;
       if (create_if_missing) {
-        const fullPath = path20.join(vaultPath2, notePath);
+        const fullPath = path22.join(vaultPath2, notePath);
         try {
           await fs20.access(fullPath);
         } catch {
@@ -12264,7 +12565,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
             throw new Error(validationResult.blockReason || "Output validation failed");
           }
           let workingContent = validationResult.content;
-          let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(workingContent, skipWikilinks, notePath);
+          let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(workingContent, skipWikilinks, notePath, ctx.content);
           if (linkedEntities?.length) {
             const stateDb2 = getWriteStateDb();
             if (stateDb2) {
@@ -12693,7 +12994,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 path23 from "path";
 function registerNoteTools(server2, vaultPath2, getIndex) {
   server2.tool(
     "vault_create_note",
@@ -12716,23 +13017,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 = path23.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 = path23.dirname(fullPath);
         await fs21.mkdir(dir, { recursive: true });
         let effectiveContent = content;
         let effectiveFrontmatter = frontmatter;
         if (template) {
-          const templatePath = path21.join(vaultPath2, template);
+          const templatePath = path23.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 = path23.basename(notePath, ".md");
             let templateContent = parsed.content.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, title);
             if (content) {
               templateContent = templateContent.trimEnd() + "\n\n" + content;
@@ -12751,7 +13052,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
           effectiveFrontmatter.created = now.toISOString();
         }
         const warnings = [];
-        const noteName = path21.basename(notePath, ".md");
+        const noteName = path23.basename(notePath, ".md");
         const existingAliases = Array.isArray(effectiveFrontmatter?.aliases) ? effectiveFrontmatter.aliases.filter((a) => typeof a === "string") : [];
         const preflight = await checkPreflightSimilarity(noteName);
         if (preflight.existingEntity) {
@@ -12868,7 +13169,7 @@ ${sources}`;
           }
           return formatMcpResult(errorResult(notePath, previewLines.join("\n")));
         }
-        const fullPath = path21.join(vaultPath2, notePath);
+        const fullPath = path23.join(vaultPath2, notePath);
         await fs21.unlink(fullPath);
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Flywheel:Delete]");
         const message = backlinkWarning ? `Deleted note: ${notePath}
@@ -12888,7 +13189,7 @@ Warning: ${backlinkWarning}` : `Deleted note: ${notePath}`;
 init_writer();
 import { z as z15 } from "zod";
 import fs22 from "fs/promises";
-import path22 from "path";
+import path24 from "path";
 import matter6 from "gray-matter";
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -12907,7 +13208,7 @@ function extractWikilinks2(content) {
   return wikilinks;
 }
 function getTitleFromPath(filePath) {
-  return path22.basename(filePath, ".md");
+  return path24.basename(filePath, ".md");
 }
 async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   const results = [];
@@ -12916,7 +13217,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 = path24.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         files.push(...await scanDir(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -12927,7 +13228,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 = path24.relative(vaultPath2, filePath);
     const content = await fs22.readFile(filePath, "utf-8");
     const wikilinks = extractWikilinks2(content);
     const matchingLinks = [];
@@ -12947,7 +13248,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   return results;
 }
 async function updateBacklinksInFile(vaultPath2, filePath, oldTitles, newTitle) {
-  const fullPath = path22.join(vaultPath2, filePath);
+  const fullPath = path24.join(vaultPath2, filePath);
   const raw = await fs22.readFile(fullPath, "utf-8");
   const parsed = matter6(raw);
   let content = parsed.content;
@@ -13014,8 +13315,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 = path24.join(vaultPath2, oldPath);
+        const newFullPath = path24.join(vaultPath2, newPath);
         try {
           await fs22.access(oldFullPath);
         } catch {
@@ -13065,7 +13366,7 @@ function registerMoveNoteTools(server2, vaultPath2) {
             }
           }
         }
-        const destDir = path22.dirname(newFullPath);
+        const destDir = path24.dirname(newFullPath);
         await fs22.mkdir(destDir, { recursive: true });
         await fs22.rename(oldFullPath, newFullPath);
         let gitCommit;
@@ -13151,10 +13452,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 = path24.join(vaultPath2, notePath);
+        const dir = path24.dirname(notePath);
+        const newPath = dir === "." ? `${sanitizedTitle}.md` : path24.join(dir, `${sanitizedTitle}.md`);
+        const newFullPath = path24.join(vaultPath2, newPath);
         try {
           await fs22.access(fullPath);
         } catch {
@@ -13511,7 +13812,7 @@ init_schema();
 // src/core/write/policy/parser.ts
 init_schema();
 import fs24 from "fs/promises";
-import path23 from "path";
+import path25 from "path";
 import matter7 from "gray-matter";
 function parseYaml(content) {
   const parsed = matter7(`---
@@ -13560,13 +13861,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 = path25.join(vaultPath2, ".claude", "policies");
+  const policyPath = path25.join(policiesDir, `${policyName}.yaml`);
   try {
     await fs24.access(policyPath);
     return loadPolicyFile(policyPath);
   } catch {
-    const ymlPath = path23.join(policiesDir, `${policyName}.yml`);
+    const ymlPath = path25.join(policiesDir, `${policyName}.yml`);
     try {
       await fs24.access(ymlPath);
       return loadPolicyFile(ymlPath);
@@ -13707,7 +14008,7 @@ init_conditions();
 init_schema();
 init_writer();
 import fs26 from "fs/promises";
-import path25 from "path";
+import path27 from "path";
 init_constants();
 async function executeStep(step, vaultPath2, context, conditionResults) {
   const { execute, reason } = shouldStepExecute(step.when, conditionResults);
@@ -13781,7 +14082,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 = path27.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13821,7 +14122,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 = path27.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13852,7 +14153,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 = path27.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13895,7 +14196,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 = path27.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
     if (!overwrite) {
@@ -13903,7 +14204,7 @@ async function executeCreateNote(params, vaultPath2, context) {
     }
   } catch {
   }
-  const dir = path25.dirname(fullPath);
+  const dir = path27.dirname(fullPath);
   await fs26.mkdir(dir, { recursive: true });
   const { content: processedContent } = maybeApplyWikilinks(content, skipWikilinks, notePath);
   await writeVaultFile(vaultPath2, notePath, processedContent, frontmatter);
@@ -13923,7 +14224,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 = path27.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13940,7 +14241,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 = path27.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13983,7 +14284,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 = path27.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -14020,7 +14321,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 = path27.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -14042,7 +14343,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 = path27.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -14205,7 +14506,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 = path27.join(vaultPath2, filePath);
     if (original === null) {
       try {
         await fs26.unlink(fullPath);
@@ -14260,9 +14561,9 @@ async function previewPolicy(policy, vaultPath2, variables) {
 
 // src/core/write/policy/storage.ts
 import fs27 from "fs/promises";
-import path26 from "path";
+import path28 from "path";
 function getPoliciesDir(vaultPath2) {
-  return path26.join(vaultPath2, ".claude", "policies");
+  return path28.join(vaultPath2, ".claude", "policies");
 }
 async function ensurePoliciesDir(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
@@ -14277,15 +14578,15 @@ async function listPolicies(vaultPath2) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
         continue;
       }
-      const filePath = path26.join(dir, file);
-      const stat3 = await fs27.stat(filePath);
+      const filePath = path28.join(dir, file);
+      const stat4 = await fs27.stat(filePath);
       const content = await fs27.readFile(filePath, "utf-8");
       const metadata = extractPolicyMetadata(content);
       policies.push({
         name: metadata.name || file.replace(/\.ya?ml$/, ""),
         description: metadata.description || "No description",
         path: file,
-        lastModified: stat3.mtime,
+        lastModified: stat4.mtime,
         version: metadata.version || "1.0",
         requiredVariables: metadata.variables || []
       });
@@ -14302,7 +14603,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 = path28.join(dir, filename);
   if (!overwrite) {
     try {
       await fs27.access(filePath);
@@ -14846,7 +15147,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 path29 from "path";
 import matter8 from "gray-matter";
 import { getProtectedZones } from "@velvetmonkey/vault-core";
 function getNotesInFolder3(index, folder) {
@@ -14952,7 +15253,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 = path29.join(vaultPath2, note.path);
     let fileContent;
     try {
       fileContent = await fs28.readFile(fullPath, "utf-8");
@@ -15590,8 +15891,8 @@ function getNoteAccessFrequency(stateDb2, daysBack = 30) {
       }
     }
   }
-  return Array.from(noteMap.entries()).map(([path30, stats]) => ({
-    path: path30,
+  return Array.from(noteMap.entries()).map(([path32, stats]) => ({
+    path: path32,
     access_count: stats.access_count,
     last_accessed: stats.last_accessed,
     tools_used: Array.from(stats.tools)
@@ -15744,7 +16045,7 @@ import { z as z25 } from "zod";
 
 // src/core/read/similarity.ts
 import * as fs29 from "fs";
-import * as path28 from "path";
+import * as path30 from "path";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
   "be",
@@ -15881,7 +16182,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 = path30.join(vaultPath2, sourcePath);
   let content;
   try {
     content = fs29.readFileSync(absPath, "utf-8");
@@ -16009,7 +16310,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: path32, limit, exclude_linked }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const stateDb2 = getStateDb();
@@ -16018,10 +16319,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(path32)) {
         return {
           content: [{ type: "text", text: JSON.stringify({
-            error: `Note not found: ${path30}`,
+            error: `Note not found: ${path32}`,
             hint: "Use the full relative path including .md extension"
           }, null, 2) }]
         };
@@ -16032,12 +16333,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, path32, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path32, opts);
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
-            source: path30,
+            source: path32,
             method,
             exclude_linked: exclude_linked ?? true,
             count: results.length,
@@ -16275,6 +16576,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) {
@@ -16795,6 +17097,38 @@ async function updateEntitiesInStateDb() {
     serverLog("index", `Failed to update entities in StateDb: ${e instanceof Error ? e.message : e}`, "error");
   }
 }
+async function buildStartupCatchupBatch(vaultPath2, sinceMs) {
+  const events = [];
+  async function scanDir(dir) {
+    let entries;
+    try {
+      entries = await fs30.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path31.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+        await scanDir(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        try {
+          const stat4 = await fs30.stat(fullPath);
+          if (stat4.mtimeMs > sinceMs) {
+            events.push({
+              type: "upsert",
+              path: path31.relative(vaultPath2, fullPath),
+              originalEvents: []
+            });
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  await scanDir(vaultPath2);
+  return events;
+}
 async function runPostIndexWork(index) {
   const postStart = Date.now();
   serverLog("index", "Scanning entities...");
@@ -16885,277 +17219,502 @@ 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) => {
-        const vaultPrefixes = /* @__PURE__ */ new Set([
-          vaultPath.replace(/\\/g, "/"),
-          resolvedVaultPath
-        ]);
-        for (const event of batch.events) {
-          const normalized = event.path.replace(/\\/g, "/");
-          let matched = false;
+    const handleBatch = async (batch) => {
+      const vaultPrefixes = /* @__PURE__ */ new Set([
+        vaultPath.replace(/\\/g, "/"),
+        resolvedVaultPath
+      ]);
+      const normalizeEventPath = (rawPath) => {
+        const normalized = rawPath.replace(/\\/g, "/");
+        for (const prefix of vaultPrefixes) {
+          if (normalized.startsWith(prefix + "/")) {
+            return normalized.slice(prefix.length + 1);
+          }
+        }
+        try {
+          const resolved = realpathSync(rawPath).replace(/\\/g, "/");
           for (const prefix of vaultPrefixes) {
-            if (normalized.startsWith(prefix + "/")) {
-              event.path = normalized.slice(prefix.length + 1);
-              matched = true;
-              break;
+            if (resolved.startsWith(prefix + "/")) {
+              return resolved.slice(prefix.length + 1);
+            }
+          }
+        } catch {
+          try {
+            const dir = path31.dirname(rawPath);
+            const base = path31.basename(rawPath);
+            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);
+                return relDir ? `${relDir}/${base}` : base;
+              }
+            }
+          } catch {
+          }
+        }
+        return normalized;
+      };
+      for (const event of batch.events) {
+        event.path = normalizeEventPath(event.path);
+      }
+      const batchRenames = (batch.renames ?? []).map((r) => ({
+        ...r,
+        oldPath: normalizeEventPath(r.oldPath),
+        newPath: normalizeEventPath(r.newPath)
+      }));
+      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(path31.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 (batchRenames.length > 0 && stateDb) {
+        try {
+          const insertMove = stateDb.db.prepare(`
+              INSERT INTO note_moves (old_path, new_path, old_folder, new_folder)
+              VALUES (?, ?, ?, ?)
+            `);
+          const renameNoteLinks = stateDb.db.prepare(
+            "UPDATE note_links SET note_path = ? WHERE note_path = ?"
+          );
+          const renameNoteTags = stateDb.db.prepare(
+            "UPDATE note_tags SET note_path = ? WHERE note_path = ?"
+          );
+          const renameNoteLinkHistory = stateDb.db.prepare(
+            "UPDATE note_link_history SET note_path = ? WHERE note_path = ?"
+          );
+          const renameWikilinkApplications = stateDb.db.prepare(
+            "UPDATE wikilink_applications SET note_path = ? WHERE note_path = ?"
+          );
+          for (const rename of batchRenames) {
+            const oldFolder = rename.oldPath.includes("/") ? rename.oldPath.split("/").slice(0, -1).join("/") : "";
+            const newFolder = rename.newPath.includes("/") ? rename.newPath.split("/").slice(0, -1).join("/") : "";
+            insertMove.run(rename.oldPath, rename.newPath, oldFolder || null, newFolder || null);
+            renameNoteLinks.run(rename.newPath, rename.oldPath);
+            renameNoteTags.run(rename.newPath, rename.oldPath);
+            renameNoteLinkHistory.run(rename.newPath, rename.oldPath);
+            renameWikilinkApplications.run(rename.newPath, rename.oldPath);
+            const oldHash = lastContentHashes.get(rename.oldPath);
+            if (oldHash !== void 0) {
+              lastContentHashes.set(rename.newPath, oldHash);
+              lastContentHashes.delete(rename.oldPath);
+            }
+          }
+          serverLog("watcher", `Renames: recorded ${batchRenames.length} move(s) in note_moves`);
+        } catch (err) {
+          serverLog("watcher", `Rename recording failed: ${err instanceof Error ? err.message : err}`, "error");
+        }
+      }
+      if (filteredEvents.length === 0) {
+        if (batchRenames.length > 0) {
+          serverLog("watcher", `Batch complete (renames only): ${batchRenames.length} rename(s)`);
+        } else {
+          serverLog("watcher", "All files unchanged (hash gate), skipping batch");
+        }
+        return;
+      }
+      serverLog("watcher", `Processing ${filteredEvents.length} file changes`);
+      const batchStart = Date.now();
+      const changedPaths = filteredEvents.map((e) => e.path);
+      const tracker = createStepTracker();
+      try {
+        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: path31.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 });
+        tracker.start("note_moves", { count: batchRenames.length });
+        tracker.end({
+          renames: batchRenames.map((r) => ({ oldPath: r.oldPath, newPath: r.newPath }))
+        });
+        if (batchRenames.length > 0) {
+          serverLog("watcher", `Note moves: ${batchRenames.length} rename(s) recorded`);
+        }
+        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();
+        const entitiesAfter = stateDb ? getAllEntitiesFromDb3(stateDb) : [];
+        const entityDiff = computeEntityDiff(entitiesBefore, entitiesAfter);
+        const categoryChanges = [];
+        if (stateDb) {
+          const beforeMap = new Map(entitiesBefore.map((e) => [e.name, e]));
+          const insertChange = stateDb.db.prepare(
+            "INSERT INTO entity_changes (entity, field, old_value, new_value) VALUES (?, ?, ?, ?)"
+          );
+          for (const after of entitiesAfter) {
+            const before = beforeMap.get(after.name);
+            if (before && before.category !== after.category) {
+              insertChange.run(after.name, "category", before.category, after.category);
+              categoryChanges.push({ entity: after.name, from: before.category, to: after.category });
             }
           }
-          if (!matched) {
+        }
+        tracker.end({ entity_count: entitiesAfter.length, ...entityDiff, category_changes: categoryChanges });
+        serverLog("watcher", `Entity scan: ${entitiesAfter.length} entities`);
+        tracker.start("hub_scores", { entity_count: entitiesAfter.length });
+        const hubUpdated = await exportHubScores(vaultIndex, stateDb);
+        const hubDiffs = [];
+        if (stateDb) {
+          const rows = stateDb.db.prepare("SELECT name, hub_score FROM entities").all();
+          for (const r of rows) {
+            const prev = hubBefore.get(r.name) ?? 0;
+            if (prev !== r.hub_score) hubDiffs.push({ entity: r.name, before: prev, after: r.hub_score });
+          }
+        }
+        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: filteredEvents.length });
+          let embUpdated = 0;
+          let embRemoved = 0;
+          for (const event of filteredEvents) {
             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;
-                }
+              if (event.type === "delete") {
+                removeEmbedding(event.path);
+                embRemoved++;
+              } else if (event.path.endsWith(".md")) {
+                const absPath = path31.join(vaultPath, event.path);
+                await updateEmbedding(event.path, absPath);
+                embUpdated++;
               }
             } catch {
-              try {
-                const dir = path29.dirname(event.path);
-                const base = path29.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 {
+            }
+          }
+          tracker.end({ updated: embUpdated, removed: embRemoved });
+          serverLog("watcher", `Note embeddings: ${embUpdated} updated, ${embRemoved} removed`);
+        } else {
+          tracker.skip("note_embeddings", "not built");
+        }
+        if (hasEntityEmbeddingsIndex() && stateDb) {
+          tracker.start("entity_embeddings", { files: filteredEvents.length });
+          let entEmbUpdated = 0;
+          const entEmbNames = [];
+          try {
+            const allEntities = getAllEntitiesFromDb3(stateDb);
+            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) {
+                await updateEntityEmbedding(entity.name, {
+                  name: entity.name,
+                  path: entity.path,
+                  category: entity.category,
+                  aliases: entity.aliases
+                }, vaultPath);
+                entEmbUpdated++;
+                entEmbNames.push(entity.name);
               }
             }
+          } catch {
           }
+          tracker.end({ updated: entEmbUpdated, updated_entities: entEmbNames.slice(0, 10) });
+          serverLog("watcher", `Entity embeddings: ${entEmbUpdated} updated`);
+        } else {
+          tracker.skip("entity_embeddings", !stateDb ? "no stateDb" : "not built");
         }
-        serverLog("watcher", `Processing ${batch.events.length} file changes`);
-        const batchStart = Date.now();
-        const changedPaths = batch.events.map((e) => e.path);
-        const tracker = createStepTracker();
-        try {
-          tracker.start("index_rebuild", { files_changed: batch.events.length, changed_paths: changedPaths });
-          vaultIndex = await buildVaultIndex(vaultPath);
-          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);
+        if (stateDb) {
+          tracker.start("index_cache", { note_count: vaultIndex.notes.size });
+          try {
+            saveVaultIndexToCache(stateDb, vaultIndex);
+            tracker.end({ saved: true });
+            serverLog("watcher", "Index cache saved");
+          } catch (err) {
+            tracker.end({ saved: false, error: err instanceof Error ? err.message : String(err) });
+            serverLog("index", `Failed to update index cache: ${err instanceof Error ? err.message : err}`, "error");
           }
-          const entitiesBefore = stateDb ? getAllEntitiesFromDb3(stateDb) : [];
-          tracker.start("entity_scan", { note_count: vaultIndex.notes.size });
-          await updateEntitiesInStateDb();
-          const entitiesAfter = stateDb ? getAllEntitiesFromDb3(stateDb) : [];
-          const entityDiff = computeEntityDiff(entitiesBefore, entitiesAfter);
-          tracker.end({ entity_count: entitiesAfter.length, ...entityDiff });
-          serverLog("watcher", `Entity scan: ${entitiesAfter.length} entities`);
-          tracker.start("hub_scores", { entity_count: entitiesAfter.length });
-          const hubUpdated = await exportHubScores(vaultIndex, stateDb);
-          const hubDiffs = [];
-          if (stateDb) {
-            const rows = stateDb.db.prepare("SELECT name, hub_score FROM entities").all();
-            for (const r of rows) {
-              const prev = hubBefore.get(r.name) ?? 0;
-              if (prev !== r.hub_score) hubDiffs.push({ entity: r.name, before: prev, after: r.hub_score });
+        } else {
+          tracker.skip("index_cache", "no stateDb");
+        }
+        tracker.start("task_cache", { files: filteredEvents.length });
+        let taskUpdated = 0;
+        let taskRemoved = 0;
+        for (const event of filteredEvents) {
+          try {
+            if (event.type === "delete") {
+              removeTaskCacheForFile(event.path);
+              taskRemoved++;
+            } else if (event.path.endsWith(".md")) {
+              await updateTaskCacheForFile(vaultPath, event.path);
+              taskUpdated++;
             }
+          } catch {
           }
-          tracker.end({ updated: hubUpdated ?? 0, diffs: hubDiffs.slice(0, 10) });
-          serverLog("watcher", `Hub scores: ${hubUpdated ?? 0} updated`);
-          tracker.start("recency", { entity_count: entitiesAfter.length });
+        }
+        tracker.end({ updated: taskUpdated, removed: taskRemoved });
+        serverLog("watcher", `Task cache: ${taskUpdated} updated, ${taskRemoved} removed`);
+        tracker.start("forward_links", { files: filteredEvents.length });
+        const eventTypeMap = new Map(filteredEvents.map((e) => [e.path, e.type]));
+        const forwardLinkResults = [];
+        let totalResolved = 0;
+        let totalDead = 0;
+        for (const event of filteredEvents) {
+          if (event.type === "delete" || !event.path.endsWith(".md")) continue;
           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)`);
+            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);
             }
-          } catch (e) {
-            tracker.end({ error: String(e) });
-            serverLog("watcher", `Recency: failed: ${e}`);
+            if (resolved.length > 0 || dead.length > 0) {
+              forwardLinkResults.push({ file: event.path, resolved, dead });
+            }
+            totalResolved += resolved.length;
+            totalDead += dead.length;
+          } catch {
           }
-          if (hasEmbeddingsIndex()) {
-            tracker.start("note_embeddings", { files: batch.events.length });
-            let embUpdated = 0;
-            let embRemoved = 0;
-            for (const event of batch.events) {
-              try {
-                if (event.type === "delete") {
-                  removeEmbedding(event.path);
-                  embRemoved++;
-                } else if (event.path.endsWith(".md")) {
-                  const absPath = path29.join(vaultPath, event.path);
-                  await updateEmbedding(event.path, absPath);
-                  embUpdated++;
+        }
+        const linkDiffs = [];
+        if (stateDb) {
+          const upsertHistory = stateDb.db.prepare(`
+              INSERT INTO note_link_history (note_path, target) VALUES (?, ?)
+              ON CONFLICT(note_path, target) DO UPDATE SET edits_survived = edits_survived + 1
+            `);
+          const checkThreshold = stateDb.db.prepare(`
+              SELECT target FROM note_link_history
+              WHERE note_path = ? AND target = ? AND edits_survived >= 3 AND last_positive_at IS NULL
+            `);
+          const markPositive = stateDb.db.prepare(`
+              UPDATE note_link_history SET last_positive_at = datetime('now') WHERE note_path = ? AND target = ?
+            `);
+          for (const entry of forwardLinkResults) {
+            const currentSet = /* @__PURE__ */ new Set([
+              ...entry.resolved.map((n) => n.toLowerCase()),
+              ...entry.dead.map((n) => n.toLowerCase())
+            ]);
+            const previousSet = getStoredNoteLinks(stateDb, entry.file);
+            if (previousSet.size === 0) {
+              updateStoredNoteLinks(stateDb, entry.file, currentSet);
+              continue;
+            }
+            const diff = diffNoteLinks(previousSet, currentSet);
+            if (diff.added.length > 0 || diff.removed.length > 0) {
+              linkDiffs.push({ file: entry.file, ...diff });
+            }
+            updateStoredNoteLinks(stateDb, entry.file, currentSet);
+            for (const link of currentSet) {
+              if (!previousSet.has(link)) continue;
+              upsertHistory.run(entry.file, link);
+              const hit = checkThreshold.get(entry.file, link);
+              if (hit) {
+                const entity = entitiesAfter.find(
+                  (e) => e.nameLower === link || (e.aliases ?? []).some((a) => a.toLowerCase() === link)
+                );
+                if (entity) {
+                  recordFeedback(stateDb, entity.name, "implicit:kept", entry.file, true);
+                  markPositive.run(entry.file, link);
                 }
-              } catch {
               }
             }
-            tracker.end({ updated: embUpdated, removed: embRemoved });
-            serverLog("watcher", `Note embeddings: ${embUpdated} updated, ${embRemoved} removed`);
-          } else {
-            tracker.skip("note_embeddings", "not built");
           }
-          if (hasEntityEmbeddingsIndex() && stateDb) {
-            tracker.start("entity_embeddings", { files: batch.events.length });
-            let entEmbUpdated = 0;
-            const entEmbNames = [];
-            try {
-              const allEntities = getAllEntitiesFromDb3(stateDb);
-              for (const event of batch.events) {
-                if (event.type === "delete" || !event.path.endsWith(".md")) continue;
-                const matching = allEntities.filter((e) => e.path === event.path);
-                for (const entity of matching) {
-                  await updateEntityEmbedding(entity.name, {
-                    name: entity.name,
-                    path: entity.path,
-                    category: entity.category,
-                    aliases: entity.aliases
-                  }, vaultPath);
-                  entEmbUpdated++;
-                  entEmbNames.push(entity.name);
-                }
+          for (const event of filteredEvents) {
+            if (event.type === "delete") {
+              const previousSet = getStoredNoteLinks(stateDb, event.path);
+              if (previousSet.size > 0) {
+                linkDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
+                updateStoredNoteLinks(stateDb, event.path, /* @__PURE__ */ new Set());
               }
-            } catch {
             }
-            tracker.end({ updated: entEmbUpdated, updated_entities: entEmbNames.slice(0, 10) });
-            serverLog("watcher", `Entity embeddings: ${entEmbUpdated} updated`);
-          } else {
-            tracker.skip("entity_embeddings", !stateDb ? "no stateDb" : "not built");
           }
-          if (stateDb) {
-            tracker.start("index_cache", { note_count: vaultIndex.notes.size });
+        }
+        tracker.end({
+          total_resolved: totalResolved,
+          total_dead: totalDead,
+          links: forwardLinkResults,
+          link_diffs: linkDiffs
+        });
+        serverLog("watcher", `Forward links: ${totalResolved} resolved, ${totalDead} dead`);
+        tracker.start("wikilink_check", { files: filteredEvents.length });
+        const trackedLinks = [];
+        if (stateDb) {
+          for (const event of filteredEvents) {
+            if (event.type === "delete" || !event.path.endsWith(".md")) continue;
             try {
-              saveVaultIndexToCache(stateDb, vaultIndex);
-              tracker.end({ saved: true });
-              serverLog("watcher", "Index cache saved");
-            } catch (err) {
-              tracker.end({ saved: false, error: err instanceof Error ? err.message : String(err) });
-              serverLog("index", `Failed to update index cache: ${err instanceof Error ? err.message : err}`, "error");
+              const apps = getTrackedApplications(stateDb, event.path);
+              if (apps.length > 0) trackedLinks.push({ file: event.path, entities: apps });
+            } catch {
             }
-          } else {
-            tracker.skip("index_cache", "no stateDb");
           }
-          tracker.start("task_cache", { files: batch.events.length });
-          let taskUpdated = 0;
-          let taskRemoved = 0;
-          for (const event of batch.events) {
-            try {
-              if (event.type === "delete") {
-                removeTaskCacheForFile(event.path);
-                taskRemoved++;
-              } else if (event.path.endsWith(".md")) {
-                await updateTaskCacheForFile(vaultPath, event.path);
-                taskUpdated++;
+        }
+        for (const diff of linkDiffs) {
+          if (diff.added.length === 0) continue;
+          const existing2 = trackedLinks.find((t) => t.file === diff.file);
+          if (existing2) {
+            const set = new Set(existing2.entities.map((e) => e.toLowerCase()));
+            for (const a of diff.added) {
+              if (!set.has(a)) {
+                existing2.entities.push(a);
+                set.add(a);
               }
-            } catch {
             }
+          } else {
+            trackedLinks.push({ file: diff.file, entities: diff.added });
           }
-          tracker.end({ updated: taskUpdated, removed: taskRemoved });
-          serverLog("watcher", `Task cache: ${taskUpdated} updated, ${taskRemoved} removed`);
-          tracker.start("forward_links", { files: batch.events.length });
-          const forwardLinkResults = [];
-          let totalResolved = 0;
-          let totalDead = 0;
-          for (const event of batch.events) {
+        }
+        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: filteredEvents.length });
+        const feedbackResults = [];
+        if (stateDb) {
+          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;
+              const content = await fs30.readFile(path31.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 {
             }
           }
-          tracker.end({
-            total_resolved: totalResolved,
-            total_dead: totalDead,
-            links: forwardLinkResults
-          });
-          serverLog("watcher", `Forward links: ${totalResolved} resolved, ${totalDead} dead`);
-          tracker.start("wikilink_check", { files: batch.events.length });
-          const trackedLinks = [];
-          if (stateDb) {
-            for (const event of batch.events) {
-              if (event.type === "delete" || !event.path.endsWith(".md")) continue;
-              try {
-                const apps = getTrackedApplications(stateDb, event.path);
-                if (apps.length > 0) trackedLinks.push({ file: event.path, entities: apps });
-              } catch {
+        }
+        if (stateDb && linkDiffs.length > 0) {
+          for (const diff of linkDiffs) {
+            for (const target of diff.removed) {
+              if (feedbackResults.some((r) => r.entity === target && r.file === diff.file)) continue;
+              const entity = entitiesAfter.find(
+                (e) => e.nameLower === target || (e.aliases ?? []).some((a) => a.toLowerCase() === target)
+              );
+              if (entity) {
+                recordFeedback(stateDb, entity.name, "implicit:removed", diff.file, false);
+                feedbackResults.push({ entity: entity.name, file: diff.file });
               }
             }
           }
-          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 });
-          const feedbackResults = [];
-          if (stateDb) {
-            for (const event of batch.events) {
-              if (event.type === "delete" || !event.path.endsWith(".md")) continue;
-              try {
-                const content = await fs30.readFile(path29.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 {
-              }
+        }
+        tracker.end({ removals: feedbackResults });
+        if (feedbackResults.length > 0) {
+          serverLog("watcher", `Implicit feedback: ${feedbackResults.length} removals detected`);
+        }
+        tracker.start("tag_scan", { files: filteredEvents.length });
+        const tagDiffs = [];
+        if (stateDb) {
+          const noteTagsForward = /* @__PURE__ */ new Map();
+          for (const [tag, paths] of vaultIndex.tags) {
+            for (const notePath of paths) {
+              if (!noteTagsForward.has(notePath)) noteTagsForward.set(notePath, /* @__PURE__ */ new Set());
+              noteTagsForward.get(notePath).add(tag);
             }
           }
-          tracker.end({ removals: feedbackResults });
-          if (feedbackResults.length > 0) {
-            serverLog("watcher", `Implicit feedback: ${feedbackResults.length} removals detected`);
-          }
-          const duration = Date.now() - batchStart;
-          if (stateDb) {
-            recordIndexEvent(stateDb, {
-              trigger: "watcher",
-              duration_ms: duration,
-              note_count: vaultIndex.notes.size,
-              files_changed: batch.events.length,
-              changed_paths: changedPaths,
-              steps: tracker.steps
-            });
+          for (const event of filteredEvents) {
+            if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+            const currentSet = noteTagsForward.get(event.path) ?? /* @__PURE__ */ new Set();
+            const previousSet = getStoredNoteTags(stateDb, event.path);
+            if (previousSet.size === 0 && currentSet.size > 0) {
+              updateStoredNoteTags(stateDb, event.path, currentSet);
+              continue;
+            }
+            const added = [...currentSet].filter((t) => !previousSet.has(t));
+            const removed = [...previousSet].filter((t) => !currentSet.has(t));
+            if (added.length > 0 || removed.length > 0) {
+              tagDiffs.push({ file: event.path, added, removed });
+            }
+            updateStoredNoteTags(stateDb, event.path, currentSet);
           }
-          serverLog("watcher", `Batch complete: ${batch.events.length} files, ${duration}ms, ${tracker.steps.length} steps`);
-        } catch (err) {
-          setIndexState("error");
-          setIndexError(err instanceof Error ? err : new Error(String(err)));
-          const duration = Date.now() - batchStart;
-          if (stateDb) {
-            recordIndexEvent(stateDb, {
-              trigger: "watcher",
-              duration_ms: duration,
-              success: false,
-              files_changed: batch.events.length,
-              changed_paths: changedPaths,
-              error: err instanceof Error ? err.message : String(err),
-              steps: tracker.steps
-            });
+          for (const event of filteredEvents) {
+            if (event.type === "delete") {
+              const previousSet = getStoredNoteTags(stateDb, event.path);
+              if (previousSet.size > 0) {
+                tagDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
+                updateStoredNoteTags(stateDb, event.path, /* @__PURE__ */ new Set());
+              }
+            }
           }
-          serverLog("watcher", `Failed to rebuild index: ${err instanceof Error ? err.message : err}`, "error");
         }
-      },
+        const totalTagsAdded = tagDiffs.reduce((s, d) => s + d.added.length, 0);
+        const totalTagsRemoved = tagDiffs.reduce((s, d) => s + d.removed.length, 0);
+        tracker.end({ total_added: totalTagsAdded, total_removed: totalTagsRemoved, tag_diffs: tagDiffs });
+        if (tagDiffs.length > 0) {
+          serverLog("watcher", `Tag scan: ${totalTagsAdded} added, ${totalTagsRemoved} removed across ${tagDiffs.length} files`);
+        }
+        const duration = Date.now() - batchStart;
+        if (stateDb) {
+          recordIndexEvent(stateDb, {
+            trigger: "watcher",
+            duration_ms: duration,
+            note_count: vaultIndex.notes.size,
+            files_changed: filteredEvents.length,
+            changed_paths: changedPaths,
+            steps: tracker.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)));
+        const duration = Date.now() - batchStart;
+        if (stateDb) {
+          recordIndexEvent(stateDb, {
+            trigger: "watcher",
+            duration_ms: duration,
+            success: false,
+            files_changed: filteredEvents.length,
+            changed_paths: changedPaths,
+            error: err instanceof Error ? err.message : String(err),
+            steps: tracker.steps
+          });
+        }
+        serverLog("watcher", `Failed to rebuild index: ${err instanceof Error ? err.message : err}`, "error");
+      }
+    };
+    const watcher = createVaultWatcher({
+      vaultPath,
+      config,
+      onBatch: handleBatch,
       onStateChange: (status) => {
         if (status.state === "dirty") {
           serverLog("watcher", "Index may be stale", "warn");
@@ -17165,6 +17724,16 @@ async function runPostIndexWork(index) {
         serverLog("watcher", `Watcher error: ${err.message}`, "error");
       }
     });
+    if (stateDb) {
+      const lastPipelineEvent = getRecentPipelineEvent(stateDb);
+      if (lastPipelineEvent) {
+        const catchupEvents = await buildStartupCatchupBatch(vaultPath, lastPipelineEvent.timestamp);
+        if (catchupEvents.length > 0) {
+          console.error(`[Flywheel] Startup catch-up: ${catchupEvents.length} file(s) modified while offline`);
+          await handleBatch({ events: catchupEvents, renames: [], timestamp: Date.now() });
+        }
+      }
+    }
     watcher.start();
     serverLog("watcher", "File watcher started");
   }