@velvetmonkey/flywheel-memory 2.0.35 → 2.0.36

package/dist/index.js

@@ -59,7 +59,7 @@ var init_constants = __esm({
 
 // src/core/write/writer.ts
 import fs18 from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 import matter5 from "gray-matter";
 function isSensitivePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
@@ -386,8 +386,8 @@ function validatePath(vaultPath2, notePath) {
   if (notePath.startsWith("\\")) {
     return false;
   }
-  const resolvedVault = path18.resolve(vaultPath2);
-  const resolvedNote = path18.resolve(vaultPath2, notePath);
+  const resolvedVault = path19.resolve(vaultPath2);
+  const resolvedNote = path19.resolve(vaultPath2, notePath);
   return resolvedNote.startsWith(resolvedVault);
 }
 async function validatePathSecure(vaultPath2, notePath) {
@@ -415,8 +415,8 @@ async function validatePathSecure(vaultPath2, notePath) {
       reason: "Path traversal not allowed"
     };
   }
-  const resolvedVault = path18.resolve(vaultPath2);
-  const resolvedNote = path18.resolve(vaultPath2, notePath);
+  const resolvedVault = path19.resolve(vaultPath2);
+  const resolvedNote = path19.resolve(vaultPath2, notePath);
   if (!resolvedNote.startsWith(resolvedVault)) {
     return {
       valid: false,
@@ -430,7 +430,7 @@ async function validatePathSecure(vaultPath2, notePath) {
     };
   }
   try {
-    const fullPath = path18.join(vaultPath2, notePath);
+    const fullPath = path19.join(vaultPath2, notePath);
     try {
       await fs18.access(fullPath);
       const realPath = await fs18.realpath(fullPath);
@@ -441,7 +441,7 @@ async function validatePathSecure(vaultPath2, notePath) {
           reason: "Symlink target is outside vault"
         };
       }
-      const relativePath = path18.relative(realVaultPath, realPath);
+      const relativePath = path19.relative(realVaultPath, realPath);
       if (isSensitivePath(relativePath)) {
         return {
           valid: false,
@@ -449,7 +449,7 @@ async function validatePathSecure(vaultPath2, notePath) {
         };
       }
     } catch {
-      const parentDir = path18.dirname(fullPath);
+      const parentDir = path19.dirname(fullPath);
       try {
         await fs18.access(parentDir);
         const realParentPath = await fs18.realpath(parentDir);
@@ -475,7 +475,7 @@ async function readVaultFile(vaultPath2, notePath) {
   if (!validatePath(vaultPath2, notePath)) {
     throw new Error("Invalid path: path traversal not allowed");
   }
-  const fullPath = path18.join(vaultPath2, notePath);
+  const fullPath = path19.join(vaultPath2, notePath);
   const [rawContent, stat3] = await Promise.all([
     fs18.readFile(fullPath, "utf-8"),
     fs18.stat(fullPath)
@@ -528,7 +528,7 @@ async function writeVaultFile(vaultPath2, notePath, content, frontmatter, lineEn
   if (!validation.valid) {
     throw new Error(`Invalid path: ${validation.reason}`);
   }
-  const fullPath = path18.join(vaultPath2, notePath);
+  const fullPath = path19.join(vaultPath2, notePath);
   let output = matter5.stringify(content, frontmatter);
   output = normalizeTrailingNewline(output);
   output = convertLineEndings(output, lineEnding);
@@ -836,8 +836,8 @@ function createContext(variables = {}) {
     steps: {}
   };
 }
-function resolvePath(obj, path30) {
-  const parts = path30.split(".");
+function resolvePath(obj, path31) {
+  const parts = path31.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === void 0 || current === null) {
@@ -1279,7 +1279,7 @@ __export(conditions_exports, {
   shouldStepExecute: () => shouldStepExecute
 });
 import fs25 from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 async function evaluateCondition(condition, vaultPath2, context) {
   const interpolatedPath = condition.path ? interpolate(condition.path, context) : void 0;
   const interpolatedSection = condition.section ? interpolate(condition.section, context) : void 0;
@@ -1332,7 +1332,7 @@ async function evaluateCondition(condition, vaultPath2, context) {
   }
 }
 async function evaluateFileExists(vaultPath2, notePath, expectExists) {
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
     await fs25.access(fullPath);
     return {
@@ -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 = path25.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 = path25.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 = path25.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 path30 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(path31) {
+  return path31.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, path31] 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: path31, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -2864,30 +2864,30 @@ var EventQueue = class {
    * Add a new event to the queue
    */
   push(type, rawPath) {
-    const path30 = normalizePath(rawPath);
+    const path31 = normalizePath(rawPath);
     const now = Date.now();
     const event = {
       type,
-      path: path30,
+      path: path31,
       timestamp: now
     };
-    let pending = this.pending.get(path30);
+    let pending = this.pending.get(path31);
     if (!pending) {
       pending = {
         events: [],
         timer: null,
         lastEvent: now
       };
-      this.pending.set(path30, pending);
+      this.pending.set(path31, pending);
     }
     pending.events.push(event);
     pending.lastEvent = now;
-    console.error(`[flywheel] QUEUE: pushed ${type} for ${path30}, pending=${this.pending.size}`);
+    console.error(`[flywheel] QUEUE: pushed ${type} for ${path31}, pending=${this.pending.size}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
     }
     pending.timer = setTimeout(() => {
-      this.flushPath(path30);
+      this.flushPath(path31);
     }, this.config.debounceMs);
     if (this.pending.size >= this.config.batchSize) {
       this.flush();
@@ -2908,10 +2908,10 @@ var EventQueue = class {
   /**
    * Flush a single path's events
    */
-  flushPath(path30) {
-    const pending = this.pending.get(path30);
+  flushPath(path31) {
+    const pending = this.pending.get(path31);
     if (!pending || pending.events.length === 0) return;
-    console.error(`[flywheel] QUEUE: flushing ${path30}, events=${pending.events.length}`);
+    console.error(`[flywheel] QUEUE: flushing ${path31}, events=${pending.events.length}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -2920,7 +2920,7 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path30,
+        path: path31,
         originalEvents: [...pending.events]
       };
       this.onBatch({
@@ -2928,7 +2928,7 @@ var EventQueue = class {
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path30);
+    this.pending.delete(path31);
   }
   /**
    * Flush all pending events
@@ -2940,7 +2940,7 @@ var EventQueue = class {
     }
     if (this.pending.size === 0) return;
     const events = [];
-    for (const [path30, pending] of this.pending) {
+    for (const [path31, pending] of this.pending) {
       if (pending.timer) {
         clearTimeout(pending.timer);
       }
@@ -2948,7 +2948,7 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path30,
+          path: path31,
           originalEvents: [...pending.events]
         });
       }
@@ -3023,6 +3023,208 @@ function parseWatcherConfig() {
   };
 }
 
+// src/core/read/watch/incrementalIndex.ts
+import path6 from "path";
+function normalizeTarget2(target) {
+  return target.toLowerCase().replace(/\.md$/, "");
+}
+function normalizeNotePath2(notePath) {
+  return notePath.toLowerCase().replace(/\.md$/, "");
+}
+function removeNoteFromIndex(index, notePath) {
+  const note = index.notes.get(notePath);
+  if (!note) {
+    return false;
+  }
+  index.notes.delete(notePath);
+  const normalizedTitle = normalizeTarget2(note.title);
+  const normalizedPath = normalizeNotePath2(notePath);
+  if (index.entities.get(normalizedTitle) === notePath) {
+    index.entities.delete(normalizedTitle);
+  }
+  if (index.entities.get(normalizedPath) === notePath) {
+    index.entities.delete(normalizedPath);
+  }
+  for (const alias of note.aliases) {
+    const normalizedAlias = normalizeTarget2(alias);
+    if (index.entities.get(normalizedAlias) === notePath) {
+      index.entities.delete(normalizedAlias);
+    }
+  }
+  for (const tag of note.tags) {
+    const tagPaths = index.tags.get(tag);
+    if (tagPaths) {
+      tagPaths.delete(notePath);
+      if (tagPaths.size === 0) {
+        index.tags.delete(tag);
+      }
+    }
+  }
+  for (const link of note.outlinks) {
+    const normalizedTarget = normalizeTarget2(link.target);
+    const targetPath = index.entities.get(normalizedTarget);
+    const key = targetPath ? normalizeNotePath2(targetPath) : normalizedTarget;
+    const backlinks = index.backlinks.get(key);
+    if (backlinks) {
+      const filtered = backlinks.filter((bl) => bl.source !== notePath);
+      if (filtered.length === 0) {
+        index.backlinks.delete(key);
+      } else {
+        index.backlinks.set(key, filtered);
+      }
+    }
+  }
+  return true;
+}
+function addNoteToIndex(index, note) {
+  index.notes.set(note.path, note);
+  const normalizedTitle = normalizeTarget2(note.title);
+  const normalizedPath = normalizeNotePath2(note.path);
+  if (!index.entities.has(normalizedTitle)) {
+    index.entities.set(normalizedTitle, note.path);
+  }
+  index.entities.set(normalizedPath, note.path);
+  for (const alias of note.aliases) {
+    const normalizedAlias = normalizeTarget2(alias);
+    if (!index.entities.has(normalizedAlias)) {
+      index.entities.set(normalizedAlias, note.path);
+    }
+  }
+  for (const tag of note.tags) {
+    if (!index.tags.has(tag)) {
+      index.tags.set(tag, /* @__PURE__ */ new Set());
+    }
+    index.tags.get(tag).add(note.path);
+  }
+  for (const link of note.outlinks) {
+    const normalizedTarget = normalizeTarget2(link.target);
+    const targetPath = index.entities.get(normalizedTarget);
+    const key = targetPath ? normalizeNotePath2(targetPath) : normalizedTarget;
+    if (!index.backlinks.has(key)) {
+      index.backlinks.set(key, []);
+    }
+    index.backlinks.get(key).push({
+      source: note.path,
+      line: link.line
+    });
+  }
+}
+async function upsertNote(index, vaultPath2, notePath) {
+  try {
+    const existed = index.notes.has(notePath);
+    if (existed) {
+      removeNoteFromIndex(index, notePath);
+    }
+    const fullPath = path6.join(vaultPath2, notePath);
+    const fs31 = await import("fs/promises");
+    const stats = await fs31.stat(fullPath);
+    const vaultFile = {
+      path: notePath,
+      absolutePath: fullPath,
+      modified: stats.mtime
+    };
+    const note = await parseNote(vaultFile);
+    addNoteToIndex(index, note);
+    return {
+      success: true,
+      action: existed ? "updated" : "added",
+      path: notePath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      action: "unchanged",
+      path: notePath,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+function deleteNote(index, notePath) {
+  const removed = removeNoteFromIndex(index, notePath);
+  return {
+    success: removed,
+    action: removed ? "removed" : "unchanged",
+    path: notePath
+  };
+}
+
+// src/core/read/watch/batchProcessor.ts
+var DEFAULT_CONCURRENCY = 4;
+var YIELD_INTERVAL = 10;
+async function processBatch(index, vaultPath2, batch, options = {}) {
+  const { concurrency = DEFAULT_CONCURRENCY, onProgress, onError } = options;
+  const startTime = Date.now();
+  const results = [];
+  let successful = 0;
+  let failed = 0;
+  let processed = 0;
+  const events = batch.events;
+  const total = events.length;
+  if (total === 0) {
+    return {
+      total: 0,
+      successful: 0,
+      failed: 0,
+      results: [],
+      durationMs: 0
+    };
+  }
+  console.error(`[flywheel] Processing ${total} file events`);
+  for (let i = 0; i < events.length; i += concurrency) {
+    const chunk = events.slice(i, i + concurrency);
+    const chunkResults = await Promise.allSettled(
+      chunk.map(async (event) => {
+        const relativePath = getRelativePath(vaultPath2, event.path);
+        if (event.type === "delete") {
+          return deleteNote(index, relativePath);
+        } else {
+          return upsertNote(index, vaultPath2, relativePath);
+        }
+      })
+    );
+    for (let j = 0; j < chunkResults.length; j++) {
+      const result = chunkResults[j];
+      processed++;
+      if (result.status === "fulfilled") {
+        results.push(result.value);
+        if (result.value.success) {
+          successful++;
+        } else {
+          failed++;
+          if (result.value.error && onError) {
+            onError(result.value.path, result.value.error);
+          }
+        }
+      } else {
+        failed++;
+        const event = chunk[j];
+        const relativePath = getRelativePath(vaultPath2, event.path);
+        const error = result.reason instanceof Error ? result.reason : new Error(String(result.reason));
+        results.push({
+          success: false,
+          action: "unchanged",
+          path: relativePath,
+          error
+        });
+        onError?.(relativePath, error);
+      }
+    }
+    onProgress?.(processed, total);
+    if (processed % YIELD_INTERVAL === 0 && processed < total) {
+      await new Promise((resolve2) => setImmediate(resolve2));
+    }
+  }
+  const durationMs = Date.now() - startTime;
+  console.error(`[flywheel] Processed ${successful}/${total} files in ${durationMs}ms`);
+  return {
+    total,
+    successful,
+    failed,
+    results,
+    durationMs
+  };
+}
+
 // src/core/read/watch/index.ts
 function createVaultWatcher(options) {
   const { vaultPath: vaultPath2, onBatch, onStateChange, onError } = options;
@@ -3097,31 +3299,31 @@ function createVaultWatcher(options) {
         usePolling: config.usePolling,
         interval: config.usePolling ? config.pollInterval : void 0
       });
-      watcher.on("add", (path30) => {
-        console.error(`[flywheel] RAW EVENT: add ${path30}`);
-        if (shouldWatch(path30, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: add ${path30}`);
-          eventQueue.push("add", path30);
+      watcher.on("add", (path31) => {
+        console.error(`[flywheel] RAW EVENT: add ${path31}`);
+        if (shouldWatch(path31, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: add ${path31}`);
+          eventQueue.push("add", path31);
         } else {
-          console.error(`[flywheel] FILTERED: add ${path30}`);
+          console.error(`[flywheel] FILTERED: add ${path31}`);
         }
       });
-      watcher.on("change", (path30) => {
-        console.error(`[flywheel] RAW EVENT: change ${path30}`);
-        if (shouldWatch(path30, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: change ${path30}`);
-          eventQueue.push("change", path30);
+      watcher.on("change", (path31) => {
+        console.error(`[flywheel] RAW EVENT: change ${path31}`);
+        if (shouldWatch(path31, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: change ${path31}`);
+          eventQueue.push("change", path31);
         } else {
-          console.error(`[flywheel] FILTERED: change ${path30}`);
+          console.error(`[flywheel] FILTERED: change ${path31}`);
         }
       });
-      watcher.on("unlink", (path30) => {
-        console.error(`[flywheel] RAW EVENT: unlink ${path30}`);
-        if (shouldWatch(path30, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: unlink ${path30}`);
-          eventQueue.push("unlink", path30);
+      watcher.on("unlink", (path31) => {
+        console.error(`[flywheel] RAW EVENT: unlink ${path31}`);
+        if (shouldWatch(path31, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: unlink ${path31}`);
+          eventQueue.push("unlink", path31);
         } else {
-          console.error(`[flywheel] FILTERED: unlink ${path30}`);
+          console.error(`[flywheel] FILTERED: unlink ${path31}`);
         }
       });
       watcher.on("ready", () => {
@@ -3725,7 +3927,7 @@ function getExtendedDashboardData(stateDb2) {
 
 // src/core/write/git.ts
 import { simpleGit, CheckRepoActions } from "simple-git";
-import path6 from "path";
+import path7 from "path";
 import fs6 from "fs/promises";
 import {
   setWriteState,
@@ -3779,7 +3981,7 @@ function clearLastMutationCommit() {
   }
 }
 async function checkGitLock(vaultPath2) {
-  const lockPath = path6.join(vaultPath2, ".git/index.lock");
+  const lockPath = path7.join(vaultPath2, ".git/index.lock");
   try {
     const stat3 = await fs6.stat(lockPath);
     const ageMs = Date.now() - stat3.mtimeMs;
@@ -3802,7 +4004,7 @@ async function isGitRepo(vaultPath2) {
   }
 }
 async function checkLockFile(vaultPath2) {
-  const lockPath = path6.join(vaultPath2, ".git/index.lock");
+  const lockPath = path7.join(vaultPath2, ".git/index.lock");
   try {
     const stat3 = await fs6.stat(lockPath);
     const ageMs = Date.now() - stat3.mtimeMs;
@@ -3852,7 +4054,7 @@ async function commitChange(vaultPath2, filePath, messagePrefix, retryConfig = D
         }
       }
       await git.add(filePath);
-      const fileName = path6.basename(filePath);
+      const fileName = path7.basename(filePath);
       const commitMessage = `${messagePrefix} Update ${fileName}`;
       const result = await git.commit(commitMessage);
       if (result.commit) {
@@ -4046,7 +4248,7 @@ function setHintsStateDb(stateDb2) {
 
 // src/core/shared/recency.ts
 import { readdir, readFile, stat } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 import {
   getEntityName,
   recordEntityMention,
@@ -4068,9 +4270,9 @@ async function* walkMarkdownFiles(dir, baseDir) {
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path7.join(dir, entry.name);
-      const relativePath = path7.relative(baseDir, fullPath);
-      const topFolder = relativePath.split(path7.sep)[0];
+      const fullPath = path8.join(dir, entry.name);
+      const relativePath = path8.relative(baseDir, fullPath);
+      const topFolder = relativePath.split(path8.sep)[0];
       if (EXCLUDED_FOLDERS.has(topFolder)) {
         continue;
       }
@@ -4950,7 +5152,7 @@ function tokenize(text) {
 
 // src/core/shared/cooccurrence.ts
 import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 var DEFAULT_MIN_COOCCURRENCE = 2;
 var EXCLUDED_FOLDERS2 = /* @__PURE__ */ new Set([
   "templates",
@@ -4984,9 +5186,9 @@ async function* walkMarkdownFiles2(dir, baseDir) {
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path8.join(dir, entry.name);
-      const relativePath = path8.relative(baseDir, fullPath);
-      const topFolder = relativePath.split(path8.sep)[0];
+      const fullPath = path9.join(dir, entry.name);
+      const relativePath = path9.relative(baseDir, fullPath);
+      const topFolder = relativePath.split(path9.sep)[0];
       if (EXCLUDED_FOLDERS2.has(topFolder)) {
         continue;
       }
@@ -5249,9 +5451,11 @@ function processWikilinks(content, notePath) {
   const resolved = resolveAliasWikilinks(content, sortedEntities, {
     caseInsensitive: true
   });
+  const step1LinkedEntities = new Set(resolved.linkedEntities.map((e) => e.toLowerCase()));
   const result = applyWikilinks(resolved.content, sortedEntities, {
     firstOccurrenceOnly: true,
-    caseInsensitive: true
+    caseInsensitive: true,
+    alreadyLinked: step1LinkedEntities
   });
   const implicitEnabled = moduleConfig?.implicit_detection !== false;
   const validPatterns = new Set(ALL_IMPLICIT_PATTERNS);
@@ -6298,11 +6502,11 @@ function countFTS5Mentions(term) {
 }
 
 // src/core/read/taskCache.ts
-import * as path10 from "path";
+import * as path11 from "path";
 
 // src/tools/read/tasks.ts
 import * as fs8 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 var TASK_REGEX = /^(\s*)- \[([ xX\-])\]\s+(.+)$/;
 var TAG_REGEX2 = /#([a-zA-Z][a-zA-Z0-9_/-]*)/g;
 var DATE_REGEX = /\b(\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}\/\d{2,4})\b/;
@@ -6371,7 +6575,7 @@ async function getAllTasks(index, vaultPath2, options = {}) {
   const allTasks = [];
   for (const note of index.notes.values()) {
     if (folder && !note.path.startsWith(folder)) continue;
-    const absolutePath = path9.join(vaultPath2, note.path);
+    const absolutePath = path10.join(vaultPath2, note.path);
     const tasks = await extractTasksFromNote(note.path, absolutePath);
     allTasks.push(...tasks);
   }
@@ -6415,7 +6619,7 @@ async function getAllTasks(index, vaultPath2, options = {}) {
 async function getTasksFromNote(index, notePath, vaultPath2, excludeTags = []) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path9.join(vaultPath2, notePath);
+  const absolutePath = path10.join(vaultPath2, notePath);
   let tasks = await extractTasksFromNote(notePath, absolutePath);
   if (excludeTags.length > 0) {
     tasks = tasks.filter(
@@ -6507,7 +6711,7 @@ async function buildTaskCache(vaultPath2, index, excludeTags) {
     }
     const allRows = [];
     for (const notePath of notePaths) {
-      const absolutePath = path10.join(vaultPath2, notePath);
+      const absolutePath = path11.join(vaultPath2, notePath);
       const tasks = await extractTasksFromNote(notePath, absolutePath);
       for (const task of tasks) {
         if (excludeTags?.length && excludeTags.some((t) => task.tags.includes(t))) {
@@ -6549,7 +6753,7 @@ async function buildTaskCache(vaultPath2, index, excludeTags) {
 async function updateTaskCacheForFile(vaultPath2, relativePath) {
   if (!db3) return;
   db3.prepare("DELETE FROM tasks WHERE path = ?").run(relativePath);
-  const absolutePath = path10.join(vaultPath2, relativePath);
+  const absolutePath = path11.join(vaultPath2, relativePath);
   const tasks = await extractTasksFromNote(relativePath, absolutePath);
   if (tasks.length > 0) {
     const insertStmt = db3.prepare(`
@@ -6689,7 +6893,7 @@ import { openStateDb, scanVaultEntities as scanVaultEntities3, getSessionId, get
 
 // src/tools/read/graph.ts
 import * as fs9 from "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 import { z } from "zod";
 
 // src/core/read/constants.ts
@@ -6973,7 +7177,7 @@ function requireIndex() {
 // src/tools/read/graph.ts
 async function getContext(vaultPath2, sourcePath, line, contextLines = 1) {
   try {
-    const fullPath = path11.join(vaultPath2, sourcePath);
+    const fullPath = path12.join(vaultPath2, sourcePath);
     const content = await fs9.promises.readFile(fullPath, "utf-8");
     const allLines = content.split("\n");
     let fmLines = 0;
@@ -7287,14 +7491,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path30] of entities) {
+    for (const [name, path31] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path30;
+        return path31;
       }
     }
-    for (const [name, path30] of entities) {
+    for (const [name, path31] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path30;
+        return path31;
       }
     }
     return void 0;
@@ -8271,8 +8475,8 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       daily_counts: z3.record(z3.number())
     }).describe("Activity summary for the last 7 days")
   };
-  function isPeriodicNote2(path30) {
-    const filename = path30.split("/").pop() || "";
+  function isPeriodicNote2(path31) {
+    const filename = path31.split("/").pop() || "";
     const nameWithoutExt = filename.replace(/\.md$/, "");
     const patterns = [
       /^\d{4}-\d{2}-\d{2}$/,
@@ -8287,7 +8491,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       // YYYY (yearly)
     ];
     const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
-    const folder = path30.split("/")[0]?.toLowerCase() || "";
+    const folder = path31.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   server2.registerTool(
@@ -8695,7 +8899,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
 
 // src/tools/read/system.ts
 import * as fs11 from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 import { z as z5 } from "zod";
 import { scanVaultEntities as scanVaultEntities2, getEntityIndexFromDb as getEntityIndexFromDb2 } from "@velvetmonkey/vault-core";
 
@@ -8995,7 +9199,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
           continue;
         }
         try {
-          const fullPath = path12.join(vaultPath2, note.path);
+          const fullPath = path13.join(vaultPath2, note.path);
           const content = await fs11.promises.readFile(fullPath, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
@@ -9111,7 +9315,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
       let wordCount;
       if (include_word_count) {
         try {
-          const fullPath = path12.join(vaultPath2, resolvedPath);
+          const fullPath = path13.join(vaultPath2, resolvedPath);
           const content = await fs11.promises.readFile(fullPath, "utf-8");
           wordCount = content.split(/\s+/).filter((w) => w.length > 0).length;
         } catch {
@@ -9342,7 +9546,7 @@ import { z as z6 } from "zod";
 
 // src/tools/read/structure.ts
 import * as fs12 from "fs";
-import * as path13 from "path";
+import * as path14 from "path";
 var HEADING_REGEX2 = /^(#{1,6})\s+(.+)$/;
 function extractHeadings(content) {
   const lines = content.split("\n");
@@ -9396,7 +9600,7 @@ function buildSections(headings, totalLines) {
 async function getNoteStructure(index, notePath, vaultPath2) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path13.join(vaultPath2, notePath);
+  const absolutePath = path14.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs12.promises.readFile(absolutePath, "utf-8");
@@ -9419,7 +9623,7 @@ async function getNoteStructure(index, notePath, vaultPath2) {
 async function getSectionContent(index, notePath, headingText, vaultPath2, includeSubheadings = true) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path13.join(vaultPath2, notePath);
+  const absolutePath = path14.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs12.promises.readFile(absolutePath, "utf-8");
@@ -9461,7 +9665,7 @@ async function findSections(index, headingPattern, vaultPath2, folder) {
   const results = [];
   for (const note of index.notes.values()) {
     if (folder && !note.path.startsWith(folder)) continue;
-    const absolutePath = path13.join(vaultPath2, note.path);
+    const absolutePath = path14.join(vaultPath2, note.path);
     let content;
     try {
       content = await fs12.promises.readFile(absolutePath, "utf-8");
@@ -9495,18 +9699,18 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         include_content: z6.boolean().default(false).describe("Include the text content under each top-level section")
       }
     },
-    async ({ path: path30, include_content }) => {
+    async ({ path: path31, include_content }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path30, vaultPath2);
+      const result = await getNoteStructure(index, path31, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path30 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path31 }, null, 2) }]
         };
       }
       if (include_content) {
         for (const section of result.sections) {
-          const sectionResult = await getSectionContent(index, path30, section.heading.text, vaultPath2, true);
+          const sectionResult = await getSectionContent(index, path31, section.heading.text, vaultPath2, true);
           if (sectionResult) {
             section.content = sectionResult.content;
           }
@@ -9528,15 +9732,15 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         include_subheadings: z6.boolean().default(true).describe("Include content under subheadings")
       }
     },
-    async ({ path: path30, heading, include_subheadings }) => {
+    async ({ path: path31, heading, include_subheadings }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path30, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path31, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path30,
+            path: path31,
             heading
           }, null, 2) }]
         };
@@ -9590,16 +9794,16 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         offset: z6.coerce.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path30, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
+    async ({ path: path31, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
       const limit = Math.min(requestedLimit ?? 25, MAX_LIMIT);
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const config = getConfig();
-      if (path30) {
-        const result2 = await getTasksFromNote(index, path30, vaultPath2, config.exclude_task_tags || []);
+      if (path31) {
+        const result2 = await getTasksFromNote(index, path31, vaultPath2, config.exclude_task_tags || []);
         if (!result2) {
           return {
-            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path30 }, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path31 }, null, 2) }]
           };
         }
         let filtered = result2;
@@ -9609,7 +9813,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         const paged2 = filtered.slice(offset, offset + limit);
         return {
           content: [{ type: "text", text: JSON.stringify({
-            path: path30,
+            path: path31,
             total_count: filtered.length,
             returned_count: paged2.length,
             open: result2.filter((t) => t.status === "open").length,
@@ -9765,7 +9969,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
 // src/tools/read/migrations.ts
 import { z as z7 } from "zod";
 import * as fs13 from "fs/promises";
-import * as path14 from "path";
+import * as path15 from "path";
 import matter2 from "gray-matter";
 function getNotesInFolder(index, folder) {
   const notes = [];
@@ -9778,7 +9982,7 @@ function getNotesInFolder(index, folder) {
   return notes;
 }
 async function readFileContent(notePath, vaultPath2) {
-  const fullPath = path14.join(vaultPath2, notePath);
+  const fullPath = path15.join(vaultPath2, notePath);
   try {
     return await fs13.readFile(fullPath, "utf-8");
   } catch {
@@ -9786,7 +9990,7 @@ async function readFileContent(notePath, vaultPath2) {
   }
 }
 async function writeFileContent(notePath, vaultPath2, content) {
-  const fullPath = path14.join(vaultPath2, notePath);
+  const fullPath = path15.join(vaultPath2, notePath);
   try {
     await fs13.writeFile(fullPath, content, "utf-8");
     return true;
@@ -9967,7 +10171,7 @@ function registerMigrationTools(server2, getIndex, getVaultPath) {
 
 // src/tools/read/graphAnalysis.ts
 import fs14 from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 import { z as z8 } from "zod";
 
 // src/tools/read/schema.ts
@@ -10729,7 +10933,7 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb,
           const scored = allNotes.map((note) => {
             let wordCount = 0;
             try {
-              const content = fs14.readFileSync(path15.join(vaultPath2, note.path), "utf-8");
+              const content = fs14.readFileSync(path16.join(vaultPath2, note.path), "utf-8");
               const body = content.replace(/^---[\s\S]*?---\n?/, "");
               wordCount = body.split(/\s+/).filter((w) => w.length > 0).length;
             } catch {
@@ -11309,12 +11513,12 @@ import { z as z10 } from "zod";
 
 // src/tools/read/bidirectional.ts
 import * as fs15 from "fs/promises";
-import * as path16 from "path";
+import * as path17 from "path";
 import matter3 from "gray-matter";
 var PROSE_PATTERN_REGEX = /^([A-Za-z][A-Za-z0-9 _-]*):\s*(?:\[\[([^\]]+)\]\]|"([^"]+)"|([^\n]+?))\s*$/gm;
 var CODE_BLOCK_REGEX2 = /```[\s\S]*?```|`[^`\n]+`/g;
 async function readFileContent2(notePath, vaultPath2) {
-  const fullPath = path16.join(vaultPath2, notePath);
+  const fullPath = path17.join(vaultPath2, notePath);
   try {
     return await fs15.readFile(fullPath, "utf-8");
   } catch {
@@ -11493,10 +11697,10 @@ async function suggestWikilinksInFrontmatter(index, notePath, vaultPath2) {
 
 // src/tools/read/computed.ts
 import * as fs16 from "fs/promises";
-import * as path17 from "path";
+import * as path18 from "path";
 import matter4 from "gray-matter";
 async function readFileContent3(notePath, vaultPath2) {
-  const fullPath = path17.join(vaultPath2, notePath);
+  const fullPath = path18.join(vaultPath2, notePath);
   try {
     return await fs16.readFile(fullPath, "utf-8");
   } catch {
@@ -11504,7 +11708,7 @@ async function readFileContent3(notePath, vaultPath2) {
   }
 }
 async function getFileStats(notePath, vaultPath2) {
-  const fullPath = path17.join(vaultPath2, notePath);
+  const fullPath = path18.join(vaultPath2, notePath);
   try {
     const stats = await fs16.stat(fullPath);
     return {
@@ -11775,7 +11979,7 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath, getConfi
 init_writer();
 import { z as z11 } from "zod";
 import fs20 from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 
 // src/core/write/validator.ts
 var TIMESTAMP_PATTERN = /^\*\*\d{2}:\d{2}\*\*/;
@@ -11978,7 +12182,7 @@ function runValidationPipeline(content, format, options = {}) {
 // src/core/write/mutation-helpers.ts
 init_writer();
 import fs19 from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 init_constants();
 init_writer();
 function formatMcpResult(result) {
@@ -12027,7 +12231,7 @@ async function handleGitCommit(vaultPath2, notePath, commit, prefix) {
   return info;
 }
 async function ensureFileExists(vaultPath2, notePath) {
-  const fullPath = path19.join(vaultPath2, notePath);
+  const fullPath = path20.join(vaultPath2, notePath);
   try {
     await fs19.access(fullPath);
     return null;
@@ -12086,7 +12290,7 @@ async function withVaultFile(options, operation) {
     if ("error" in result) {
       return formatMcpResult(result.error);
     }
-    const fullPath = path19.join(vaultPath2, notePath);
+    const fullPath = path20.join(vaultPath2, notePath);
     const statBefore = await fs19.stat(fullPath);
     if (statBefore.mtimeMs !== result.mtimeMs) {
       console.warn(`[withVaultFile] External modification detected on ${notePath}, re-reading and retrying`);
@@ -12149,10 +12353,10 @@ async function withVaultFrontmatter(options, operation) {
 
 // src/tools/write/mutations.ts
 async function createNoteFromTemplate(vaultPath2, notePath, config) {
-  const fullPath = path20.join(vaultPath2, notePath);
-  await fs20.mkdir(path20.dirname(fullPath), { recursive: true });
+  const fullPath = path21.join(vaultPath2, notePath);
+  await fs20.mkdir(path21.dirname(fullPath), { recursive: true });
   const templates = config.templates || {};
-  const filename = path20.basename(notePath, ".md").toLowerCase();
+  const filename = path21.basename(notePath, ".md").toLowerCase();
   let templatePath;
   const dailyPattern = /^\d{4}-\d{2}-\d{2}/;
   const weeklyPattern = /^\d{4}-W\d{2}/;
@@ -12173,10 +12377,10 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   let templateContent;
   if (templatePath) {
     try {
-      const absTemplatePath = path20.join(vaultPath2, templatePath);
+      const absTemplatePath = path21.join(vaultPath2, templatePath);
       templateContent = await fs20.readFile(absTemplatePath, "utf-8");
     } catch {
-      const title = path20.basename(notePath, ".md");
+      const title = path21.basename(notePath, ".md");
       templateContent = `---
 ---
 
@@ -12185,7 +12389,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
       templatePath = void 0;
     }
   } else {
-    const title = path20.basename(notePath, ".md");
+    const title = path21.basename(notePath, ".md");
     templateContent = `---
 ---
 
@@ -12194,7 +12398,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   }
   const now = /* @__PURE__ */ new Date();
   const dateStr = now.toISOString().split("T")[0];
-  templateContent = templateContent.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, path20.basename(notePath, ".md"));
+  templateContent = templateContent.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, path21.basename(notePath, ".md"));
   const matter9 = (await import("gray-matter")).default;
   const parsed = matter9(templateContent);
   if (!parsed.data.date) {
@@ -12234,7 +12438,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 = path21.join(vaultPath2, notePath);
         try {
           await fs20.access(fullPath);
         } catch {
@@ -12693,7 +12897,7 @@ Example: vault_update_frontmatter({ path: "projects/alpha.md", frontmatter: { st
 init_writer();
 import { z as z14 } from "zod";
 import fs21 from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 function registerNoteTools(server2, vaultPath2, getIndex) {
   server2.tool(
     "vault_create_note",
@@ -12716,23 +12920,23 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
         if (!validatePath(vaultPath2, notePath)) {
           return formatMcpResult(errorResult(notePath, "Invalid path: path traversal not allowed"));
         }
-        const fullPath = path21.join(vaultPath2, notePath);
+        const fullPath = path22.join(vaultPath2, notePath);
         const existsCheck = await ensureFileExists(vaultPath2, notePath);
         if (existsCheck === null && !overwrite) {
           return formatMcpResult(errorResult(notePath, `File already exists: ${notePath}. Use overwrite=true to replace.`));
         }
-        const dir = path21.dirname(fullPath);
+        const dir = path22.dirname(fullPath);
         await fs21.mkdir(dir, { recursive: true });
         let effectiveContent = content;
         let effectiveFrontmatter = frontmatter;
         if (template) {
-          const templatePath = path21.join(vaultPath2, template);
+          const templatePath = path22.join(vaultPath2, template);
           try {
             const raw = await fs21.readFile(templatePath, "utf-8");
             const matter9 = (await import("gray-matter")).default;
             const parsed = matter9(raw);
             const dateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-            const title = path21.basename(notePath, ".md");
+            const title = path22.basename(notePath, ".md");
             let templateContent = parsed.content.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, title);
             if (content) {
               templateContent = templateContent.trimEnd() + "\n\n" + content;
@@ -12751,7 +12955,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
           effectiveFrontmatter.created = now.toISOString();
         }
         const warnings = [];
-        const noteName = path21.basename(notePath, ".md");
+        const noteName = path22.basename(notePath, ".md");
         const existingAliases = Array.isArray(effectiveFrontmatter?.aliases) ? effectiveFrontmatter.aliases.filter((a) => typeof a === "string") : [];
         const preflight = await checkPreflightSimilarity(noteName);
         if (preflight.existingEntity) {
@@ -12868,7 +13072,7 @@ ${sources}`;
           }
           return formatMcpResult(errorResult(notePath, previewLines.join("\n")));
         }
-        const fullPath = path21.join(vaultPath2, notePath);
+        const fullPath = path22.join(vaultPath2, notePath);
         await fs21.unlink(fullPath);
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Flywheel:Delete]");
         const message = backlinkWarning ? `Deleted note: ${notePath}
@@ -12888,7 +13092,7 @@ Warning: ${backlinkWarning}` : `Deleted note: ${notePath}`;
 init_writer();
 import { z as z15 } from "zod";
 import fs22 from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 import matter6 from "gray-matter";
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -12907,7 +13111,7 @@ function extractWikilinks2(content) {
   return wikilinks;
 }
 function getTitleFromPath(filePath) {
-  return path22.basename(filePath, ".md");
+  return path23.basename(filePath, ".md");
 }
 async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   const results = [];
@@ -12916,7 +13120,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
     const files = [];
     const entries = await fs22.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path22.join(dir, entry.name);
+      const fullPath = path23.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         files.push(...await scanDir(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -12927,7 +13131,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   }
   const allFiles = await scanDir(vaultPath2);
   for (const filePath of allFiles) {
-    const relativePath = path22.relative(vaultPath2, filePath);
+    const relativePath = path23.relative(vaultPath2, filePath);
     const content = await fs22.readFile(filePath, "utf-8");
     const wikilinks = extractWikilinks2(content);
     const matchingLinks = [];
@@ -12947,7 +13151,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   return results;
 }
 async function updateBacklinksInFile(vaultPath2, filePath, oldTitles, newTitle) {
-  const fullPath = path22.join(vaultPath2, filePath);
+  const fullPath = path23.join(vaultPath2, filePath);
   const raw = await fs22.readFile(fullPath, "utf-8");
   const parsed = matter6(raw);
   let content = parsed.content;
@@ -13014,8 +13218,8 @@ function registerMoveNoteTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const oldFullPath = path22.join(vaultPath2, oldPath);
-        const newFullPath = path22.join(vaultPath2, newPath);
+        const oldFullPath = path23.join(vaultPath2, oldPath);
+        const newFullPath = path23.join(vaultPath2, newPath);
         try {
           await fs22.access(oldFullPath);
         } catch {
@@ -13065,7 +13269,7 @@ function registerMoveNoteTools(server2, vaultPath2) {
             }
           }
         }
-        const destDir = path22.dirname(newFullPath);
+        const destDir = path23.dirname(newFullPath);
         await fs22.mkdir(destDir, { recursive: true });
         await fs22.rename(oldFullPath, newFullPath);
         let gitCommit;
@@ -13151,10 +13355,10 @@ function registerMoveNoteTools(server2, vaultPath2) {
         if (sanitizedTitle !== newTitle) {
           console.error(`[Flywheel] Title sanitized: "${newTitle}" \u2192 "${sanitizedTitle}"`);
         }
-        const fullPath = path22.join(vaultPath2, notePath);
-        const dir = path22.dirname(notePath);
-        const newPath = dir === "." ? `${sanitizedTitle}.md` : path22.join(dir, `${sanitizedTitle}.md`);
-        const newFullPath = path22.join(vaultPath2, newPath);
+        const fullPath = path23.join(vaultPath2, notePath);
+        const dir = path23.dirname(notePath);
+        const newPath = dir === "." ? `${sanitizedTitle}.md` : path23.join(dir, `${sanitizedTitle}.md`);
+        const newFullPath = path23.join(vaultPath2, newPath);
         try {
           await fs22.access(fullPath);
         } catch {
@@ -13511,7 +13715,7 @@ init_schema();
 // src/core/write/policy/parser.ts
 init_schema();
 import fs24 from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 import matter7 from "gray-matter";
 function parseYaml(content) {
   const parsed = matter7(`---
@@ -13560,13 +13764,13 @@ async function loadPolicyFile(filePath) {
   }
 }
 async function loadPolicy(vaultPath2, policyName) {
-  const policiesDir = path23.join(vaultPath2, ".claude", "policies");
-  const policyPath = path23.join(policiesDir, `${policyName}.yaml`);
+  const policiesDir = path24.join(vaultPath2, ".claude", "policies");
+  const policyPath = path24.join(policiesDir, `${policyName}.yaml`);
   try {
     await fs24.access(policyPath);
     return loadPolicyFile(policyPath);
   } catch {
-    const ymlPath = path23.join(policiesDir, `${policyName}.yml`);
+    const ymlPath = path24.join(policiesDir, `${policyName}.yml`);
     try {
       await fs24.access(ymlPath);
       return loadPolicyFile(ymlPath);
@@ -13707,7 +13911,7 @@ init_conditions();
 init_schema();
 init_writer();
 import fs26 from "fs/promises";
-import path25 from "path";
+import path26 from "path";
 init_constants();
 async function executeStep(step, vaultPath2, context, conditionResults) {
   const { execute, reason } = shouldStepExecute(step.when, conditionResults);
@@ -13781,7 +13985,7 @@ async function executeAddToSection(params, vaultPath2, context) {
   const preserveListNesting = params.preserveListNesting !== false;
   const suggestOutgoingLinks = params.suggestOutgoingLinks !== false;
   const maxSuggestions = Number(params.maxSuggestions) || 3;
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13821,7 +14025,7 @@ async function executeRemoveFromSection(params, vaultPath2) {
   const pattern = String(params.pattern || "");
   const mode = params.mode || "first";
   const useRegex = Boolean(params.useRegex);
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13852,7 +14056,7 @@ async function executeReplaceInSection(params, vaultPath2, context) {
   const mode = params.mode || "first";
   const useRegex = Boolean(params.useRegex);
   const skipWikilinks = Boolean(params.skipWikilinks);
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13895,7 +14099,7 @@ async function executeCreateNote(params, vaultPath2, context) {
   if (!validatePath(vaultPath2, notePath)) {
     return { success: false, message: "Invalid path: path traversal not allowed", path: notePath };
   }
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
     if (!overwrite) {
@@ -13903,7 +14107,7 @@ async function executeCreateNote(params, vaultPath2, context) {
     }
   } catch {
   }
-  const dir = path25.dirname(fullPath);
+  const dir = path26.dirname(fullPath);
   await fs26.mkdir(dir, { recursive: true });
   const { content: processedContent } = maybeApplyWikilinks(content, skipWikilinks, notePath);
   await writeVaultFile(vaultPath2, notePath, processedContent, frontmatter);
@@ -13923,7 +14127,7 @@ async function executeDeleteNote(params, vaultPath2) {
   if (!validatePath(vaultPath2, notePath)) {
     return { success: false, message: "Invalid path: path traversal not allowed", path: notePath };
   }
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13940,7 +14144,7 @@ async function executeToggleTask(params, vaultPath2) {
   const notePath = String(params.path || "");
   const task = String(params.task || "");
   const section = params.section ? String(params.section) : void 0;
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -13983,7 +14187,7 @@ async function executeAddTask(params, vaultPath2, context) {
   const completed = Boolean(params.completed);
   const skipWikilinks = Boolean(params.skipWikilinks);
   const preserveListNesting = params.preserveListNesting !== false;
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -14020,7 +14224,7 @@ async function executeAddTask(params, vaultPath2, context) {
 async function executeUpdateFrontmatter(params, vaultPath2) {
   const notePath = String(params.path || "");
   const updates = params.frontmatter || {};
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -14042,7 +14246,7 @@ async function executeAddFrontmatterField(params, vaultPath2) {
   const notePath = String(params.path || "");
   const key = String(params.key || "");
   const value = params.value;
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs26.access(fullPath);
   } catch {
@@ -14205,7 +14409,7 @@ async function executePolicy(policy, vaultPath2, variables, commit = false) {
 async function rollbackChanges(vaultPath2, originalContents, filesModified) {
   for (const filePath of filesModified) {
     const original = originalContents.get(filePath);
-    const fullPath = path25.join(vaultPath2, filePath);
+    const fullPath = path26.join(vaultPath2, filePath);
     if (original === null) {
       try {
         await fs26.unlink(fullPath);
@@ -14260,9 +14464,9 @@ async function previewPolicy(policy, vaultPath2, variables) {
 
 // src/core/write/policy/storage.ts
 import fs27 from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 function getPoliciesDir(vaultPath2) {
-  return path26.join(vaultPath2, ".claude", "policies");
+  return path27.join(vaultPath2, ".claude", "policies");
 }
 async function ensurePoliciesDir(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
@@ -14277,7 +14481,7 @@ async function listPolicies(vaultPath2) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
         continue;
       }
-      const filePath = path26.join(dir, file);
+      const filePath = path27.join(dir, file);
       const stat3 = await fs27.stat(filePath);
       const content = await fs27.readFile(filePath, "utf-8");
       const metadata = extractPolicyMetadata(content);
@@ -14302,7 +14506,7 @@ async function writePolicyRaw(vaultPath2, policyName, content, overwrite = false
   const dir = getPoliciesDir(vaultPath2);
   await ensurePoliciesDir(vaultPath2);
   const filename = `${policyName}.yaml`;
-  const filePath = path26.join(dir, filename);
+  const filePath = path27.join(dir, filename);
   if (!overwrite) {
     try {
       await fs27.access(filePath);
@@ -14846,7 +15050,7 @@ import { z as z20 } from "zod";
 
 // src/core/write/tagRename.ts
 import * as fs28 from "fs/promises";
-import * as path27 from "path";
+import * as path28 from "path";
 import matter8 from "gray-matter";
 import { getProtectedZones } from "@velvetmonkey/vault-core";
 function getNotesInFolder3(index, folder) {
@@ -14952,7 +15156,7 @@ async function renameTag(index, vaultPath2, oldTag, newTag, options) {
   const previews = [];
   let totalChanges = 0;
   for (const note of affectedNotes) {
-    const fullPath = path27.join(vaultPath2, note.path);
+    const fullPath = path28.join(vaultPath2, note.path);
     let fileContent;
     try {
       fileContent = await fs28.readFile(fullPath, "utf-8");
@@ -15590,8 +15794,8 @@ function getNoteAccessFrequency(stateDb2, daysBack = 30) {
       }
     }
   }
-  return Array.from(noteMap.entries()).map(([path30, stats]) => ({
-    path: path30,
+  return Array.from(noteMap.entries()).map(([path31, stats]) => ({
+    path: path31,
     access_count: stats.access_count,
     last_accessed: stats.last_accessed,
     tools_used: Array.from(stats.tools)
@@ -15744,7 +15948,7 @@ import { z as z25 } from "zod";
 
 // src/core/read/similarity.ts
 import * as fs29 from "fs";
-import * as path28 from "path";
+import * as path29 from "path";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
   "be",
@@ -15881,7 +16085,7 @@ function extractKeyTerms(content, maxTerms = 15) {
 }
 function findSimilarNotes(db4, vaultPath2, index, sourcePath, options = {}) {
   const limit = options.limit ?? 10;
-  const absPath = path28.join(vaultPath2, sourcePath);
+  const absPath = path29.join(vaultPath2, sourcePath);
   let content;
   try {
     content = fs29.readFileSync(absPath, "utf-8");
@@ -16009,7 +16213,7 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
         exclude_linked: z25.boolean().optional().describe("Exclude notes already linked to/from the source note (default: true)")
       }
     },
-    async ({ path: path30, limit, exclude_linked }) => {
+    async ({ path: path31, limit, exclude_linked }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const stateDb2 = getStateDb();
@@ -16018,10 +16222,10 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
           content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
         };
       }
-      if (!index.notes.has(path30)) {
+      if (!index.notes.has(path31)) {
         return {
           content: [{ type: "text", text: JSON.stringify({
-            error: `Note not found: ${path30}`,
+            error: `Note not found: ${path31}`,
             hint: "Use the full relative path including .md extension"
           }, null, 2) }]
         };
@@ -16032,12 +16236,12 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
       };
       const useHybrid = hasEmbeddingsIndex();
       const method = useHybrid ? "hybrid" : "bm25";
-      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path30, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path30, opts);
+      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path31, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path31, opts);
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
-            source: path30,
+            source: path31,
             method,
             exclude_linked: exclude_linked ?? true,
             count: results.length,
@@ -16275,6 +16479,7 @@ function registerMergeTools2(server2, getStateDb) {
 
 // src/index.ts
 import * as fs30 from "node:fs/promises";
+import { createHash as createHash2 } from "node:crypto";
 
 // src/resources/vault.ts
 function registerVaultResources(server2, getIndex) {
@@ -16885,6 +17090,7 @@ 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,
@@ -16916,8 +17122,8 @@ async function runPostIndexWork(index) {
               }
             } catch {
               try {
-                const dir = path29.dirname(event.path);
-                const base = path29.basename(event.path);
+                const dir = path30.dirname(event.path);
+                const base = path30.basename(event.path);
                 const resolvedDir = realpathSync(dir).replace(/\\/g, "/");
                 for (const prefix of vaultPrefixes) {
                   if (resolvedDir.startsWith(prefix + "/") || resolvedDir === prefix) {
@@ -16932,16 +17138,52 @@ async function runPostIndexWork(index) {
             }
           }
         }
-        serverLog("watcher", `Processing ${batch.events.length} file changes`);
+        const filteredEvents = [];
+        for (const event of batch.events) {
+          if (event.type === "delete") {
+            filteredEvents.push(event);
+            lastContentHashes.delete(event.path);
+            continue;
+          }
+          try {
+            const content = await fs30.readFile(path30.join(vaultPath, event.path), "utf-8");
+            const hash = createHash2("md5").update(content).digest("hex");
+            if (lastContentHashes.get(event.path) === hash) {
+              serverLog("watcher", `Hash unchanged, skipping: ${event.path}`);
+              continue;
+            }
+            lastContentHashes.set(event.path, hash);
+            filteredEvents.push(event);
+          } catch {
+            filteredEvents.push(event);
+          }
+        }
+        if (filteredEvents.length === 0) {
+          serverLog("watcher", "All files unchanged (hash gate), skipping batch");
+          return;
+        }
+        serverLog("watcher", `Processing ${filteredEvents.length} file changes`);
         const batchStart = Date.now();
-        const changedPaths = batch.events.map((e) => e.path);
+        const changedPaths = filteredEvents.map((e) => e.path);
         const tracker = createStepTracker();
         try {
-          tracker.start("index_rebuild", { files_changed: batch.events.length, changed_paths: changedPaths });
-          vaultIndex = await buildVaultIndex(vaultPath);
+          tracker.start("index_rebuild", { files_changed: filteredEvents.length, changed_paths: changedPaths });
+          if (!vaultIndex) {
+            vaultIndex = await buildVaultIndex(vaultPath);
+            serverLog("watcher", `Index rebuilt (full): ${vaultIndex.notes.size} notes, ${vaultIndex.entities.size} entities`);
+          } else {
+            const absoluteBatch = {
+              ...batch,
+              events: filteredEvents.map((e) => ({
+                ...e,
+                path: path30.join(vaultPath, e.path)
+              }))
+            };
+            const batchResult = await processBatch(vaultIndex, vaultPath, absoluteBatch);
+            serverLog("watcher", `Incremental: ${batchResult.successful}/${batchResult.total} files in ${batchResult.durationMs}ms`);
+          }
           setIndexState("ready");
           tracker.end({ note_count: vaultIndex.notes.size, entity_count: vaultIndex.entities.size, tag_count: vaultIndex.tags.size });
-          serverLog("watcher", `Index rebuilt: ${vaultIndex.notes.size} notes, ${vaultIndex.entities.size} entities`);
           const hubBefore = /* @__PURE__ */ new Map();
           if (stateDb) {
             const rows = stateDb.db.prepare("SELECT name, hub_score FROM entities").all();
@@ -16985,16 +17227,16 @@ async function runPostIndexWork(index) {
             serverLog("watcher", `Recency: failed: ${e}`);
           }
           if (hasEmbeddingsIndex()) {
-            tracker.start("note_embeddings", { files: batch.events.length });
+            tracker.start("note_embeddings", { files: filteredEvents.length });
             let embUpdated = 0;
             let embRemoved = 0;
-            for (const event of batch.events) {
+            for (const event of filteredEvents) {
               try {
                 if (event.type === "delete") {
                   removeEmbedding(event.path);
                   embRemoved++;
                 } else if (event.path.endsWith(".md")) {
-                  const absPath = path29.join(vaultPath, event.path);
+                  const absPath = path30.join(vaultPath, event.path);
                   await updateEmbedding(event.path, absPath);
                   embUpdated++;
                 }
@@ -17007,12 +17249,12 @@ async function runPostIndexWork(index) {
             tracker.skip("note_embeddings", "not built");
           }
           if (hasEntityEmbeddingsIndex() && stateDb) {
-            tracker.start("entity_embeddings", { files: batch.events.length });
+            tracker.start("entity_embeddings", { files: filteredEvents.length });
             let entEmbUpdated = 0;
             const entEmbNames = [];
             try {
               const allEntities = getAllEntitiesFromDb3(stateDb);
-              for (const event of batch.events) {
+              for (const event of filteredEvents) {
                 if (event.type === "delete" || !event.path.endsWith(".md")) continue;
                 const matching = allEntities.filter((e) => e.path === event.path);
                 for (const entity of matching) {
@@ -17046,10 +17288,10 @@ async function runPostIndexWork(index) {
           } else {
             tracker.skip("index_cache", "no stateDb");
           }
-          tracker.start("task_cache", { files: batch.events.length });
+          tracker.start("task_cache", { files: filteredEvents.length });
           let taskUpdated = 0;
           let taskRemoved = 0;
-          for (const event of batch.events) {
+          for (const event of filteredEvents) {
             try {
               if (event.type === "delete") {
                 removeTaskCacheForFile(event.path);
@@ -17063,11 +17305,11 @@ async function runPostIndexWork(index) {
           }
           tracker.end({ updated: taskUpdated, removed: taskRemoved });
           serverLog("watcher", `Task cache: ${taskUpdated} updated, ${taskRemoved} removed`);
-          tracker.start("forward_links", { files: batch.events.length });
+          tracker.start("forward_links", { files: filteredEvents.length });
           const forwardLinkResults = [];
           let totalResolved = 0;
           let totalDead = 0;
-          for (const event of batch.events) {
+          for (const event of filteredEvents) {
             if (event.type === "delete" || !event.path.endsWith(".md")) continue;
             try {
               const links = getForwardLinksForNote(vaultIndex, event.path);
@@ -17095,10 +17337,10 @@ async function runPostIndexWork(index) {
             links: forwardLinkResults
           });
           serverLog("watcher", `Forward links: ${totalResolved} resolved, ${totalDead} dead`);
-          tracker.start("wikilink_check", { files: batch.events.length });
+          tracker.start("wikilink_check", { files: filteredEvents.length });
           const trackedLinks = [];
           if (stateDb) {
-            for (const event of batch.events) {
+            for (const event of filteredEvents) {
               if (event.type === "delete" || !event.path.endsWith(".md")) continue;
               try {
                 const apps = getTrackedApplications(stateDb, event.path);
@@ -17109,13 +17351,13 @@ async function runPostIndexWork(index) {
           }
           tracker.end({ tracked: trackedLinks });
           serverLog("watcher", `Wikilink check: ${trackedLinks.reduce((s, t) => s + t.entities.length, 0)} tracked links in ${trackedLinks.length} files`);
-          tracker.start("implicit_feedback", { files: batch.events.length });
+          tracker.start("implicit_feedback", { files: filteredEvents.length });
           const feedbackResults = [];
           if (stateDb) {
-            for (const event of batch.events) {
+            for (const event of filteredEvents) {
               if (event.type === "delete" || !event.path.endsWith(".md")) continue;
               try {
-                const content = await fs30.readFile(path29.join(vaultPath, event.path), "utf-8");
+                const content = await fs30.readFile(path30.join(vaultPath, event.path), "utf-8");
                 const removed = processImplicitFeedback(stateDb, event.path, content);
                 for (const entity of removed) feedbackResults.push({ entity, file: event.path });
               } catch {
@@ -17132,12 +17374,12 @@ async function runPostIndexWork(index) {
               trigger: "watcher",
               duration_ms: duration,
               note_count: vaultIndex.notes.size,
-              files_changed: batch.events.length,
+              files_changed: filteredEvents.length,
               changed_paths: changedPaths,
               steps: tracker.steps
             });
           }
-          serverLog("watcher", `Batch complete: ${batch.events.length} files, ${duration}ms, ${tracker.steps.length} steps`);
+          serverLog("watcher", `Batch complete: ${filteredEvents.length} files, ${duration}ms, ${tracker.steps.length} steps`);
         } catch (err) {
           setIndexState("error");
           setIndexError(err instanceof Error ? err : new Error(String(err)));
@@ -17147,7 +17389,7 @@ async function runPostIndexWork(index) {
               trigger: "watcher",
               duration_ms: duration,
               success: false,
-              files_changed: batch.events.length,
+              files_changed: filteredEvents.length,
               changed_paths: changedPaths,
               error: err instanceof Error ? err.message : String(err),
               steps: tracker.steps