@velvetmonkey/flywheel-memory 2.0.139 → 2.0.140

package/dist/index.js

@@ -4595,6 +4595,8 @@ __export(proactiveQueue_exports, {
   enqueueProactiveSuggestions: () => enqueueProactiveSuggestions,
   expireStaleEntries: () => expireStaleEntries
 });
+import * as path12 from "path";
+import { statSync as statSync3 } from "fs";
 function enqueueProactiveSuggestions(stateDb2, entries) {
   if (entries.length === 0) return 0;
   const now = Date.now();
@@ -4620,7 +4622,7 @@ function enqueueProactiveSuggestions(stateDb2, entries) {
   }
   return enqueued;
 }
-async function drainProactiveQueue(stateDb2, vaultPath2, currentBatchPaths, config, applyFn) {
+async function drainProactiveQueue(stateDb2, vaultPath2, config, applyFn) {
   const result = {
     applied: [],
     expired: 0,
@@ -4652,7 +4654,14 @@ async function drainProactiveQueue(stateDb2, vaultPath2, currentBatchPaths, conf
     `SELECT COUNT(*) as cnt FROM wikilink_applications WHERE note_path = ? AND applied_at >= ?`
   );
   for (const [filePath, suggestions] of byFile) {
-    if (currentBatchPaths.has(filePath)) {
+    const fullPath = path12.join(vaultPath2, filePath);
+    try {
+      const mtime = statSync3(fullPath).mtimeMs;
+      if (Date.now() - mtime < MTIME_GUARD_MS) {
+        result.skippedActiveEdit += suggestions.length;
+        continue;
+      }
+    } catch {
       result.skippedActiveEdit += suggestions.length;
       continue;
     }
@@ -4698,12 +4707,13 @@ function expireStaleEntries(stateDb2) {
   ).run(Date.now());
   return result.changes;
 }
-var QUEUE_TTL_MS;
+var QUEUE_TTL_MS, MTIME_GUARD_MS;
 var init_proactiveQueue = __esm({
   "src/core/write/proactiveQueue.ts"() {
     "use strict";
     init_serverLog();
-    QUEUE_TTL_MS = 60 * 60 * 1e3;
+    QUEUE_TTL_MS = 6 * 60 * 60 * 1e3;
+    MTIME_GUARD_MS = 6e4;
   }
 });
 
@@ -4722,7 +4732,7 @@ var init_constants = __esm({
 
 // src/core/write/writer.ts
 import fs21 from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 import matter5 from "gray-matter";
 import { createHash as createHash2 } from "node:crypto";
 function isSensitivePath(filePath) {
@@ -5050,13 +5060,13 @@ function validatePath(vaultPath2, notePath) {
   if (notePath.startsWith("\\")) {
     return false;
   }
-  const resolvedVault = path22.resolve(vaultPath2);
-  const resolvedNote = path22.resolve(vaultPath2, notePath);
+  const resolvedVault = path23.resolve(vaultPath2);
+  const resolvedNote = path23.resolve(vaultPath2, notePath);
   return resolvedNote.startsWith(resolvedVault);
 }
 function sanitizeNotePath(notePath) {
-  const dir = path22.dirname(notePath);
-  let filename = path22.basename(notePath);
+  const dir = path23.dirname(notePath);
+  let filename = path23.basename(notePath);
   const ext = filename.endsWith(".md") ? ".md" : "";
   let stem2 = ext ? filename.slice(0, -ext.length) : filename;
   stem2 = stem2.replace(/\s+/g, "-");
@@ -5065,7 +5075,7 @@ function sanitizeNotePath(notePath) {
   stem2 = stem2.replace(/-{2,}/g, "-");
   stem2 = stem2.replace(/^-+|-+$/g, "");
   filename = stem2 + (ext || ".md");
-  return dir === "." ? filename : path22.join(dir, filename).replace(/\\/g, "/");
+  return dir === "." ? filename : path23.join(dir, filename).replace(/\\/g, "/");
 }
 async function validatePathSecure(vaultPath2, notePath) {
   if (notePath.startsWith("/")) {
@@ -5092,8 +5102,8 @@ async function validatePathSecure(vaultPath2, notePath) {
       reason: "Path traversal not allowed"
     };
   }
-  const resolvedVault = path22.resolve(vaultPath2);
-  const resolvedNote = path22.resolve(vaultPath2, notePath);
+  const resolvedVault = path23.resolve(vaultPath2);
+  const resolvedNote = path23.resolve(vaultPath2, notePath);
   if (!resolvedNote.startsWith(resolvedVault)) {
     return {
       valid: false,
@@ -5107,7 +5117,7 @@ async function validatePathSecure(vaultPath2, notePath) {
     };
   }
   try {
-    const fullPath = path22.join(vaultPath2, notePath);
+    const fullPath = path23.join(vaultPath2, notePath);
     try {
       await fs21.access(fullPath);
       const realPath = await fs21.realpath(fullPath);
@@ -5118,7 +5128,7 @@ async function validatePathSecure(vaultPath2, notePath) {
           reason: "Symlink target is outside vault"
         };
       }
-      const relativePath = path22.relative(realVaultPath, realPath);
+      const relativePath = path23.relative(realVaultPath, realPath);
       if (isSensitivePath(relativePath)) {
         return {
           valid: false,
@@ -5126,7 +5136,7 @@ async function validatePathSecure(vaultPath2, notePath) {
         };
       }
     } catch {
-      const parentDir = path22.dirname(fullPath);
+      const parentDir = path23.dirname(fullPath);
       try {
         await fs21.access(parentDir);
         const realParentPath = await fs21.realpath(parentDir);
@@ -5155,7 +5165,7 @@ async function readVaultFile(vaultPath2, notePath) {
   if (!validatePath(vaultPath2, notePath)) {
     throw new Error("Invalid path: path traversal not allowed");
   }
-  const fullPath = path22.join(vaultPath2, notePath);
+  const fullPath = path23.join(vaultPath2, notePath);
   const [rawContent, stat5] = await Promise.all([
     fs21.readFile(fullPath, "utf-8"),
     fs21.stat(fullPath)
@@ -5210,7 +5220,7 @@ async function writeVaultFile(vaultPath2, notePath, content, frontmatter, lineEn
   if (!validation.valid) {
     throw new Error(`Invalid path: ${validation.reason}`);
   }
-  const fullPath = path22.join(vaultPath2, notePath);
+  const fullPath = path23.join(vaultPath2, notePath);
   if (expectedHash) {
     const currentRaw = await fs21.readFile(fullPath, "utf-8");
     const currentHash = computeContentHash(currentRaw);
@@ -5610,8 +5620,8 @@ function createContext(variables = {}) {
     steps: {}
   };
 }
-function resolvePath(obj, path36) {
-  const parts = path36.split(".");
+function resolvePath(obj, path37) {
+  const parts = path37.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === void 0 || current === null) {
@@ -6069,7 +6079,7 @@ __export(conditions_exports, {
   shouldStepExecute: () => shouldStepExecute
 });
 import fs28 from "fs/promises";
-import path28 from "path";
+import path29 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;
@@ -6122,7 +6132,7 @@ async function evaluateCondition(condition, vaultPath2, context) {
   }
 }
 async function evaluateFileExists(vaultPath2, notePath, expectExists) {
-  const fullPath = path28.join(vaultPath2, notePath);
+  const fullPath = path29.join(vaultPath2, notePath);
   try {
     await fs28.access(fullPath);
     return {
@@ -6137,7 +6147,7 @@ async function evaluateFileExists(vaultPath2, notePath, expectExists) {
   }
 }
 async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectExists) {
-  const fullPath = path28.join(vaultPath2, notePath);
+  const fullPath = path29.join(vaultPath2, notePath);
   try {
     await fs28.access(fullPath);
   } catch {
@@ -6168,7 +6178,7 @@ async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectEx
   }
 }
 async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expectExists) {
-  const fullPath = path28.join(vaultPath2, notePath);
+  const fullPath = path29.join(vaultPath2, notePath);
   try {
     await fs28.access(fullPath);
   } catch {
@@ -6199,7 +6209,7 @@ async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expect
   }
 }
 async function evaluateFrontmatterEquals(vaultPath2, notePath, fieldName, expectedValue) {
-  const fullPath = path28.join(vaultPath2, notePath);
+  const fullPath = path29.join(vaultPath2, notePath);
   try {
     await fs28.access(fullPath);
   } catch {
@@ -6343,10 +6353,10 @@ var init_taskHelpers = __esm({
 });
 
 // src/index.ts
-import * as path35 from "path";
+import * as path36 from "path";
 import { readFileSync as readFileSync6, realpathSync, existsSync as existsSync3 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname7, join as join20 } from "path";
+import { dirname as dirname7, join as join21 } from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -6581,8 +6591,8 @@ function updateIndexProgress(parsed, total) {
 function normalizeTarget(target) {
   return target.toLowerCase().replace(/\.md$/, "");
 }
-function normalizeNotePath(path36) {
-  return path36.toLowerCase().replace(/\.md$/, "");
+function normalizeNotePath(path37) {
+  return path37.toLowerCase().replace(/\.md$/, "");
 }
 async function buildVaultIndex(vaultPath2, options = {}) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
@@ -6751,7 +6761,7 @@ function findSimilarEntity(index, target) {
   }
   const maxDist = normalizedLen <= 10 ? 1 : 2;
   let bestMatch;
-  for (const [entity, path36] of index.entities) {
+  for (const [entity, path37] of index.entities) {
     const lenDiff = Math.abs(entity.length - normalizedLen);
     if (lenDiff > maxDist) {
       continue;
@@ -6759,7 +6769,7 @@ function findSimilarEntity(index, target) {
     const dist = levenshteinDistance(normalized, entity);
     if (dist > 0 && dist <= maxDist) {
       if (!bestMatch || dist < bestMatch.distance) {
-        bestMatch = { path: path36, entity, distance: dist };
+        bestMatch = { path: path37, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -7290,30 +7300,30 @@ var EventQueue = class {
    * Add a new event to the queue
    */
   push(type, rawPath) {
-    const path36 = normalizePath(rawPath);
+    const path37 = normalizePath(rawPath);
     const now = Date.now();
     const event = {
       type,
-      path: path36,
+      path: path37,
       timestamp: now
     };
-    let pending = this.pending.get(path36);
+    let pending = this.pending.get(path37);
     if (!pending) {
       pending = {
         events: [],
         timer: null,
         lastEvent: now
       };
-      this.pending.set(path36, pending);
+      this.pending.set(path37, pending);
     }
     pending.events.push(event);
     pending.lastEvent = now;
-    console.error(`[flywheel] QUEUE: pushed ${type} for ${path36}, pending=${this.pending.size}`);
+    console.error(`[flywheel] QUEUE: pushed ${type} for ${path37}, pending=${this.pending.size}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
     }
     pending.timer = setTimeout(() => {
-      this.flushPath(path36);
+      this.flushPath(path37);
     }, this.config.debounceMs);
     if (this.pending.size >= this.config.batchSize) {
       this.flush();
@@ -7334,10 +7344,10 @@ var EventQueue = class {
   /**
    * Flush a single path's events
    */
-  flushPath(path36) {
-    const pending = this.pending.get(path36);
+  flushPath(path37) {
+    const pending = this.pending.get(path37);
     if (!pending || pending.events.length === 0) return;
-    console.error(`[flywheel] QUEUE: flushing ${path36}, events=${pending.events.length}`);
+    console.error(`[flywheel] QUEUE: flushing ${path37}, events=${pending.events.length}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -7346,7 +7356,7 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path36,
+        path: path37,
         originalEvents: [...pending.events]
       };
       this.onBatch({
@@ -7355,7 +7365,7 @@ var EventQueue = class {
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path36);
+    this.pending.delete(path37);
   }
   /**
    * Flush all pending events
@@ -7367,7 +7377,7 @@ var EventQueue = class {
     }
     if (this.pending.size === 0) return;
     const events = [];
-    for (const [path36, pending] of this.pending) {
+    for (const [path37, pending] of this.pending) {
       if (pending.timer) {
         clearTimeout(pending.timer);
       }
@@ -7375,7 +7385,7 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path36,
+          path: path37,
           originalEvents: [...pending.events]
         });
       }
@@ -7761,31 +7771,31 @@ function createVaultWatcher(options) {
         usePolling: config.usePolling,
         interval: config.usePolling ? config.pollInterval : void 0
       });
-      watcher.on("add", (path36) => {
-        console.error(`[flywheel] RAW EVENT: add ${path36}`);
-        if (shouldWatch(path36, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: add ${path36}`);
-          eventQueue.push("add", path36);
+      watcher.on("add", (path37) => {
+        console.error(`[flywheel] RAW EVENT: add ${path37}`);
+        if (shouldWatch(path37, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: add ${path37}`);
+          eventQueue.push("add", path37);
         } else {
-          console.error(`[flywheel] FILTERED: add ${path36}`);
+          console.error(`[flywheel] FILTERED: add ${path37}`);
         }
       });
-      watcher.on("change", (path36) => {
-        console.error(`[flywheel] RAW EVENT: change ${path36}`);
-        if (shouldWatch(path36, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: change ${path36}`);
-          eventQueue.push("change", path36);
+      watcher.on("change", (path37) => {
+        console.error(`[flywheel] RAW EVENT: change ${path37}`);
+        if (shouldWatch(path37, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: change ${path37}`);
+          eventQueue.push("change", path37);
         } else {
-          console.error(`[flywheel] FILTERED: change ${path36}`);
+          console.error(`[flywheel] FILTERED: change ${path37}`);
         }
       });
-      watcher.on("unlink", (path36) => {
-        console.error(`[flywheel] RAW EVENT: unlink ${path36}`);
-        if (shouldWatch(path36, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: unlink ${path36}`);
-          eventQueue.push("unlink", path36);
+      watcher.on("unlink", (path37) => {
+        console.error(`[flywheel] RAW EVENT: unlink ${path37}`);
+        if (shouldWatch(path37, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: unlink ${path37}`);
+          eventQueue.push("unlink", path37);
         } else {
-          console.error(`[flywheel] FILTERED: unlink ${path36}`);
+          console.error(`[flywheel] FILTERED: unlink ${path37}`);
         }
       });
       watcher.on("ready", () => {
@@ -7817,8 +7827,8 @@ function createVaultWatcher(options) {
 }
 
 // src/core/read/watch/pipeline.ts
-import * as path14 from "node:path";
-import * as fs9 from "node:fs/promises";
+import * as path15 from "node:path";
+import * as fs10 from "node:fs/promises";
 import {
   getAllEntitiesFromDb,
   findEntityMatches,
@@ -8071,14 +8081,283 @@ init_cooccurrence();
 init_wikilinks();
 init_proactiveQueue();
 init_retrievalCooccurrence();
+
+// src/core/read/fts5.ts
+init_vault();
+init_serverLog();
+init_vault_scope();
+import * as fs8 from "fs";
+var EXCLUDED_DIRS3 = /* @__PURE__ */ new Set([
+  ".obsidian",
+  ".trash",
+  ".git",
+  "node_modules",
+  "templates",
+  ".claude",
+  ".flywheel"
+]);
+var MAX_INDEX_FILE_SIZE = 5 * 1024 * 1024;
+var STALE_THRESHOLD_MS = 60 * 60 * 1e3;
+function splitFrontmatter(raw) {
+  if (!raw.startsWith("---")) return { frontmatter: "", body: raw };
+  const end = raw.indexOf("\n---", 3);
+  if (end === -1) return { frontmatter: "", body: raw };
+  const yaml = raw.substring(4, end);
+  const values = yaml.split("\n").map((line) => line.replace(/^[\s-]*/, "").replace(/^[\w]+:\s*/, "")).filter((v) => v && !v.startsWith("[") && !v.startsWith("{")).join(" ");
+  return { frontmatter: values, body: raw.substring(end + 4) };
+}
+var db2 = null;
+function getDb2() {
+  return getActiveScopeOrNull()?.stateDb?.db ?? db2;
+}
+var state = {
+  ready: false,
+  building: false,
+  lastBuilt: null,
+  noteCount: 0,
+  error: null
+};
+function setFTS5Database(database) {
+  db2 = database;
+  try {
+    const row = db2.prepare(
+      "SELECT value FROM fts_metadata WHERE key = ?"
+    ).get("last_built");
+    if (row) {
+      const lastBuilt = new Date(row.value);
+      const countRow = db2.prepare("SELECT COUNT(*) as count FROM notes_fts").get();
+      state = {
+        ready: countRow.count > 0,
+        building: false,
+        lastBuilt,
+        noteCount: countRow.count,
+        error: null
+      };
+    }
+  } catch {
+  }
+}
+function shouldIndexFile2(filePath) {
+  const parts = filePath.split("/");
+  return !parts.some((part) => EXCLUDED_DIRS3.has(part));
+}
+async function buildFTS5Index(vaultPath2) {
+  const db4 = getDb2();
+  try {
+    state.error = null;
+    state.building = true;
+    if (!db4) {
+      throw new Error("FTS5 database not initialized. Call setFTS5Database() first.");
+    }
+    const files = await scanVault(vaultPath2);
+    const indexableFiles = files.filter((f) => shouldIndexFile2(f.path));
+    const rows = [];
+    for (const file of indexableFiles) {
+      try {
+        const stats = fs8.statSync(file.absolutePath);
+        if (stats.size > MAX_INDEX_FILE_SIZE) {
+          continue;
+        }
+        const raw = fs8.readFileSync(file.absolutePath, "utf-8");
+        const { frontmatter, body } = splitFrontmatter(raw);
+        const title = file.path.replace(/\.md$/, "").split("/").pop() || file.path;
+        rows.push([file.path, title, frontmatter, body]);
+      } catch (err) {
+        serverLog("fts5", `Skipping ${file.path}: ${err}`, "warn");
+      }
+    }
+    const insert = db4.prepare(
+      "INSERT INTO notes_fts (path, title, frontmatter, content) VALUES (?, ?, ?, ?)"
+    );
+    const now = /* @__PURE__ */ new Date();
+    const swapAll = db4.transaction(() => {
+      db4.exec("DELETE FROM notes_fts");
+      for (const row of rows) {
+        insert.run(...row);
+      }
+      db4.prepare(
+        "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)"
+      ).run("last_built", now.toISOString());
+    });
+    swapAll();
+    const indexed = rows.length;
+    state = {
+      ready: true,
+      building: false,
+      lastBuilt: now,
+      noteCount: indexed,
+      error: null
+    };
+    serverLog("fts5", `Indexed ${indexed} notes`);
+    return state;
+  } catch (err) {
+    state = {
+      ready: false,
+      building: false,
+      lastBuilt: null,
+      noteCount: 0,
+      error: err instanceof Error ? err.message : String(err)
+    };
+    throw err;
+  }
+}
+function isIndexStale(_vaultPath) {
+  const db4 = getDb2();
+  if (!db4) {
+    return true;
+  }
+  try {
+    const row = db4.prepare(
+      "SELECT value FROM fts_metadata WHERE key = ?"
+    ).get("last_built");
+    if (!row) {
+      return true;
+    }
+    const lastBuilt = new Date(row.value);
+    const age = Date.now() - lastBuilt.getTime();
+    return age > STALE_THRESHOLD_MS;
+  } catch {
+    return true;
+  }
+}
+function updateFTS5Incremental(vaultPath2, changed, deleted) {
+  const db4 = getDb2();
+  if (!db4 || !state.ready) return { updated: 0, removed: 0 };
+  const del = db4.prepare("DELETE FROM notes_fts WHERE path = ?");
+  const ins = db4.prepare(
+    "INSERT INTO notes_fts (path, title, frontmatter, content) VALUES (?, ?, ?, ?)"
+  );
+  let updated = 0;
+  let removed = 0;
+  const run = db4.transaction(() => {
+    for (const p of deleted) {
+      del.run(p);
+      removed++;
+    }
+    for (const p of changed) {
+      if (!shouldIndexFile2(p)) continue;
+      const absPath = `${vaultPath2}/${p}`.replace(/\\/g, "/");
+      try {
+        const stats = fs8.statSync(absPath);
+        if (stats.size > MAX_INDEX_FILE_SIZE) continue;
+        const raw = fs8.readFileSync(absPath, "utf-8");
+        const { frontmatter, body } = splitFrontmatter(raw);
+        const title = p.replace(/\.md$/, "").split("/").pop() || p;
+        del.run(p);
+        ins.run(p, title, frontmatter, body);
+        updated++;
+      } catch {
+        del.run(p);
+      }
+    }
+  });
+  run();
+  if (updated > 0 || removed > 0) {
+    state.noteCount = db4.prepare("SELECT COUNT(*) as count FROM notes_fts").get().count;
+  }
+  return { updated, removed };
+}
+function sanitizeFTS5Query(query) {
+  if (!query?.trim()) return "";
+  const phrases = [];
+  const withoutPhrases = query.replace(/"([^"]+)"/g, (_, phrase) => {
+    phrases.push(`"${phrase.replace(/"/g, '""')}"`);
+    return "";
+  });
+  const cleaned = withoutPhrases.replace(/[(){}[\]^~:\-]/g, " ").replace(/\s+/g, " ").trim();
+  const tokens = cleaned.split(" ").filter((t) => t && t !== "AND" && t !== "OR" && t !== "NOT");
+  const parts = [...phrases];
+  if (tokens.length === 1) {
+    parts.push(tokens[0]);
+  } else if (tokens.length > 1) {
+    parts.push(tokens.join(" OR "));
+  }
+  return parts.join(" ") || "";
+}
+function searchFTS5(_vaultPath, query, limit = 10) {
+  const db4 = getDb2();
+  if (!db4) {
+    throw new Error("FTS5 database not initialized. Call setFTS5Database() first.");
+  }
+  const sanitized = sanitizeFTS5Query(query);
+  if (!sanitized) return [];
+  try {
+    const stmt = db4.prepare(`
+      SELECT
+        path,
+        title,
+        snippet(notes_fts, 3, '<mark>', '</mark>', '...', 64) as snippet
+      FROM notes_fts
+      WHERE notes_fts MATCH ?
+      ORDER BY bm25(notes_fts, 0.0, 5.0, 10.0, 1.0)
+      LIMIT ?
+    `);
+    const results = stmt.all(sanitized, limit);
+    return results;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("fts5:")) {
+      return [];
+    }
+    throw err;
+  }
+}
+function getFTS5State() {
+  if (state.building) return { ...state };
+  const scopeDb = getDb2();
+  if (scopeDb) {
+    try {
+      const row = scopeDb.prepare(
+        "SELECT value FROM fts_metadata WHERE key = ?"
+      ).get("last_built");
+      const countRow = scopeDb.prepare("SELECT COUNT(*) as count FROM notes_fts").get();
+      return {
+        ready: countRow.count > 0,
+        building: false,
+        lastBuilt: row ? new Date(row.value) : null,
+        noteCount: countRow.count,
+        error: null
+      };
+    } catch {
+    }
+  }
+  return { ...state };
+}
+function getContentPreview(notePath, maxChars = 300) {
+  const db4 = getDb2();
+  if (!db4) return null;
+  try {
+    const row = db4.prepare(
+      "SELECT substr(content, 1, ?) as preview FROM notes_fts WHERE path = ?"
+    ).get(maxChars + 50, notePath);
+    if (!row?.preview) return null;
+    const truncated = row.preview.length > maxChars ? row.preview.slice(0, maxChars).replace(/\s\S*$/, "") + "..." : row.preview;
+    return truncated;
+  } catch {
+    return null;
+  }
+}
+function countFTS5Mentions(term) {
+  const db4 = getDb2();
+  if (!db4) return 0;
+  try {
+    const result = db4.prepare(
+      "SELECT COUNT(*) as cnt FROM notes_fts WHERE content MATCH ?"
+    ).get(`"${term}"`);
+    return result?.cnt ?? 0;
+  } catch {
+    return 0;
+  }
+}
+
+// src/core/read/watch/pipeline.ts
 init_embeddings();
 
 // src/core/read/taskCache.ts
-import * as path13 from "path";
+import * as path14 from "path";
 
 // src/tools/read/tasks.ts
-import * as fs8 from "fs";
-import * as path12 from "path";
+import * as fs9 from "fs";
+import * as path13 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/;
@@ -8104,7 +8383,7 @@ function extractDueDate(text) {
 async function extractTasksFromNote(notePath, absolutePath) {
   let content;
   try {
-    content = await fs8.promises.readFile(absolutePath, "utf-8");
+    content = await fs9.promises.readFile(absolutePath, "utf-8");
   } catch {
     return [];
   }
@@ -8147,7 +8426,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 = path12.join(vaultPath2, note.path);
+    const absolutePath = path13.join(vaultPath2, note.path);
     const tasks = await extractTasksFromNote(note.path, absolutePath);
     allTasks.push(...tasks);
   }
@@ -8191,7 +8470,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 = path12.join(vaultPath2, notePath);
+  const absolutePath = path13.join(vaultPath2, notePath);
   let tasks = await extractTasksFromNote(notePath, absolutePath);
   if (excludeTags.length > 0) {
     tasks = tasks.filter(
@@ -8213,17 +8492,17 @@ async function getTasksWithDueDates(index, vaultPath2, options = {}) {
 // src/core/read/taskCache.ts
 init_serverLog();
 init_vault_scope();
-var db2 = null;
-function getDb2() {
-  return getActiveScopeOrNull()?.stateDb?.db ?? db2;
+var db3 = null;
+function getDb3() {
+  return getActiveScopeOrNull()?.stateDb?.db ?? db3;
 }
 var TASK_CACHE_STALE_MS = 30 * 60 * 1e3;
 var cacheReady = false;
 var rebuildInProgress = false;
 function setTaskCacheDatabase(database) {
-  db2 = database;
+  db3 = database;
   try {
-    const row = db2.prepare(
+    const row = db3.prepare(
       "SELECT value FROM fts_metadata WHERE key = ?"
     ).get("task_cache_built");
     if (row) {
@@ -8233,7 +8512,7 @@ function setTaskCacheDatabase(database) {
   }
 }
 function isTaskCacheReady() {
-  const scopeDb = getDb2();
+  const scopeDb = getDb3();
   if (!scopeDb) return false;
   try {
     const row = scopeDb.prepare(
@@ -8248,7 +8527,7 @@ function isTaskCacheBuilding() {
   return rebuildInProgress;
 }
 async function buildTaskCache(vaultPath2, index, excludeTags) {
-  const db4 = getDb2();
+  const db4 = getDb3();
   if (!db4) {
     throw new Error("Task cache database not initialized. Call setTaskCacheDatabase() first.");
   }
@@ -8262,7 +8541,7 @@ async function buildTaskCache(vaultPath2, index, excludeTags) {
     }
     const allRows = [];
     for (const notePath of notePaths) {
-      const absolutePath = path13.join(vaultPath2, notePath);
+      const absolutePath = path14.join(vaultPath2, notePath);
       const tasks = await extractTasksFromNote(notePath, absolutePath);
       for (const task of tasks) {
         if (excludeTags?.length && excludeTags.some((t) => task.tags.includes(t))) {
@@ -8302,10 +8581,10 @@ async function buildTaskCache(vaultPath2, index, excludeTags) {
   }
 }
 async function updateTaskCacheForFile(vaultPath2, relativePath) {
-  const db4 = getDb2();
+  const db4 = getDb3();
   if (!db4) return;
   db4.prepare("DELETE FROM tasks WHERE path = ?").run(relativePath);
-  const absolutePath = path13.join(vaultPath2, relativePath);
+  const absolutePath = path14.join(vaultPath2, relativePath);
   const tasks = await extractTasksFromNote(relativePath, absolutePath);
   if (tasks.length > 0) {
     const insertStmt = db4.prepare(`
@@ -8330,12 +8609,12 @@ async function updateTaskCacheForFile(vaultPath2, relativePath) {
   }
 }
 function removeTaskCacheForFile(relativePath) {
-  const db4 = getDb2();
+  const db4 = getDb3();
   if (!db4) return;
   db4.prepare("DELETE FROM tasks WHERE path = ?").run(relativePath);
 }
 function queryTasksFromCache(options) {
-  const db4 = getDb2();
+  const db4 = getDb3();
   if (!db4) {
     throw new Error("Task cache database not initialized.");
   }
@@ -8422,7 +8701,7 @@ function queryTasksFromCache(options) {
   };
 }
 function isTaskCacheStale() {
-  const db4 = getDb2();
+  const db4 = getDb3();
   if (!db4) return true;
   try {
     const row = db4.prepare(
@@ -8478,6 +8757,7 @@ var PipelineRunner = class {
     try {
       await runStep("drain_proactive_queue", tracker, {}, () => this.drainQueue());
       await this.indexRebuild();
+      this.fts5Incremental();
       this.noteMoves();
       await this.entityScan();
       await runStep("hub_scores", tracker, { entity_count: this.entitiesAfter.length }, () => this.hubScores());
@@ -8540,7 +8820,7 @@ var PipelineRunner = class {
     } else {
       const absoluteBatch = {
         ...p.batch,
-        events: p.events.map((e) => ({ ...e, path: path14.join(p.vp, e.path) }))
+        events: p.events.map((e) => ({ ...e, path: path15.join(p.vp, e.path) }))
       };
       const batchResult = await processBatch(vaultIndex2, p.vp, absoluteBatch);
       serverLog("watcher", `Incremental: ${batchResult.successful}/${batchResult.total} files in ${batchResult.durationMs}ms`);
@@ -8549,6 +8829,26 @@ var PipelineRunner = class {
     const idx = p.getVaultIndex();
     tracker.end({ note_count: idx.notes.size, entity_count: idx.entities.size, tag_count: idx.tags.size });
   }
+  // ── Step 1.1: FTS5 incremental update ──────────────────────────────
+  fts5Incremental() {
+    const { p, tracker } = this;
+    const changed = p.events.filter((e) => e.type === "upsert").map((e) => e.path);
+    const deleted = [
+      ...p.events.filter((e) => e.type === "delete").map((e) => e.path),
+      ...p.renames.map((r) => r.oldPath)
+    ];
+    if (changed.length === 0 && deleted.length === 0) {
+      tracker.start("fts5_incremental", {});
+      tracker.skip("fts5_incremental", "no changes");
+      return;
+    }
+    tracker.start("fts5_incremental", { changed: changed.length, deleted: deleted.length });
+    const result = updateFTS5Incremental(p.vp, changed, deleted);
+    tracker.end(result);
+    if (result.updated > 0 || result.removed > 0) {
+      serverLog("watcher", `FTS5: ${result.updated} updated, ${result.removed} removed`);
+    }
+  }
   // ── Step 1.5: Note moves ──────────────────────────────────────────
   noteMoves() {
     const { p, tracker } = this;
@@ -8689,7 +8989,7 @@ var PipelineRunner = class {
             removeEmbedding(event.path);
             embRemoved++;
           } else if (event.path.endsWith(".md")) {
-            const absPath = path14.join(p.vp, event.path);
+            const absPath = path15.join(p.vp, event.path);
             await updateEmbedding(event.path, absPath);
             embUpdated++;
           }
@@ -8923,7 +9223,7 @@ var PipelineRunner = class {
     for (const event of p.events) {
       if (event.type === "delete" || !event.path.endsWith(".md")) continue;
       try {
-        const content = await fs9.readFile(path14.join(p.vp, event.path), "utf-8");
+        const content = await fs10.readFile(path15.join(p.vp, event.path), "utf-8");
         const zones = getProtectedZones(content);
         const linked = new Set(
           (this.forwardLinkResults.find((r) => r.file === event.path)?.resolved ?? []).map((n) => n.toLowerCase())
@@ -8968,7 +9268,7 @@ var PipelineRunner = class {
       for (const event of p.events) {
         if (event.type === "delete" || !event.path.endsWith(".md")) continue;
         try {
-          const content = await fs9.readFile(path14.join(p.vp, event.path), "utf-8");
+          const content = await fs10.readFile(path15.join(p.vp, event.path), "utf-8");
           const removed = processImplicitFeedback(p.sd, event.path, content);
           for (const entity of removed) feedbackResults.push({ entity, file: event.path });
         } catch {
@@ -9045,7 +9345,7 @@ var PipelineRunner = class {
     for (const event of p.events) {
       if (event.type === "delete" || !event.path.endsWith(".md")) continue;
       try {
-        const content = await fs9.readFile(path14.join(p.vp, event.path), "utf-8");
+        const content = await fs10.readFile(path15.join(p.vp, event.path), "utf-8");
         const zones = getProtectedZones(content);
         const linkedSet = new Set(
           (this.forwardLinkResults.find((r) => r.file === event.path)?.resolved ?? []).concat(this.forwardLinkResults.find((r) => r.file === event.path)?.dead ?? []).map((n) => n.toLowerCase())
@@ -9081,7 +9381,7 @@ var PipelineRunner = class {
     for (const event of p.events) {
       if (event.type === "delete" || !event.path.endsWith(".md")) continue;
       try {
-        const rawContent = await fs9.readFile(path14.join(p.vp, event.path), "utf-8");
+        const rawContent = await fs10.readFile(path15.join(p.vp, event.path), "utf-8");
         const content = rawContent.replace(/ → \[\[.*$/gm, "");
         const result = await suggestRelatedLinks(content, {
           maxSuggestions: 5,
@@ -9112,14 +9412,12 @@ var PipelineRunner = class {
     if (!p.sd || p.flywheelConfig?.proactive_linking === false) {
       return { skipped: true };
     }
-    const currentBatchPaths = new Set(p.events.map((e) => e.path));
     const result = await drainProactiveQueue(
       p.sd,
       p.vp,
-      currentBatchPaths,
       {
         minScore: p.flywheelConfig?.proactive_min_score ?? 20,
-        maxPerFile: p.flywheelConfig?.proactive_max_per_file ?? 3,
+        maxPerFile: p.flywheelConfig?.proactive_max_per_file ?? 5,
         maxPerDay: p.flywheelConfig?.proactive_max_per_day ?? 10
       },
       applyProactiveSuggestions
@@ -9145,7 +9443,7 @@ var PipelineRunner = class {
     tracker.start("proactive_enqueue", { files: this.suggestionResults.length });
     try {
       const minScore = p.flywheelConfig?.proactive_min_score ?? 20;
-      const maxPerFile = p.flywheelConfig?.proactive_max_per_file ?? 3;
+      const maxPerFile = p.flywheelConfig?.proactive_max_per_file ?? 5;
       const entries = [];
       for (const { file, top } of this.suggestionResults) {
         const candidates = top.filter((s) => s.score >= minScore && s.confidence === "high").slice(0, maxPerFile);
@@ -9166,323 +9464,106 @@ var PipelineRunner = class {
   // ── Step 13: Tag scan ─────────────────────────────────────────────
   async tagScan() {
     const { p } = this;
-    const vaultIndex2 = p.getVaultIndex();
-    const tagDiffs = [];
-    if (p.sd) {
-      const noteTagsForward = /* @__PURE__ */ new Map();
-      for (const [tag, paths] of vaultIndex2.tags) {
-        for (const notePath of paths) {
-          if (!noteTagsForward.has(notePath)) noteTagsForward.set(notePath, /* @__PURE__ */ new Set());
-          noteTagsForward.get(notePath).add(tag);
-        }
-      }
-      for (const event of p.events) {
-        if (event.type === "delete" || !event.path.endsWith(".md")) continue;
-        const currentSet = noteTagsForward.get(event.path) ?? /* @__PURE__ */ new Set();
-        const previousSet = getStoredNoteTags(p.sd, event.path);
-        if (previousSet.size === 0 && currentSet.size > 0) {
-          updateStoredNoteTags(p.sd, 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(p.sd, event.path, currentSet);
-      }
-      for (const event of p.events) {
-        if (event.type === "delete") {
-          const previousSet = getStoredNoteTags(p.sd, event.path);
-          if (previousSet.size > 0) {
-            tagDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
-            updateStoredNoteTags(p.sd, event.path, /* @__PURE__ */ new Set());
-          }
-        }
-      }
-    }
-    const totalTagsAdded = tagDiffs.reduce((s, d) => s + d.added.length, 0);
-    const totalTagsRemoved = tagDiffs.reduce((s, d) => s + d.removed.length, 0);
-    if (tagDiffs.length > 0) {
-      serverLog("watcher", `Tag scan: ${totalTagsAdded} added, ${totalTagsRemoved} removed across ${tagDiffs.length} files`);
-    }
-    return { total_added: totalTagsAdded, total_removed: totalTagsRemoved, tag_diffs: tagDiffs };
-  }
-  // ── Step 19: Retrieval co-occurrence ──────────────────────────────
-  async retrievalCooccurrence() {
-    const { p } = this;
-    if (!p.sd) return { skipped: "no sd" };
-    const inserted = mineRetrievalCooccurrence(p.sd);
-    if (inserted > 0) {
-      serverLog("watcher", `Retrieval co-occurrence: ${inserted} new pairs`);
-    }
-    return { pairs_inserted: inserted };
-  }
-};
-
-// src/core/read/logging.ts
-init_serverLog();
-import {
-  createLoggerFromConfig,
-  generateSessionId,
-  setSessionId
-} from "@velvetmonkey/vault-core";
-var logger = null;
-async function initializeLogger(vaultPath2) {
-  try {
-    const sessionId = generateSessionId();
-    setSessionId(sessionId);
-    logger = await createLoggerFromConfig(vaultPath2, "flywheel");
-  } catch (error) {
-    serverLog("server", `Failed to initialize logger: ${error}`, "error");
-    logger = null;
-  }
-}
-function getLogger() {
-  return logger;
-}
-
-// src/index.ts
-init_wikilinks();
-
-// src/core/write/logging.ts
-init_serverLog();
-import {
-  createLoggerFromConfig as createLoggerFromConfig2,
-  generateSessionId as generateSessionId2,
-  setSessionId as setSessionId2
-} from "@velvetmonkey/vault-core";
-var logger2 = null;
-async function initializeLogger2(vaultPath2) {
-  try {
-    const sessionId = generateSessionId2();
-    setSessionId2(sessionId);
-    logger2 = await createLoggerFromConfig2(vaultPath2, "write");
-  } catch (error) {
-    serverLog("server", `Failed to initialize logger: ${error}`, "error");
-    logger2 = null;
-  }
-}
-async function flushLogs() {
-  if (logger2) await logger2.flush();
-}
-
-// src/core/read/fts5.ts
-init_vault();
-init_serverLog();
-init_vault_scope();
-import * as fs10 from "fs";
-var EXCLUDED_DIRS3 = /* @__PURE__ */ new Set([
-  ".obsidian",
-  ".trash",
-  ".git",
-  "node_modules",
-  "templates",
-  ".claude",
-  ".flywheel"
-]);
-var MAX_INDEX_FILE_SIZE = 5 * 1024 * 1024;
-var STALE_THRESHOLD_MS = 60 * 60 * 1e3;
-function splitFrontmatter(raw) {
-  if (!raw.startsWith("---")) return { frontmatter: "", body: raw };
-  const end = raw.indexOf("\n---", 3);
-  if (end === -1) return { frontmatter: "", body: raw };
-  const yaml = raw.substring(4, end);
-  const values = yaml.split("\n").map((line) => line.replace(/^[\s-]*/, "").replace(/^[\w]+:\s*/, "")).filter((v) => v && !v.startsWith("[") && !v.startsWith("{")).join(" ");
-  return { frontmatter: values, body: raw.substring(end + 4) };
-}
-var db3 = null;
-function getDb3() {
-  return getActiveScopeOrNull()?.stateDb?.db ?? db3;
-}
-var state = {
-  ready: false,
-  building: false,
-  lastBuilt: null,
-  noteCount: 0,
-  error: null
-};
-function setFTS5Database(database) {
-  db3 = database;
-  try {
-    const row = db3.prepare(
-      "SELECT value FROM fts_metadata WHERE key = ?"
-    ).get("last_built");
-    if (row) {
-      const lastBuilt = new Date(row.value);
-      const countRow = db3.prepare("SELECT COUNT(*) as count FROM notes_fts").get();
-      state = {
-        ready: countRow.count > 0,
-        building: false,
-        lastBuilt,
-        noteCount: countRow.count,
-        error: null
-      };
-    }
-  } catch {
-  }
-}
-function shouldIndexFile2(filePath) {
-  const parts = filePath.split("/");
-  return !parts.some((part) => EXCLUDED_DIRS3.has(part));
-}
-async function buildFTS5Index(vaultPath2) {
-  const db4 = getDb3();
-  try {
-    state.error = null;
-    state.building = true;
-    if (!db4) {
-      throw new Error("FTS5 database not initialized. Call setFTS5Database() first.");
-    }
-    const files = await scanVault(vaultPath2);
-    const indexableFiles = files.filter((f) => shouldIndexFile2(f.path));
-    const rows = [];
-    for (const file of indexableFiles) {
-      try {
-        const stats = fs10.statSync(file.absolutePath);
-        if (stats.size > MAX_INDEX_FILE_SIZE) {
+    const vaultIndex2 = p.getVaultIndex();
+    const tagDiffs = [];
+    if (p.sd) {
+      const noteTagsForward = /* @__PURE__ */ new Map();
+      for (const [tag, paths] of vaultIndex2.tags) {
+        for (const notePath of paths) {
+          if (!noteTagsForward.has(notePath)) noteTagsForward.set(notePath, /* @__PURE__ */ new Set());
+          noteTagsForward.get(notePath).add(tag);
+        }
+      }
+      for (const event of p.events) {
+        if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+        const currentSet = noteTagsForward.get(event.path) ?? /* @__PURE__ */ new Set();
+        const previousSet = getStoredNoteTags(p.sd, event.path);
+        if (previousSet.size === 0 && currentSet.size > 0) {
+          updateStoredNoteTags(p.sd, event.path, currentSet);
           continue;
         }
-        const raw = fs10.readFileSync(file.absolutePath, "utf-8");
-        const { frontmatter, body } = splitFrontmatter(raw);
-        const title = file.path.replace(/\.md$/, "").split("/").pop() || file.path;
-        rows.push([file.path, title, frontmatter, body]);
-      } catch (err) {
-        serverLog("fts5", `Skipping ${file.path}: ${err}`, "warn");
+        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(p.sd, event.path, currentSet);
       }
-    }
-    const insert = db4.prepare(
-      "INSERT INTO notes_fts (path, title, frontmatter, content) VALUES (?, ?, ?, ?)"
-    );
-    const now = /* @__PURE__ */ new Date();
-    const swapAll = db4.transaction(() => {
-      db4.exec("DELETE FROM notes_fts");
-      for (const row of rows) {
-        insert.run(...row);
+      for (const event of p.events) {
+        if (event.type === "delete") {
+          const previousSet = getStoredNoteTags(p.sd, event.path);
+          if (previousSet.size > 0) {
+            tagDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
+            updateStoredNoteTags(p.sd, event.path, /* @__PURE__ */ new Set());
+          }
+        }
       }
-      db4.prepare(
-        "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)"
-      ).run("last_built", now.toISOString());
-    });
-    swapAll();
-    const indexed = rows.length;
-    state = {
-      ready: true,
-      building: false,
-      lastBuilt: now,
-      noteCount: indexed,
-      error: null
-    };
-    serverLog("fts5", `Indexed ${indexed} notes`);
-    return state;
-  } catch (err) {
-    state = {
-      ready: false,
-      building: false,
-      lastBuilt: null,
-      noteCount: 0,
-      error: err instanceof Error ? err.message : String(err)
-    };
-    throw err;
-  }
-}
-function isIndexStale(_vaultPath) {
-  const db4 = getDb3();
-  if (!db4) {
-    return true;
-  }
-  try {
-    const row = db4.prepare(
-      "SELECT value FROM fts_metadata WHERE key = ?"
-    ).get("last_built");
-    if (!row) {
-      return true;
     }
-    const lastBuilt = new Date(row.value);
-    const age = Date.now() - lastBuilt.getTime();
-    return age > STALE_THRESHOLD_MS;
-  } catch {
-    return true;
-  }
-}
-function sanitizeFTS5Query(query) {
-  if (!query?.trim()) return "";
-  return query.replace(/"/g, '""').replace(/[(){}[\]^~:\-]/g, " ").replace(/\s+/g, " ").trim();
-}
-function searchFTS5(_vaultPath, query, limit = 10) {
-  const db4 = getDb3();
-  if (!db4) {
-    throw new Error("FTS5 database not initialized. Call setFTS5Database() first.");
-  }
-  const sanitized = sanitizeFTS5Query(query);
-  if (!sanitized) return [];
-  try {
-    const stmt = db4.prepare(`
-      SELECT
-        path,
-        title,
-        snippet(notes_fts, 3, '<mark>', '</mark>', '...', 64) as snippet
-      FROM notes_fts
-      WHERE notes_fts MATCH ?
-      ORDER BY bm25(notes_fts, 0.0, 5.0, 10.0, 1.0)
-      LIMIT ?
-    `);
-    const results = stmt.all(sanitized, limit);
-    return results;
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("fts5:")) {
-      return [];
+    const totalTagsAdded = tagDiffs.reduce((s, d) => s + d.added.length, 0);
+    const totalTagsRemoved = tagDiffs.reduce((s, d) => s + d.removed.length, 0);
+    if (tagDiffs.length > 0) {
+      serverLog("watcher", `Tag scan: ${totalTagsAdded} added, ${totalTagsRemoved} removed across ${tagDiffs.length} files`);
     }
-    throw err;
+    return { total_added: totalTagsAdded, total_removed: totalTagsRemoved, tag_diffs: tagDiffs };
   }
-}
-function getFTS5State() {
-  if (state.building) return { ...state };
-  const scopeDb = getDb3();
-  if (scopeDb) {
-    try {
-      const row = scopeDb.prepare(
-        "SELECT value FROM fts_metadata WHERE key = ?"
-      ).get("last_built");
-      const countRow = scopeDb.prepare("SELECT COUNT(*) as count FROM notes_fts").get();
-      return {
-        ready: countRow.count > 0,
-        building: false,
-        lastBuilt: row ? new Date(row.value) : null,
-        noteCount: countRow.count,
-        error: null
-      };
-    } catch {
+  // ── Step 19: Retrieval co-occurrence ──────────────────────────────
+  async retrievalCooccurrence() {
+    const { p } = this;
+    if (!p.sd) return { skipped: "no sd" };
+    const inserted = mineRetrievalCooccurrence(p.sd);
+    if (inserted > 0) {
+      serverLog("watcher", `Retrieval co-occurrence: ${inserted} new pairs`);
     }
+    return { pairs_inserted: inserted };
   }
-  return { ...state };
-}
-function getContentPreview(notePath, maxChars = 300) {
-  const db4 = getDb3();
-  if (!db4) return null;
+};
+
+// src/core/read/logging.ts
+init_serverLog();
+import {
+  createLoggerFromConfig,
+  generateSessionId,
+  setSessionId
+} from "@velvetmonkey/vault-core";
+var logger = null;
+async function initializeLogger(vaultPath2) {
   try {
-    const row = db4.prepare(
-      "SELECT substr(content, 1, ?) as preview FROM notes_fts WHERE path = ?"
-    ).get(maxChars + 50, notePath);
-    if (!row?.preview) return null;
-    const truncated = row.preview.length > maxChars ? row.preview.slice(0, maxChars).replace(/\s\S*$/, "") + "..." : row.preview;
-    return truncated;
-  } catch {
-    return null;
+    const sessionId = generateSessionId();
+    setSessionId(sessionId);
+    logger = await createLoggerFromConfig(vaultPath2, "flywheel");
+  } catch (error) {
+    serverLog("server", `Failed to initialize logger: ${error}`, "error");
+    logger = null;
   }
 }
-function countFTS5Mentions(term) {
-  const db4 = getDb3();
-  if (!db4) return 0;
+function getLogger() {
+  return logger;
+}
+
+// src/index.ts
+init_wikilinks();
+
+// src/core/write/logging.ts
+init_serverLog();
+import {
+  createLoggerFromConfig as createLoggerFromConfig2,
+  generateSessionId as generateSessionId2,
+  setSessionId as setSessionId2
+} from "@velvetmonkey/vault-core";
+var logger2 = null;
+async function initializeLogger2(vaultPath2) {
   try {
-    const result = db4.prepare(
-      "SELECT COUNT(*) as cnt FROM notes_fts WHERE content MATCH ?"
-    ).get(`"${term}"`);
-    return result?.cnt ?? 0;
-  } catch {
-    return 0;
+    const sessionId = generateSessionId2();
+    setSessionId2(sessionId);
+    logger2 = await createLoggerFromConfig2(vaultPath2, "write");
+  } catch (error) {
+    serverLog("server", `Failed to initialize logger: ${error}`, "error");
+    logger2 = null;
   }
 }
+async function flushLogs() {
+  if (logger2) await logger2.flush();
+}
 
 // src/index.ts
 init_embeddings();
@@ -10183,8 +10264,8 @@ function getNoteAccessFrequency(stateDb2, daysBack = 30) {
       }
     }
   }
-  return Array.from(noteMap.entries()).map(([path36, stats]) => ({
-    path: path36,
+  return Array.from(noteMap.entries()).map(([path37, stats]) => ({
+    path: path37,
     access_count: stats.access_count,
     last_accessed: stats.last_accessed,
     tools_used: Array.from(stats.tools)
@@ -10715,7 +10796,7 @@ var TOOL_CATEGORY = {
   predict_stale_notes: "temporal",
   track_concept_evolution: "temporal",
   temporal_summary: "temporal",
-  // diagnostics (14 tools) -- vault health, stats, config, activity, merges
+  // diagnostics (18 tools) -- vault health, stats, config, activity, merges, doctor, trust, benchmark, history
   health_check: "diagnostics",
   get_vault_stats: "diagnostics",
   get_folder_structure: "diagnostics",
@@ -10856,9 +10937,9 @@ Use "note_intelligence" for per-note analysis (completeness, quality, suggestion
 }
 
 // src/tool-registry.ts
-import * as path34 from "path";
-import { dirname as dirname5, join as join18 } from "path";
-import { statSync as statSync5, readFileSync as readFileSync5 } from "fs";
+import * as path35 from "path";
+import { dirname as dirname5, join as join19 } from "path";
+import { statSync as statSync6, readFileSync as readFileSync5 } from "fs";
 import { fileURLToPath } from "url";
 import { z as z38 } from "zod";
 import { getSessionId } from "@velvetmonkey/vault-core";
@@ -10866,7 +10947,7 @@ init_vault_scope();
 
 // src/tools/read/graph.ts
 import * as fs11 from "fs";
-import * as path15 from "path";
+import * as path16 from "path";
 import { z } from "zod";
 
 // src/core/read/constants.ts
@@ -11317,7 +11398,7 @@ function requireIndex() {
 // src/tools/read/graph.ts
 async function getContext(vaultPath2, sourcePath, line, contextLines = 1) {
   try {
-    const fullPath = path15.join(vaultPath2, sourcePath);
+    const fullPath = path16.join(vaultPath2, sourcePath);
     const content = await fs11.promises.readFile(fullPath, "utf-8");
     const allLines = content.split("\n");
     let fmLines = 0;
@@ -12108,14 +12189,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath, getStateDb3 = ()
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path36] of entities) {
+    for (const [name, path37] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path36;
+        return path37;
       }
     }
-    for (const [name, path36] of entities) {
+    for (const [name, path37] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path36;
+        return path37;
       }
     }
     return void 0;
@@ -12953,8 +13034,8 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
       daily_counts: z4.record(z4.number())
     }).describe("Activity summary for the last 7 days")
   };
-  function isPeriodicNote3(path36) {
-    const filename = path36.split("/").pop() || "";
+  function isPeriodicNote3(path37) {
+    const filename = path37.split("/").pop() || "";
     const nameWithoutExt = filename.replace(/\.md$/, "");
     const patterns = [
       /^\d{4}-\d{2}-\d{2}$/,
@@ -12969,7 +13050,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
       // YYYY (yearly)
     ];
     const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
-    const folder = path36.split("/")[0]?.toLowerCase() || "";
+    const folder = path37.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   server2.registerTool(
@@ -13818,13 +13899,13 @@ function multiHopBackfill(primaryResults, index, stateDb2, config = {}) {
   candidates.sort((a, b) => b.score - a.score);
   return candidates.slice(0, cfg.maxBackfill).map((c) => c.result);
 }
-function scoreCandidate(path36, index, stateDb2) {
-  const note = index.notes.get(path36);
+function scoreCandidate(path37, index, stateDb2) {
+  const note = index.notes.get(path37);
   const decay = recencyDecay(note?.modified);
   let hubScore = 1;
   if (stateDb2) {
     try {
-      const title = note?.title ?? path36.replace(/\.md$/, "").split("/").pop() ?? "";
+      const title = note?.title ?? path37.replace(/\.md$/, "").split("/").pop() ?? "";
       const entity = getEntityByName3(stateDb2, title);
       if (entity) hubScore = entity.hubScore ?? 1;
     } catch {
@@ -14352,7 +14433,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb3) {
 
 // src/tools/read/system.ts
 import * as fs14 from "fs";
-import * as path16 from "path";
+import * as path17 from "path";
 import { z as z6 } from "zod";
 import { scanVaultEntities as scanVaultEntities2, getEntityIndexFromDb as getEntityIndexFromDb2 } from "@velvetmonkey/vault-core";
 
@@ -14665,7 +14746,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
           continue;
         }
         try {
-          const fullPath = path16.join(vaultPath2, note.path);
+          const fullPath = path17.join(vaultPath2, note.path);
           const content = await fs14.promises.readFile(fullPath, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
@@ -14926,7 +15007,7 @@ import { z as z7 } from "zod";
 
 // src/tools/read/structure.ts
 import * as fs15 from "fs";
-import * as path17 from "path";
+import * as path18 from "path";
 var HEADING_REGEX2 = /^(#{1,6})\s+(.+)$/;
 function extractHeadings2(content) {
   const lines = content.split("\n");
@@ -14980,7 +15061,7 @@ function buildSections(headings, totalLines) {
 async function getNoteStructure(index, notePath, vaultPath2) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path17.join(vaultPath2, notePath);
+  const absolutePath = path18.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs15.promises.readFile(absolutePath, "utf-8");
@@ -15003,7 +15084,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 = path17.join(vaultPath2, notePath);
+  const absolutePath = path18.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs15.promises.readFile(absolutePath, "utf-8");
@@ -15045,7 +15126,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 = path17.join(vaultPath2, note.path);
+    const absolutePath = path18.join(vaultPath2, note.path);
     let content;
     try {
       content = await fs15.promises.readFile(absolutePath, "utf-8");
@@ -15080,30 +15161,30 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         include_content: z7.boolean().default(true).describe("Include the text content under each top-level section. Set false to get structure only.")
       }
     },
-    async ({ path: path36, include_content }) => {
+    async ({ path: path37, include_content }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path36, vaultPath2);
+      const result = await getNoteStructure(index, path37, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path36 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path37 }, null, 2) }]
         };
       }
       if (include_content) {
         for (const section of result.sections) {
-          const sectionResult = await getSectionContent(index, path36, section.heading.text, vaultPath2, true);
+          const sectionResult = await getSectionContent(index, path37, section.heading.text, vaultPath2, true);
           if (sectionResult) {
             section.content = sectionResult.content;
           }
         }
       }
-      const note = index.notes.get(path36);
+      const note = index.notes.get(path37);
       const enriched = { ...result };
       if (note) {
         enriched.frontmatter = note.frontmatter;
         enriched.tags = note.tags;
         enriched.aliases = note.aliases;
-        const normalizedPath = path36.toLowerCase().replace(/\.md$/, "");
+        const normalizedPath = path37.toLowerCase().replace(/\.md$/, "");
         const backlinks = index.backlinks.get(normalizedPath) || [];
         enriched.backlink_count = backlinks.length;
         enriched.outlink_count = note.outlinks.length;
@@ -15136,15 +15217,15 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         include_subheadings: z7.boolean().default(true).describe("Include content under subheadings")
       }
     },
-    async ({ path: path36, heading, include_subheadings }) => {
+    async ({ path: path37, heading, include_subheadings }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path36, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path37, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path36,
+            path: path37,
             heading
           }, null, 2) }]
         };
@@ -15198,16 +15279,16 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         offset: z7.coerce.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path36, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
+    async ({ path: path37, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
       const limit = Math.min(requestedLimit ?? 25, MAX_LIMIT);
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const config = getConfig2();
-      if (path36) {
-        const result2 = await getTasksFromNote(index, path36, vaultPath2, config.exclude_task_tags || []);
+      if (path37) {
+        const result2 = await getTasksFromNote(index, path37, vaultPath2, config.exclude_task_tags || []);
         if (!result2) {
           return {
-            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path36 }, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path37 }, null, 2) }]
           };
         }
         let filtered = result2;
@@ -15217,7 +15298,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         const paged2 = filtered.slice(offset, offset + limit);
         return {
           content: [{ type: "text", text: JSON.stringify({
-            path: path36,
+            path: path37,
             total_count: filtered.length,
             returned_count: paged2.length,
             open: result2.filter((t) => t.status === "open").length,
@@ -15373,7 +15454,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
 // src/tools/read/migrations.ts
 import { z as z8 } from "zod";
 import * as fs16 from "fs/promises";
-import * as path18 from "path";
+import * as path19 from "path";
 import matter2 from "gray-matter";
 function getNotesInFolder(index, folder) {
   const notes = [];
@@ -15386,7 +15467,7 @@ function getNotesInFolder(index, folder) {
   return notes;
 }
 async function readFileContent(notePath, vaultPath2) {
-  const fullPath = path18.join(vaultPath2, notePath);
+  const fullPath = path19.join(vaultPath2, notePath);
   try {
     return await fs16.readFile(fullPath, "utf-8");
   } catch {
@@ -15394,7 +15475,7 @@ async function readFileContent(notePath, vaultPath2) {
   }
 }
 async function writeFileContent(notePath, vaultPath2, content) {
-  const fullPath = path18.join(vaultPath2, notePath);
+  const fullPath = path19.join(vaultPath2, notePath);
   try {
     await fs16.writeFile(fullPath, content, "utf-8");
     return true;
@@ -15575,7 +15656,7 @@ function registerMigrationTools(server2, getIndex, getVaultPath) {
 
 // src/tools/read/graphAnalysis.ts
 import fs17 from "node:fs";
-import path19 from "node:path";
+import path20 from "node:path";
 import { z as z9 } from "zod";
 
 // src/tools/read/schema.ts
@@ -16101,7 +16182,7 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb3
           const scored = allNotes.map((note) => {
             let wordCount = 0;
             try {
-              const content = fs17.readFileSync(path19.join(vaultPath2, note.path), "utf-8");
+              const content = fs17.readFileSync(path20.join(vaultPath2, note.path), "utf-8");
               const body = content.replace(/^---[\s\S]*?---\n?/, "");
               wordCount = body.split(/\s+/).filter((w) => w.length > 0).length;
             } catch {
@@ -16732,12 +16813,12 @@ import { z as z12 } from "zod";
 
 // src/tools/read/bidirectional.ts
 import * as fs18 from "fs/promises";
-import * as path20 from "path";
+import * as path21 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 = path20.join(vaultPath2, notePath);
+  const fullPath = path21.join(vaultPath2, notePath);
   try {
     return await fs18.readFile(fullPath, "utf-8");
   } catch {
@@ -16916,10 +16997,10 @@ async function suggestWikilinksInFrontmatter(index, notePath, vaultPath2) {
 
 // src/tools/read/computed.ts
 import * as fs19 from "fs/promises";
-import * as path21 from "path";
+import * as path22 from "path";
 import matter4 from "gray-matter";
 async function readFileContent3(notePath, vaultPath2) {
-  const fullPath = path21.join(vaultPath2, notePath);
+  const fullPath = path22.join(vaultPath2, notePath);
   try {
     return await fs19.readFile(fullPath, "utf-8");
   } catch {
@@ -16927,7 +17008,7 @@ async function readFileContent3(notePath, vaultPath2) {
   }
 }
 async function getFileStats(notePath, vaultPath2) {
-  const fullPath = path21.join(vaultPath2, notePath);
+  const fullPath = path22.join(vaultPath2, notePath);
   try {
     const stats = await fs19.stat(fullPath);
     return {
@@ -17199,7 +17280,7 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath, getConfi
 init_writer();
 import { z as z13 } from "zod";
 import fs23 from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 
 // src/core/write/validator.ts
 var TIMESTAMP_PATTERN = /^\*\*\d{2}:\d{2}\*\*/;
@@ -17418,7 +17499,7 @@ init_writer();
 init_wikilinks();
 init_wikilinkFeedback();
 import fs22 from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 function formatMcpResult(result) {
   if (result.tokensEstimate === void 0 || result.tokensEstimate === 0) {
     result.tokensEstimate = estimateTokens(result);
@@ -17466,7 +17547,7 @@ async function handleGitCommit(vaultPath2, notePath, commit, prefix) {
 }
 async function getPolicyHint(vaultPath2) {
   try {
-    const policiesDir = path23.join(vaultPath2, ".claude", "policies");
+    const policiesDir = path24.join(vaultPath2, ".claude", "policies");
     const files = await fs22.readdir(policiesDir);
     const yamlFiles = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
     if (yamlFiles.length > 0) {
@@ -17478,7 +17559,7 @@ async function getPolicyHint(vaultPath2) {
   return "";
 }
 async function ensureFileExists(vaultPath2, notePath) {
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path24.join(vaultPath2, notePath);
   try {
     await fs22.access(fullPath);
     return null;
@@ -17656,7 +17737,7 @@ async function executeCreateNote(options) {
     if (!pathCheck.valid) {
       return { success: false, result: errorResult(notePath, `Path blocked: ${pathCheck.reason}`), filesWritten: [] };
     }
-    const fullPath = path23.join(vaultPath2, notePath);
+    const fullPath = path24.join(vaultPath2, notePath);
     let fileExists = false;
     try {
       await fs22.access(fullPath);
@@ -17666,7 +17747,7 @@ async function executeCreateNote(options) {
     if (fileExists && !overwrite) {
       return { success: false, result: errorResult(notePath, `File already exists: ${notePath}. Use overwrite=true to replace.`), filesWritten: [] };
     }
-    await fs22.mkdir(path23.dirname(fullPath), { recursive: true });
+    await fs22.mkdir(path24.dirname(fullPath), { recursive: true });
     const { maybeApplyWikilinks: maybeApplyWikilinks2 } = await Promise.resolve().then(() => (init_wikilinks(), wikilinks_exports));
     const { content: processedContent } = maybeApplyWikilinks2(content, skipWikilinks ?? false, notePath);
     let finalFrontmatter = frontmatter;
@@ -17700,7 +17781,7 @@ async function executeDeleteNote(options) {
     if (!pathCheck.valid) {
       return { success: false, result: errorResult(notePath, `Path blocked: ${pathCheck.reason}`), filesWritten: [] };
     }
-    const fullPath = path23.join(vaultPath2, notePath);
+    const fullPath = path24.join(vaultPath2, notePath);
     try {
       await fs22.access(fullPath);
     } catch {
@@ -17724,10 +17805,10 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   if (!validation.valid) {
     throw new Error(`Path blocked: ${validation.reason}`);
   }
-  const fullPath = path24.join(vaultPath2, notePath);
-  await fs23.mkdir(path24.dirname(fullPath), { recursive: true });
+  const fullPath = path25.join(vaultPath2, notePath);
+  await fs23.mkdir(path25.dirname(fullPath), { recursive: true });
   const templates = config.templates || {};
-  const filename = path24.basename(notePath, ".md").toLowerCase();
+  const filename = path25.basename(notePath, ".md").toLowerCase();
   let templatePath;
   const dailyPattern = /^\d{4}-\d{2}-\d{2}/;
   const weeklyPattern = /^\d{4}-W\d{2}/;
@@ -17748,10 +17829,10 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   let templateContent;
   if (templatePath) {
     try {
-      const absTemplatePath = path24.join(vaultPath2, templatePath);
+      const absTemplatePath = path25.join(vaultPath2, templatePath);
       templateContent = await fs23.readFile(absTemplatePath, "utf-8");
     } catch {
-      const title = path24.basename(notePath, ".md");
+      const title = path25.basename(notePath, ".md");
       templateContent = `---
 ---
 
@@ -17760,7 +17841,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
       templatePath = void 0;
     }
   } else {
-    const title = path24.basename(notePath, ".md");
+    const title = path25.basename(notePath, ".md");
     templateContent = `---
 ---
 
@@ -17769,7 +17850,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, path24.basename(notePath, ".md"));
+  templateContent = templateContent.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, path25.basename(notePath, ".md"));
   const matter9 = (await import("gray-matter")).default;
   const parsed = matter9(templateContent);
   if (!parsed.data.date) {
@@ -17810,7 +17891,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
       let noteCreated = false;
       let templateUsed;
       if (create_if_missing && !dry_run) {
-        const fullPath = path24.join(vaultPath2, notePath);
+        const fullPath = path25.join(vaultPath2, notePath);
         try {
           await fs23.access(fullPath);
         } catch {
@@ -17821,7 +17902,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
         }
       }
       if (create_if_missing && dry_run) {
-        const fullPath = path24.join(vaultPath2, notePath);
+        const fullPath = path25.join(vaultPath2, notePath);
         try {
           await fs23.access(fullPath);
         } catch {
@@ -18309,7 +18390,7 @@ init_writer();
 init_wikilinks();
 import { z as z16 } from "zod";
 import fs24 from "fs/promises";
-import path25 from "path";
+import path26 from "path";
 function registerNoteTools(server2, getVaultPath, getIndex) {
   server2.tool(
     "vault_create_note",
@@ -18335,23 +18416,23 @@ function registerNoteTools(server2, getVaultPath, getIndex) {
         if (!validatePath(vaultPath2, notePath)) {
           return formatMcpResult(errorResult(notePath, "Invalid path: path traversal not allowed"));
         }
-        const fullPath = path25.join(vaultPath2, notePath);
+        const fullPath = path26.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 = path25.dirname(fullPath);
+        const dir = path26.dirname(fullPath);
         await fs24.mkdir(dir, { recursive: true });
         let effectiveContent = content;
         let effectiveFrontmatter = frontmatter;
         if (template) {
-          const templatePath = path25.join(vaultPath2, template);
+          const templatePath = path26.join(vaultPath2, template);
           try {
             const raw = await fs24.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 = path25.basename(notePath, ".md");
+            const title = path26.basename(notePath, ".md");
             let templateContent = parsed.content.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, title);
             if (content) {
               templateContent = templateContent.trimEnd() + "\n\n" + content;
@@ -18370,7 +18451,7 @@ function registerNoteTools(server2, getVaultPath, getIndex) {
           effectiveFrontmatter.created = now.toISOString();
         }
         const warnings = [];
-        const noteName = path25.basename(notePath, ".md");
+        const noteName = path26.basename(notePath, ".md");
         const existingAliases = Array.isArray(effectiveFrontmatter?.aliases) ? effectiveFrontmatter.aliases.filter((a) => typeof a === "string") : [];
         const preflight = await checkPreflightSimilarity(noteName);
         if (preflight.existingEntity) {
@@ -18511,7 +18592,7 @@ ${sources}`;
           }
           return formatMcpResult(errorResult(notePath, previewLines.join("\n")));
         }
-        const fullPath = path25.join(vaultPath2, notePath);
+        const fullPath = path26.join(vaultPath2, notePath);
         await fs24.unlink(fullPath);
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Flywheel:Delete]");
         const message = backlinkWarning ? `Deleted note: ${notePath}
@@ -18533,7 +18614,7 @@ init_git();
 init_wikilinks();
 import { z as z17 } from "zod";
 import fs25 from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 import matter6 from "gray-matter";
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -18552,7 +18633,7 @@ function extractWikilinks2(content) {
   return wikilinks;
 }
 function getTitleFromPath(filePath) {
-  return path26.basename(filePath, ".md");
+  return path27.basename(filePath, ".md");
 }
 async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   const results = [];
@@ -18561,7 +18642,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
     const files = [];
     const entries = await fs25.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path26.join(dir, entry.name);
+      const fullPath = path27.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         files.push(...await scanDir(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -18572,7 +18653,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   }
   const allFiles = await scanDir(vaultPath2);
   for (const filePath of allFiles) {
-    const relativePath = path26.relative(vaultPath2, filePath);
+    const relativePath = path27.relative(vaultPath2, filePath);
     const content = await fs25.readFile(filePath, "utf-8");
     const wikilinks = extractWikilinks2(content);
     const matchingLinks = [];
@@ -18659,8 +18740,8 @@ function registerMoveNoteTools(server2, getVaultPath) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const oldFullPath = path26.join(vaultPath2, oldPath);
-        const newFullPath = path26.join(vaultPath2, newPath);
+        const oldFullPath = path27.join(vaultPath2, oldPath);
+        const newFullPath = path27.join(vaultPath2, newPath);
         try {
           await fs25.access(oldFullPath);
         } catch {
@@ -18741,7 +18822,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const destDir = path26.dirname(newFullPath);
+        const destDir = path27.dirname(newFullPath);
         await fs25.mkdir(destDir, { recursive: true });
         await fs25.rename(oldFullPath, newFullPath);
         let gitCommit;
@@ -18817,10 +18898,10 @@ function registerMoveNoteTools(server2, getVaultPath) {
         if (sanitizedTitle !== newTitle) {
           console.error(`[Flywheel] Title sanitized: "${newTitle}" \u2192 "${sanitizedTitle}"`);
         }
-        const fullPath = path26.join(vaultPath2, notePath);
-        const dir = path26.dirname(notePath);
-        const newPath = dir === "." ? `${sanitizedTitle}.md` : path26.join(dir, `${sanitizedTitle}.md`);
-        const newFullPath = path26.join(vaultPath2, newPath);
+        const fullPath = path27.join(vaultPath2, notePath);
+        const dir = path27.dirname(notePath);
+        const newPath = dir === "." ? `${sanitizedTitle}.md` : path27.join(dir, `${sanitizedTitle}.md`);
+        const newFullPath = path27.join(vaultPath2, newPath);
         try {
           await fs25.access(fullPath);
         } catch {
@@ -19351,7 +19432,7 @@ init_schema();
 // src/core/write/policy/parser.ts
 init_schema();
 import fs27 from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 import matter7 from "gray-matter";
 function parseYaml(content) {
   const parsed = matter7(`---
@@ -19400,13 +19481,13 @@ async function loadPolicyFile(filePath) {
   }
 }
 async function loadPolicy(vaultPath2, policyName) {
-  const policiesDir = path27.join(vaultPath2, ".claude", "policies");
-  const policyPath = path27.join(policiesDir, `${policyName}.yaml`);
+  const policiesDir = path28.join(vaultPath2, ".claude", "policies");
+  const policyPath = path28.join(policiesDir, `${policyName}.yaml`);
   try {
     await fs27.access(policyPath);
     return loadPolicyFile(policyPath);
   } catch {
-    const ymlPath = path27.join(policiesDir, `${policyName}.yml`);
+    const ymlPath = path28.join(policiesDir, `${policyName}.yml`);
     try {
       await fs27.access(ymlPath);
       return loadPolicyFile(ymlPath);
@@ -19549,7 +19630,7 @@ init_writer();
 init_git();
 init_wikilinks();
 import fs29 from "fs/promises";
-import path29 from "path";
+import path30 from "path";
 init_constants();
 async function executeStep(step, vaultPath2, context, conditionResults, searchFn) {
   const { execute, reason } = shouldStepExecute(step.when, conditionResults);
@@ -19757,7 +19838,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 = path29.join(vaultPath2, notePath);
+  const fullPath = path30.join(vaultPath2, notePath);
   try {
     await fs29.access(fullPath);
   } catch {
@@ -20040,7 +20121,7 @@ async function rollbackChanges(vaultPath2, originalContents, filesModified) {
     const pathCheck = await validatePathSecure(vaultPath2, filePath);
     if (!pathCheck.valid) continue;
     const original = originalContents.get(filePath);
-    const fullPath = path29.join(vaultPath2, filePath);
+    const fullPath = path30.join(vaultPath2, filePath);
     if (original === null) {
       try {
         await fs29.unlink(fullPath);
@@ -20095,9 +20176,9 @@ async function previewPolicy(policy, vaultPath2, variables) {
 
 // src/core/write/policy/storage.ts
 import fs30 from "fs/promises";
-import path30 from "path";
+import path31 from "path";
 function getPoliciesDir(vaultPath2) {
-  return path30.join(vaultPath2, ".claude", "policies");
+  return path31.join(vaultPath2, ".claude", "policies");
 }
 async function ensurePoliciesDir(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
@@ -20112,7 +20193,7 @@ async function listPolicies(vaultPath2) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
         continue;
       }
-      const filePath = path30.join(dir, file);
+      const filePath = path31.join(dir, file);
       const stat5 = await fs30.stat(filePath);
       const content = await fs30.readFile(filePath, "utf-8");
       const metadata = extractPolicyMetadata(content);
@@ -20137,7 +20218,7 @@ async function writePolicyRaw(vaultPath2, policyName, content, overwrite = false
   const dir = getPoliciesDir(vaultPath2);
   await ensurePoliciesDir(vaultPath2);
   const filename = `${policyName}.yaml`;
-  const filePath = path30.join(dir, filename);
+  const filePath = path31.join(dir, filename);
   if (!overwrite) {
     try {
       await fs30.access(filePath);
@@ -20683,7 +20764,7 @@ import { z as z22 } from "zod";
 
 // src/core/write/tagRename.ts
 import * as fs31 from "fs/promises";
-import * as path31 from "path";
+import * as path32 from "path";
 import matter8 from "gray-matter";
 import { getProtectedZones as getProtectedZones2 } from "@velvetmonkey/vault-core";
 function getNotesInFolder3(index, folder) {
@@ -20789,7 +20870,7 @@ async function renameTag(index, vaultPath2, oldTag, newTag, options) {
   const previews = [];
   let totalChanges = 0;
   for (const note of affectedNotes) {
-    const fullPath = path31.join(vaultPath2, note.path);
+    const fullPath = path32.join(vaultPath2, note.path);
     let fileContent;
     try {
       fileContent = await fs31.readFile(fullPath, "utf-8");
@@ -22097,7 +22178,7 @@ init_wikilinks();
 init_wikilinkFeedback();
 import { z as z29 } from "zod";
 import * as fs32 from "fs/promises";
-import * as path32 from "path";
+import * as path33 from "path";
 import { scanVaultEntities as scanVaultEntities3, SCHEMA_VERSION as SCHEMA_VERSION2 } from "@velvetmonkey/vault-core";
 init_embeddings();
 function hasSkipWikilinks(content) {
@@ -22113,13 +22194,13 @@ async function collectMarkdownFiles(dirPath, basePath, excludeFolders) {
     const entries = await fs32.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const fullPath = path32.join(dirPath, entry.name);
+      const fullPath = path33.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (excludeFolders.some((f) => entry.name.toLowerCase() === f.toLowerCase())) continue;
         const sub = await collectMarkdownFiles(fullPath, basePath, excludeFolders);
         results.push(...sub);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        results.push(path32.relative(basePath, fullPath));
+        results.push(path33.relative(basePath, fullPath));
       }
     }
   } catch {
@@ -22149,7 +22230,7 @@ var EXCLUDE_FOLDERS = [
 ];
 function buildStatusReport(stateDb2, vaultPath2) {
   const recommendations = [];
-  const dbPath = path32.join(vaultPath2, ".flywheel", "state.db");
+  const dbPath = path33.join(vaultPath2, ".flywheel", "state.db");
   const statedbExists = stateDb2 !== null;
   if (!statedbExists) {
     recommendations.push("StateDb not initialized \u2014 server needs restart");
@@ -22275,7 +22356,7 @@ async function executeRun(stateDb2, vaultPath2) {
       const allFiles = await collectMarkdownFiles(vaultPath2, vaultPath2, EXCLUDE_FOLDERS);
       let eligible = 0;
       for (const relativePath of allFiles) {
-        const fullPath = path32.join(vaultPath2, relativePath);
+        const fullPath = path33.join(vaultPath2, relativePath);
         let content;
         try {
           content = await fs32.readFile(fullPath, "utf-8");
@@ -22333,7 +22414,7 @@ async function executeEnrich(stateDb2, vaultPath2, dryRun, batchSize, offset) {
   const eligible = [];
   let notesSkipped = 0;
   for (const relativePath of allFiles) {
-    const fullPath = path32.join(vaultPath2, relativePath);
+    const fullPath = path33.join(vaultPath2, relativePath);
     let content;
     try {
       content = await fs32.readFile(fullPath, "utf-8");
@@ -22363,7 +22444,7 @@ async function executeEnrich(stateDb2, vaultPath2, dryRun, batchSize, offset) {
       match_count: result.linksAdded
     });
     if (!dryRun) {
-      const fullPath = path32.join(vaultPath2, relativePath);
+      const fullPath = path33.join(vaultPath2, relativePath);
       await fs32.writeFile(fullPath, result.content, "utf-8");
       notesModified++;
       if (stateDb2) {
@@ -22596,7 +22677,7 @@ import { z as z32 } from "zod";
 // src/core/read/similarity.ts
 init_embeddings();
 import * as fs33 from "fs";
-import * as path33 from "path";
+import * as path34 from "path";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
   "be",
@@ -22733,7 +22814,7 @@ function extractKeyTerms(content, maxTerms = 15) {
 }
 function findSimilarNotes(db4, vaultPath2, index, sourcePath, options = {}) {
   const limit = options.limit ?? 10;
-  const absPath = path33.join(vaultPath2, sourcePath);
+  const absPath = path34.join(vaultPath2, sourcePath);
   let content;
   try {
     content = fs33.readFileSync(absPath, "utf-8");
@@ -22875,7 +22956,7 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb3) {
         diversity: z32.number().min(0).max(1).optional().describe("Relevance vs diversity tradeoff (0=max diversity, 1=pure relevance, default: 0.7)")
       }
     },
-    async ({ path: path36, limit, diversity }) => {
+    async ({ path: path37, limit, diversity }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const stateDb2 = getStateDb3();
@@ -22884,10 +22965,10 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb3) {
           content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
         };
       }
-      if (!index.notes.has(path36)) {
+      if (!index.notes.has(path37)) {
         return {
           content: [{ type: "text", text: JSON.stringify({
-            error: `Note not found: ${path36}`,
+            error: `Note not found: ${path37}`,
             hint: "Use the full relative path including .md extension"
           }, null, 2) }]
         };
@@ -22899,12 +22980,12 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb3) {
       };
       const useHybrid = hasEmbeddingsIndex();
       const method = useHybrid ? "hybrid" : "bm25";
-      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path36, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path36, opts);
+      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path37, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path37, opts);
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
-            source: path36,
+            source: path37,
             method,
             count: results.length,
             similar: results
@@ -24136,7 +24217,7 @@ function registerVaultResources(server2, getIndex) {
 // src/tool-registry.ts
 var __trFilename = fileURLToPath(import.meta.url);
 var __trDirname = dirname5(__trFilename);
-var trPkg = JSON.parse(readFileSync5(join18(__trDirname, "../package.json"), "utf-8"));
+var trPkg = JSON.parse(readFileSync5(join19(__trDirname, "../package.json"), "utf-8"));
 function applyToolGating(targetServer, categories, getDb4, registry, getVaultPath, vaultCallbacks) {
   let _registered = 0;
   let _skipped = 0;
@@ -24201,7 +24282,7 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
               let totalBytes = 0;
               for (const p of notePaths) {
                 try {
-                  totalBytes += statSync5(path34.join(vp, p)).size;
+                  totalBytes += statSync6(path35.join(vp, p)).size;
                 } catch {
                 }
               }
@@ -24422,7 +24503,7 @@ function registerAllTools(targetServer, ctx) {
 // src/index.ts
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = dirname7(__filename);
-var pkg = JSON.parse(readFileSync6(join20(__dirname, "../package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync6(join21(__dirname, "../package.json"), "utf-8"));
 var vaultPath = process.env.PROJECT_PATH || process.env.VAULT_PATH || findVaultRoot();
 var resolvedVaultPath;
 try {
@@ -24774,7 +24855,7 @@ async function buildStartupCatchupBatch(vaultPath2, sinceMs) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path35.join(dir, entry.name);
+      const fullPath = path36.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
         await scanDir(fullPath);
@@ -24784,7 +24865,7 @@ async function buildStartupCatchupBatch(vaultPath2, sinceMs) {
           if (stat5.mtimeMs > sinceMs) {
             events.push({
               type: "upsert",
-              path: path35.relative(vaultPath2, fullPath),
+              path: path36.relative(vaultPath2, fullPath),
               originalEvents: []
             });
           }
@@ -24981,8 +25062,8 @@ async function runPostIndexWork(ctx) {
           }
         } catch {
           try {
-            const dir = path35.dirname(rawPath);
-            const base = path35.basename(rawPath);
+            const dir = path36.dirname(rawPath);
+            const base = path36.basename(rawPath);
             const resolvedDir = realpathSync(dir).replace(/\\/g, "/");
             for (const prefix of vaultPrefixes) {
               if (resolvedDir.startsWith(prefix + "/") || resolvedDir === prefix) {
@@ -25014,7 +25095,7 @@ async function runPostIndexWork(ctx) {
           continue;
         }
         try {
-          const content = await fs34.readFile(path35.join(vp, event.path), "utf-8");
+          const content = await fs34.readFile(path36.join(vp, event.path), "utf-8");
           const hash = createHash3("sha256").update(content).digest("hex").slice(0, 16);
           if (lastContentHashes.get(event.path) === hash) {
             serverLog("watcher", `Hash unchanged, skipping: ${event.path}`);