npm - @velvetmonkey/flywheel-memory - Versions diffs - 2.5.12 → 2.5.14 - Mend

@velvetmonkey/flywheel-memory 2.5.12 → 2.5.14

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

Files changed (3) hide show

package/dist/index.js CHANGED Viewed

@@ -344,7 +344,7 @@ function resolveWorkerPath() {
 async function initEmbeddings() {
   if (workerReady && worker) return;
   if (workerInitPromise) return workerInitPromise;
-  workerInitPromise = new Promise((resolve3, reject) => {
+  workerInitPromise = new Promise((resolve4, reject) => {
     try {
       const workerPath = resolveWorkerPath();
       console.error(`[Semantic] Spawning embedding worker: ${workerPath}`);
@@ -359,7 +359,7 @@ async function initEmbeddings() {
               console.error(`[Semantic] Probed model ${activeModelConfig.id}: ${msg.dims} dims`);
             }
             console.error(`[Semantic] Worker ready (model: ${activeModelConfig.id}, dims: ${msg.dims})`);
-            resolve3();
+            resolve4();
             break;
           case "result": {
             const pending = pendingEmbeds.get(msg.id);
@@ -435,8 +435,8 @@ async function embedText(text) {
     throw new Error("Embedding worker not available");
   }
   const id = ++embedRequestId;
-  return new Promise((resolve3, reject) => {
-    pendingEmbeds.set(id, { resolve: resolve3, reject });
+  return new Promise((resolve4, reject) => {
+    pendingEmbeds.set(id, { resolve: resolve4, reject });
     worker.postMessage({ type: "embed", id, text });
   });
 }
@@ -2696,7 +2696,7 @@ function isLockContentionError(error) {
   return false;
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function calculateDelay(attempt, config2) {
   let delay = config2.baseDelayMs * Math.pow(2, attempt);
@@ -4304,10 +4304,26 @@ async function suggestRelatedLinks(content, options = {}) {
             (token) => contentTokens.has(token) || contentStems.has(stem(token))
           );
           const strongCooccurrence = boost >= config2.minCooccurrenceGate;
-          if (!hasContentOverlap && !strongCooccurrence) {
+          let multiSeedOK = true;
+          if (!hasContentOverlap && cooccurrenceIndex && config2.minContentMatch > 0) {
+            let qualifyingSeedCount = 0;
+            for (const seed of cooccurrenceSeeds) {
+              const entityAssocs = cooccurrenceIndex.associations[seed];
+              if (!entityAssocs) continue;
+              const coocCount = entityAssocs.get(entityName) || 0;
+              if (coocCount < (cooccurrenceIndex.minCount ?? 2)) continue;
+              const dfEntity = cooccurrenceIndex.documentFrequency?.get(entityName) || 0;
+              const dfSeed = cooccurrenceIndex.documentFrequency?.get(seed) || 0;
+              if (dfEntity === 0 || dfSeed === 0) continue;
+              const npmi = computeNpmi(coocCount, dfEntity, dfSeed, cooccurrenceIndex.totalNotesScanned ?? 1);
+              if (npmi > 0) qualifyingSeedCount++;
+            }
+            multiSeedOK = qualifyingSeedCount >= 2;
+          }
+          if (!hasContentOverlap && !(strongCooccurrence && multiSeedOK)) {
             continue;
           }
-          if (hasContentOverlap || strongCooccurrence) {
+          if (hasContentOverlap || strongCooccurrence && multiSeedOK) {
             entitiesWithAnyScoringPath.add(entityName);
           }
           const typeBoost = disabled.has("type_boost") ? 0 : getTypeBoost(category, getConfig()?.custom_categories, entityName);
@@ -4853,8 +4869,8 @@ var init_wikilinks = __esm({
         minWordLength: 3,
         minSuggestionScore: 10,
         // Exact match (10) or two stem matches
-        minMatchRatio: 0.4,
-        // 40% of multi-word entity must match
+        minMatchRatio: 0.6,
+        // 60% of multi-word entity must match (blocks 1-of-2 token FPs)
         requireMultipleMatches: false,
         stemMatchBonus: 5,
         // Standard bonus for stem matches
@@ -4863,8 +4879,10 @@ var init_wikilinks = __esm({
         fuzzyMatchBonus: 4,
         // Moderate fuzzy bonus
         contentRelevanceFloor: 5,
-        noRelevanceCap: 10,
-        minCooccurrenceGate: 5,
+        noRelevanceCap: 9,
+        // Below minSuggestionScore — graph-only entities can't reach threshold
+        minCooccurrenceGate: 6,
+        // Stronger graph signal for graph-only admission
         minContentMatch: 2
       },
       aggressive: {
@@ -5185,16 +5203,16 @@ var init_tool_embeddings_generated = __esm({
 // src/core/write/path-security.ts
 import fs20 from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 function isSensitivePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
   return SENSITIVE_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath));
 }
 function isWithinDirectory(child, parent, allowEqual = false) {
-  const rel = path22.relative(path22.resolve(parent), path22.resolve(child));
+  const rel = path23.relative(path23.resolve(parent), path23.resolve(child));
   if (rel === "") return allowEqual;
-  const firstSeg = rel.split(path22.sep)[0];
-  return firstSeg !== ".." && !path22.isAbsolute(rel);
+  const firstSeg = rel.split(path23.sep)[0];
+  return firstSeg !== ".." && !path23.isAbsolute(rel);
 }
 function validatePath(vaultPath2, notePath) {
   if (notePath.startsWith("/")) {
@@ -5206,11 +5224,11 @@ function validatePath(vaultPath2, notePath) {
   if (notePath.startsWith("\\")) {
     return false;
   }
-  return isWithinDirectory(path22.resolve(vaultPath2, notePath), vaultPath2);
+  return isWithinDirectory(path23.resolve(vaultPath2, notePath), vaultPath2);
 }
 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, "-");
@@ -5219,7 +5237,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("/")) {
@@ -5240,14 +5258,14 @@ async function validatePathSecure(vaultPath2, notePath) {
       reason: "Absolute paths not allowed"
     };
   }
-  const firstSeg = path22.normalize(notePath).split(path22.sep).filter(Boolean)[0];
+  const firstSeg = path23.normalize(notePath).split(path23.sep).filter(Boolean)[0];
   if (firstSeg === "..") {
     return {
       valid: false,
       reason: "Path traversal not allowed"
     };
   }
-  if (!isWithinDirectory(path22.resolve(vaultPath2, notePath), vaultPath2)) {
+  if (!isWithinDirectory(path23.resolve(vaultPath2, notePath), vaultPath2)) {
     return {
       valid: false,
       reason: "Path traversal not allowed"
@@ -5260,7 +5278,7 @@ async function validatePathSecure(vaultPath2, notePath) {
     };
   }
   try {
-    const fullPath = path22.join(vaultPath2, notePath);
+    const fullPath = path23.join(vaultPath2, notePath);
     try {
       await fs20.access(fullPath);
       const realPath = await fs20.realpath(fullPath);
@@ -5271,7 +5289,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,
@@ -5279,7 +5297,7 @@ async function validatePathSecure(vaultPath2, notePath) {
         };
       }
     } catch {
-      const parentDir = path22.dirname(fullPath);
+      const parentDir = path23.dirname(fullPath);
       try {
         await fs20.access(parentDir);
         const realParentPath = await fs20.realpath(parentDir);
@@ -6058,7 +6076,7 @@ var init_content_mutation = __esm({
 // src/core/write/file-io.ts
 import fs21 from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 import matter5 from "gray-matter";
 import { createHash as createHash2 } from "node:crypto";
 function computeContentHash(rawContent) {
@@ -6069,7 +6087,7 @@ async function readVaultFile(vaultPath2, notePath) {
   if (!validation.valid) {
     throw new Error(`Invalid path: ${validation.reason}`);
   }
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path24.join(vaultPath2, notePath);
   const [rawContent, stat4] = await Promise.all([
     fs21.readFile(fullPath, "utf-8"),
     fs21.stat(fullPath)
@@ -6124,7 +6142,7 @@ async function writeVaultFile(vaultPath2, notePath, content, frontmatter, lineEn
   if (!validation.valid) {
     throw new Error(`Invalid path: ${validation.reason}`);
   }
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path24.join(vaultPath2, notePath);
   if (expectedHash) {
     const currentRaw = await fs21.readFile(fullPath, "utf-8");
     const currentHash = computeContentHash(currentRaw);
@@ -6192,8 +6210,8 @@ function createContext(variables = {}) {
     steps: {}
   };
 }
-function resolvePath(obj, path40) {
-  const parts = path40.split(".");
+function resolvePath(obj, path41) {
+  const parts = path41.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === void 0 || current === null) {
@@ -6651,7 +6669,7 @@ __export(conditions_exports, {
   shouldStepExecute: () => shouldStepExecute
 });
 import fs29 from "fs/promises";
-import path31 from "path";
+import path32 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;
@@ -6704,7 +6722,7 @@ async function evaluateCondition(condition, vaultPath2, context) {
   }
 }
 async function evaluateFileExists(vaultPath2, notePath, expectExists) {
-  const fullPath = path31.join(vaultPath2, notePath);
+  const fullPath = path32.join(vaultPath2, notePath);
   try {
     await fs29.access(fullPath);
     return {
@@ -6719,7 +6737,7 @@ async function evaluateFileExists(vaultPath2, notePath, expectExists) {
   }
 }
 async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectExists) {
-  const fullPath = path31.join(vaultPath2, notePath);
+  const fullPath = path32.join(vaultPath2, notePath);
   try {
     await fs29.access(fullPath);
   } catch {
@@ -6750,7 +6768,7 @@ async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectEx
   }
 }
 async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expectExists) {
-  const fullPath = path31.join(vaultPath2, notePath);
+  const fullPath = path32.join(vaultPath2, notePath);
   try {
     await fs29.access(fullPath);
   } catch {
@@ -6781,7 +6799,7 @@ async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expect
   }
 }
 async function evaluateFrontmatterEquals(vaultPath2, notePath, fieldName, expectedValue) {
-  const fullPath = path31.join(vaultPath2, notePath);
+  const fullPath = path32.join(vaultPath2, notePath);
   try {
     await fs29.access(fullPath);
   } catch {
@@ -6925,10 +6943,10 @@ var init_taskHelpers = __esm({
 });
 // src/index.ts
-import * as path39 from "path";
-import { readFileSync as readFileSync6, realpathSync, existsSync as existsSync3 } from "fs";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname7, join as join20 } from "path";
+import * as path40 from "path";
+import { readFileSync as readFileSync6, realpathSync, existsSync as existsSync4 } from "fs";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { dirname as dirname8, join as join21 } from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { performance as performance2 } from "node:perf_hooks";
@@ -7165,8 +7183,8 @@ function updateIndexProgress(parsed, total) {
 function normalizeTarget(target) {
   return target.toLowerCase().replace(/\.md$/, "");
 }
-function normalizeNotePath(path40) {
-  return path40.toLowerCase().replace(/\.md$/, "");
+function normalizeNotePath(path41) {
+  return path41.toLowerCase().replace(/\.md$/, "");
 }
 async function buildVaultIndex(vaultPath2, options = {}) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
@@ -7214,7 +7232,7 @@ async function buildVaultIndexInternal(vaultPath2, startTime, onProgress) {
       console.error(`Parsed ${parsedCount}/${files.length} files (${elapsed}s)`);
       onProgress?.(parsedCount, files.length);
     }
-    await new Promise((resolve3) => setImmediate(resolve3));
+    await new Promise((resolve4) => setImmediate(resolve4));
   }
   if (parseErrors.length > 0) {
     const msg = `Failed to parse ${parseErrors.length} file(s):`;
@@ -7340,7 +7358,7 @@ function findSimilarEntity(index, target) {
   }
   const maxDist = normalizedLen <= 10 ? 1 : 2;
   let bestMatch;
-  for (const [entity, path40] of index.entities) {
+  for (const [entity, path41] of index.entities) {
     const lenDiff = Math.abs(entity.length - normalizedLen);
     if (lenDiff > maxDist) {
       continue;
@@ -7348,7 +7366,7 @@ function findSimilarEntity(index, target) {
     const dist = levenshteinDistance(normalized, entity);
     if (dist > 0 && dist <= maxDist) {
       if (!bestMatch || dist < bestMatch.distance) {
-        bestMatch = { path: path40, entity, distance: dist };
+        bestMatch = { path: path41, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -7907,30 +7925,30 @@ var EventQueue = class {
    * Add a new event to the queue
    */
   push(type, rawPath) {
-    const path40 = normalizePath(rawPath);
+    const path41 = normalizePath(rawPath);
     const now = Date.now();
     const event = {
       type,
-      path: path40,
+      path: path41,
       timestamp: now
     };
-    let pending = this.pending.get(path40);
+    let pending = this.pending.get(path41);
     if (!pending) {
       pending = {
         events: [],
         timer: null,
         lastEvent: now
       };
-      this.pending.set(path40, pending);
+      this.pending.set(path41, pending);
     }
     pending.events.push(event);
     pending.lastEvent = now;
-    console.error(`[flywheel] QUEUE: pushed ${type} for ${path40}, pending=${this.pending.size}`);
+    console.error(`[flywheel] QUEUE: pushed ${type} for ${path41}, pending=${this.pending.size}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
     }
     pending.timer = setTimeout(() => {
-      this.flushPath(path40);
+      this.flushPath(path41);
     }, this.config.debounceMs);
     if (this.pending.size >= this.config.batchSize) {
       this.flush();
@@ -7951,10 +7969,10 @@ var EventQueue = class {
   /**
    * Flush a single path's events
    */
-  flushPath(path40) {
-    const pending = this.pending.get(path40);
+  flushPath(path41) {
+    const pending = this.pending.get(path41);
     if (!pending || pending.events.length === 0) return;
-    console.error(`[flywheel] QUEUE: flushing ${path40}, events=${pending.events.length}`);
+    console.error(`[flywheel] QUEUE: flushing ${path41}, events=${pending.events.length}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -7963,7 +7981,7 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path40,
+        path: path41,
         originalEvents: [...pending.events]
       };
       this.onBatch({
@@ -7972,7 +7990,7 @@ var EventQueue = class {
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path40);
+    this.pending.delete(path41);
   }
   /**
    * Flush all pending events
@@ -7984,7 +8002,7 @@ var EventQueue = class {
     }
     if (this.pending.size === 0) return;
     const events = [];
-    for (const [path40, pending] of this.pending) {
+    for (const [path41, pending] of this.pending) {
       if (pending.timer) {
         clearTimeout(pending.timer);
       }
@@ -7992,7 +8010,7 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path40,
+          path: path41,
           originalEvents: [...pending.events]
         });
       }
@@ -8292,7 +8310,7 @@ async function processBatch(index, vaultPath2, batch, options = {}) {
     }
     onProgress?.(processed, total);
     if (processed % YIELD_INTERVAL === 0 && processed < total) {
-      await new Promise((resolve3) => setImmediate(resolve3));
+      await new Promise((resolve4) => setImmediate(resolve4));
     }
   }
   const durationMs = Date.now() - startTime;
@@ -8384,31 +8402,31 @@ function createVaultWatcher(options) {
         usePolling: config2.usePolling,
         interval: config2.usePolling ? config2.pollInterval : void 0
       });
-      watcher.on("add", (path40) => {
-        console.error(`[flywheel] RAW EVENT: add ${path40}`);
-        if (shouldWatch(path40, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: add ${path40}`);
-          eventQueue.push("add", path40);
+      watcher.on("add", (path41) => {
+        console.error(`[flywheel] RAW EVENT: add ${path41}`);
+        if (shouldWatch(path41, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: add ${path41}`);
+          eventQueue.push("add", path41);
         } else {
-          console.error(`[flywheel] FILTERED: add ${path40}`);
+          console.error(`[flywheel] FILTERED: add ${path41}`);
         }
       });
-      watcher.on("change", (path40) => {
-        console.error(`[flywheel] RAW EVENT: change ${path40}`);
-        if (shouldWatch(path40, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: change ${path40}`);
-          eventQueue.push("change", path40);
+      watcher.on("change", (path41) => {
+        console.error(`[flywheel] RAW EVENT: change ${path41}`);
+        if (shouldWatch(path41, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: change ${path41}`);
+          eventQueue.push("change", path41);
         } else {
-          console.error(`[flywheel] FILTERED: change ${path40}`);
+          console.error(`[flywheel] FILTERED: change ${path41}`);
         }
       });
-      watcher.on("unlink", (path40) => {
-        console.error(`[flywheel] RAW EVENT: unlink ${path40}`);
-        if (shouldWatch(path40, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: unlink ${path40}`);
-          eventQueue.push("unlink", path40);
+      watcher.on("unlink", (path41) => {
+        console.error(`[flywheel] RAW EVENT: unlink ${path41}`);
+        if (shouldWatch(path41, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: unlink ${path41}`);
+          eventQueue.push("unlink", path41);
         } else {
-          console.error(`[flywheel] FILTERED: unlink ${path40}`);
+          console.error(`[flywheel] FILTERED: unlink ${path41}`);
         }
       });
       watcher.on("ready", () => {
@@ -8448,8 +8466,6 @@ import {
   getProtectedZones,
   rangeOverlapsProtectedZone,
   detectImplicitEntities as detectImplicitEntities2,
-  checkDbIntegrity,
-  safeBackupAsync,
   recordEntityMention as recordEntityMention2
 } from "@velvetmonkey/vault-core";
 init_serverLog();
@@ -9740,6 +9756,17 @@ var PipelineRunner = class {
   suggestionResults = [];
   async run() {
     const { p, tracker } = this;
+    if (p.ctx.integrityState === "failed") {
+      serverLog("watcher", `Skipping batch for ${p.ctx.name}: StateDb integrity failed`, "warn");
+      this.activity.busy = false;
+      this.activity.current_step = null;
+      this.activity.last_completed_at = Date.now();
+      this.activity.last_completed_trigger = "watcher";
+      this.activity.last_completed_duration_ms = 0;
+      this.activity.last_completed_files = p.events.length;
+      this.activity.last_completed_steps = [];
+      return;
+    }
     this.activity.busy = true;
     this.activity.trigger = "watcher";
     this.activity.started_at = this.batchStart;
@@ -10625,21 +10652,15 @@ var PipelineRunner = class {
   async integrityCheck() {
     const { p } = this;
     if (!p.sd) return { skipped: true, reason: "no statedb" };
-    const INTEGRITY_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1e3;
-    const lastCheckRow = p.sd.getMetadataValue.get("last_integrity_check");
-    const lastCheck = lastCheckRow ? parseInt(lastCheckRow.value, 10) : 0;
-    if (Date.now() - lastCheck < INTEGRITY_CHECK_INTERVAL_MS) {
-      return { skipped: true, reason: "checked recently" };
-    }
-    const result = checkDbIntegrity(p.sd.db);
-    p.sd.setMetadataValue.run("last_integrity_check", String(Date.now()));
-    if (result.ok) {
-      await safeBackupAsync(p.sd.db, p.sd.dbPath);
-      return { integrity: "ok", backed_up: true };
-    } else {
+    const result = await p.runIntegrityCheck(p.ctx, "watcher");
+    if (result.status === "healthy") {
+      return { integrity: "ok", backed_up: result.backupCreated };
+    }
+    if (result.status === "failed") {
       serverLog("watcher", `Integrity check FAILED: ${result.detail}`, "error");
       return { integrity: "failed", detail: result.detail };
     }
+    return { skipped: true, reason: result.detail ?? "integrity runner unavailable" };
   }
   // ── Maintenance: periodic incremental vacuum ─────────────────────
   async maintenance() {
@@ -10999,8 +11020,77 @@ function getToolSelectionReport(stateDb2, daysBack = 7) {
   };
 }
+// src/core/read/integrity.ts
+import * as path16 from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { Worker as Worker2 } from "node:worker_threads";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var INTEGRITY_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+var INTEGRITY_CHECK_TIMEOUT_MS = 2 * 60 * 1e3;
+var INTEGRITY_BACKUP_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+var INTEGRITY_METADATA_KEYS = {
+  checkedAt: "last_integrity_check",
+  status: "last_integrity_status",
+  durationMs: "last_integrity_duration_ms",
+  detail: "last_integrity_detail"
+};
+function resolveWorkerSpec() {
+  const thisFile = fileURLToPath2(import.meta.url);
+  const thisDir = path16.dirname(thisFile);
+  const prodPath = path16.join(thisDir, "integrity-worker.js");
+  if (existsSync3(prodPath)) return { filename: prodPath };
+  const distPath = path16.resolve(thisDir, "..", "..", "..", "dist", "integrity-worker.js");
+  if (existsSync3(distPath)) return { filename: distPath };
+  const srcPath = path16.join(thisDir, "integrity-worker.ts");
+  return { filename: srcPath, execArgv: ["--import", "tsx"] };
+}
+async function runIntegrityWorker(message, timeoutMs = INTEGRITY_CHECK_TIMEOUT_MS) {
+  const workerSpec = resolveWorkerSpec();
+  return new Promise((resolve4) => {
+    const worker2 = new Worker2(workerSpec.filename, {
+      execArgv: workerSpec.execArgv
+    });
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer2);
+      void worker2.terminate().catch(() => {
+      });
+      resolve4(result);
+    };
+    const timer2 = setTimeout(() => {
+      finish({
+        status: "error",
+        detail: `Integrity worker timed out after ${timeoutMs}ms`,
+        durationMs: timeoutMs,
+        backupCreated: false
+      });
+    }, timeoutMs);
+    worker2.once("message", (result) => finish(result));
+    worker2.once("error", (err) => {
+      finish({
+        status: "error",
+        detail: err.message,
+        durationMs: 0,
+        backupCreated: false
+      });
+    });
+    worker2.once("exit", (code) => {
+      if (settled || code === 0) return;
+      finish({
+        status: "error",
+        detail: `Integrity worker exited with code ${code}`,
+        durationMs: 0,
+        backupCreated: false
+      });
+    });
+    worker2.postMessage(message);
+  });
+}
 // src/index.ts
-import { openStateDb, scanVaultEntities as scanVaultEntities5, getAllEntitiesFromDb as getAllEntitiesFromDb6, loadContentHashes, saveContentHashBatch, renameContentHash, checkDbIntegrity as checkDbIntegrity2, safeBackupAsync as safeBackupAsync2, preserveCorruptedDb, deleteStateDbFiles, attemptSalvage } from "@velvetmonkey/vault-core";
+import { openStateDb, scanVaultEntities as scanVaultEntities5, getAllEntitiesFromDb as getAllEntitiesFromDb6, loadContentHashes, saveContentHashBatch, renameContentHash } from "@velvetmonkey/vault-core";
 // src/core/write/memory.ts
 init_wikilinkFeedback();
@@ -12074,8 +12164,8 @@ function getNoteAccessFrequency(stateDb2, daysBack = 30) {
       }
     }
   }
-  return Array.from(noteMap.entries()).map(([path40, stats]) => ({
-    path: path40,
+  return Array.from(noteMap.entries()).map(([path41, stats]) => ({
+    path: path41,
     access_count: stats.access_count,
     last_accessed: stats.last_accessed,
     tools_used: Array.from(stats.tools)
@@ -12762,10 +12852,10 @@ Use "flywheel_config" to inspect runtime configuration and set "tool_tier_overri
 }
 // src/tool-registry.ts
-import * as path38 from "path";
-import { dirname as dirname5, join as join18 } from "path";
+import * as path39 from "path";
+import { dirname as dirname6, join as join19 } from "path";
 import { statSync as statSync6, readFileSync as readFileSync5 } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import { z as z39 } from "zod";
 import { CallToolRequestSchema, ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
 import { getSessionId } from "@velvetmonkey/vault-core";
@@ -13114,13 +13204,13 @@ function multiHopBackfill(primaryResults, index, stateDb2, config2 = {}) {
   candidates.sort((a, b) => b.score - a.score);
   return candidates.slice(0, cfg.maxBackfill).map((c) => c.result);
 }
-function scoreCandidate(path40, index, stateDb2) {
-  const note = index.notes.get(path40);
+function scoreCandidate(path41, index, stateDb2) {
+  const note = index.notes.get(path41);
   const decay = recencyDecay(note?.modified);
   let hubScore = 1;
   if (stateDb2) {
     try {
-      const title = note?.title ?? path40.replace(/\.md$/, "").split("/").pop() ?? "";
+      const title = note?.title ?? path41.replace(/\.md$/, "").split("/").pop() ?? "";
       const entity = getEntityByName3(stateDb2, title);
       if (entity) hubScore = entity.hubScore ?? 1;
     } catch {
@@ -13357,7 +13447,7 @@ init_stemmer();
 // src/tools/read/structure.ts
 import * as fs12 from "fs";
-import * as path16 from "path";
+import * as path17 from "path";
 var HEADING_REGEX2 = /^(#{1,6})\s+(.+)$/;
 function extractHeadings2(content) {
   const lines = content.replace(/\r\n/g, "\n").split("\n");
@@ -13411,7 +13501,7 @@ function buildSections(headings, totalLines) {
 async function getNoteStructure(index, notePath, vaultPath2) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path16.join(vaultPath2, notePath);
+  const absolutePath = path17.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs12.promises.readFile(absolutePath, "utf-8");
@@ -13435,7 +13525,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 = path16.join(vaultPath2, notePath);
+  const absolutePath = path17.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs12.promises.readFile(absolutePath, "utf-8");
@@ -13478,7 +13568,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 = path16.join(vaultPath2, note.path);
+    const absolutePath = path17.join(vaultPath2, note.path);
     let content;
     try {
       content = await fs12.promises.readFile(absolutePath, "utf-8");
@@ -13580,11 +13670,11 @@ function applyEntityBridging(results, stateDb2, maxBridgesPerResult = 5) {
   const linkMap = /* @__PURE__ */ new Map();
   try {
     const paths = results.map((r) => r.path).filter(Boolean);
-    for (const path40 of paths) {
+    for (const path41 of paths) {
       const rows = stateDb2.db.prepare(
         "SELECT target FROM note_links WHERE note_path = ?"
-      ).all(path40);
-      linkMap.set(path40, new Set(rows.map((r) => r.target)));
+      ).all(path41);
+      linkMap.set(path41, new Set(rows.map((r) => r.target)));
     }
   } catch {
     return;
@@ -14137,7 +14227,7 @@ init_vault_scope();
 // src/tools/read/graph.ts
 import * as fs13 from "fs";
-import * as path17 from "path";
+import * as path18 from "path";
 import { z as z2 } from "zod";
 // src/tools/read/graphAdvanced.ts
@@ -14571,7 +14661,7 @@ function detectCycles(index, maxLength = 10, limit = 20) {
 // src/tools/read/graph.ts
 async function getContext(vaultPath2, sourcePath, line, contextLines = 1) {
   try {
-    const fullPath = path17.join(vaultPath2, sourcePath);
+    const fullPath = path18.join(vaultPath2, sourcePath);
     const content = await fs13.promises.readFile(fullPath, "utf-8");
     const allLines = content.split("\n");
     let fmLines = 0;
@@ -15116,14 +15206,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath, getStateDb4 = ()
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path40] of entities) {
+    for (const [name, path41] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path40;
+        return path41;
       }
     }
-    for (const [name, path40] of entities) {
+    for (const [name, path41] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path40;
+        return path41;
       }
     }
     return void 0;
@@ -15666,7 +15756,17 @@ function getProactiveLinkingOneLiner(stateDb2, daysBack = 1) {
 init_wikilinkFeedback();
 init_embeddings();
 var STALE_THRESHOLD_SECONDS = 300;
-function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () => ({}), getStateDb4 = () => null, getWatcherStatus2 = () => null, getVersion = () => "unknown", getPipelineActivityState = () => null) {
+function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () => ({}), getStateDb4 = () => null, getWatcherStatus2 = () => null, getVersion = () => "unknown", getPipelineActivityState = () => null, getVaultRuntimeState = () => ({
+  bootState: "booting",
+  integrityState: "unknown",
+  integrityCheckInProgress: false,
+  integrityStartedAt: null,
+  integritySource: null,
+  lastIntegrityCheckedAt: null,
+  lastIntegrityDurationMs: null,
+  lastIntegrityDetail: null,
+  lastBackupAt: null
+})) {
   const IndexProgressSchema = z4.object({
     parsed: z4.coerce.number().describe("Number of files parsed so far"),
     total: z4.coerce.number().describe("Total number of files to parse")
@@ -15819,18 +15919,14 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
     }
     let dbIntegrityFailed = false;
     const stateDb2 = getStateDb4();
-    if (stateDb2) {
-      try {
-        const result = stateDb2.db.pragma("quick_check");
-        const ok = result.length === 1 && Object.values(result[0])[0] === "ok";
-        if (!ok) {
-          dbIntegrityFailed = true;
-          recommendations.push(`Database integrity check failed: ${Object.values(result[0])[0] ?? "unknown error"}`);
-        }
-      } catch (err) {
-        dbIntegrityFailed = true;
-        recommendations.push(`Database integrity check error: ${err instanceof Error ? err.message : err}`);
-      }
+    const runtimeState = getVaultRuntimeState();
+    if (runtimeState.integrityState === "failed") {
+      dbIntegrityFailed = true;
+      recommendations.push(`Database integrity check failed: ${runtimeState.lastIntegrityDetail ?? "unknown integrity failure"}`);
+    } else if (runtimeState.integrityState === "error") {
+      recommendations.push(`Database integrity check error: ${runtimeState.lastIntegrityDetail ?? "integrity runner error"}`);
+    } else if (runtimeState.integrityCheckInProgress) {
+      recommendations.push("Database integrity check is still running.");
     }
     const indexBuilt = indexState2 === "ready" && index !== void 0 && index.notes !== void 0;
     let lastIndexActivityAt;
@@ -16024,6 +16120,14 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
       tasks_ready: isTaskCacheReady(),
       tasks_building: isTaskCacheBuilding(),
       watcher_state: getWatcherStatus2()?.state,
+      boot_state: runtimeState.bootState,
+      integrity_state: runtimeState.integrityState,
+      integrity_check_in_progress: runtimeState.integrityCheckInProgress,
+      integrity_started_at: runtimeState.integrityStartedAt,
+      integrity_source: runtimeState.integritySource,
+      integrity_last_checked_at: runtimeState.lastIntegrityCheckedAt,
+      integrity_duration_ms: runtimeState.lastIntegrityDurationMs,
+      integrity_detail: runtimeState.lastIntegrityDetail,
       watcher_pending: getWatcherStatus2()?.pendingEvents,
       last_index_activity_at: lastIndexActivityAt,
       last_index_activity_ago_seconds: lastIndexActivityAt ? Math.floor((Date.now() - lastIndexActivityAt) / 1e3) : void 0,
@@ -16075,6 +16179,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
     async ({ detail = false }) => {
       const activity = getPipelineActivityState();
       const now = Date.now();
+      const runtimeState = getVaultRuntimeState();
       const output = {
         busy: activity?.busy ?? false,
         trigger: activity?.trigger ?? null,
@@ -16083,6 +16188,9 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
         current_step: activity?.current_step ?? null,
         progress: activity && activity.busy && activity.total_steps > 0 ? `${activity.completed_steps}/${activity.total_steps} steps` : null,
         pending_events: activity?.pending_events ?? 0,
+        boot_state: runtimeState.bootState,
+        integrity_state: runtimeState.integrityState,
+        integrity_check_in_progress: runtimeState.integrityCheckInProgress,
         last_completed: activity?.last_completed_at ? {
           at: activity.last_completed_at,
           ago_seconds: Math.floor((now - activity.last_completed_at) / 1e3),
@@ -16143,8 +16251,8 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
       daily_counts: z4.record(z4.number())
     }).describe("Activity summary for the last 7 days")
   };
-  function isPeriodicNote3(path40) {
-    const filename = path40.split("/").pop() || "";
+  function isPeriodicNote3(path41) {
+    const filename = path41.split("/").pop() || "";
     const nameWithoutExt = filename.replace(/\.md$/, "");
     const patterns = [
       /^\d{4}-\d{2}-\d{2}$/,
@@ -16159,7 +16267,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
       // YYYY (yearly)
     ];
     const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
-    const folder = path40.split("/")[0]?.toLowerCase() || "";
+    const folder = path41.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   async function runVaultStats() {
@@ -17266,13 +17374,13 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         max_content_chars: z6.number().default(2e4).describe("Max total chars of section content to include. Sections are truncated at paragraph boundaries.")
       }
     },
-    async ({ path: path40, include_content, max_content_chars }) => {
+    async ({ path: path41, include_content, max_content_chars }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path40, vaultPath2);
+      const result = await getNoteStructure(index, path41, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path40 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path41 }, null, 2) }]
         };
       }
       let totalChars = 0;
@@ -17283,7 +17391,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
             truncated = true;
             break;
           }
-          const sectionResult = await getSectionContent(index, path40, section.heading.text, vaultPath2, true);
+          const sectionResult = await getSectionContent(index, path41, section.heading.text, vaultPath2, true);
           if (sectionResult) {
             let content = sectionResult.content;
             const remaining = max_content_chars - totalChars;
@@ -17298,13 +17406,13 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
           }
         }
       }
-      const note = index.notes.get(path40);
+      const note = index.notes.get(path41);
       const enriched = { ...result };
       if (note) {
         enriched.frontmatter = note.frontmatter;
         enriched.tags = note.tags;
         enriched.aliases = note.aliases;
-        const normalizedPath = path40.toLowerCase().replace(/\.md$/, "");
+        const normalizedPath = path41.toLowerCase().replace(/\.md$/, "");
         const backlinks = index.backlinks.get(normalizedPath) || [];
         enriched.backlink_count = backlinks.length;
         enriched.outlink_count = note.outlinks.length;
@@ -17342,15 +17450,15 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         max_content_chars: z6.number().default(1e4).describe("Max chars of section content. Truncated at paragraph boundaries.")
       }
     },
-    async ({ path: path40, heading, include_subheadings, max_content_chars }) => {
+    async ({ path: path41, heading, include_subheadings, max_content_chars }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path40, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path41, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path40,
+            path: path41,
             heading
           }, null, 2) }]
         };
@@ -17411,16 +17519,16 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         offset: z6.coerce.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path40, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
+    async ({ path: path41, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
       const limit = Math.min(requestedLimit ?? 25, MAX_LIMIT);
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const config2 = getConfig2();
-      if (path40) {
-        const result2 = await getTasksFromNote(index, path40, vaultPath2, getExcludeTags(config2));
+      if (path41) {
+        const result2 = await getTasksFromNote(index, path41, vaultPath2, getExcludeTags(config2));
         if (!result2) {
           return {
-            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path40 }, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path41 }, null, 2) }]
           };
         }
         let filtered = result2;
@@ -17430,7 +17538,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         const paged2 = filtered.slice(offset, offset + limit);
         return {
           content: [{ type: "text", text: JSON.stringify({
-            path: path40,
+            path: path41,
             total_count: filtered.length,
             returned_count: paged2.length,
             open: result2.filter((t) => t.status === "open").length,
@@ -17586,7 +17694,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
 // src/tools/read/migrations.ts
 import { z as z7 } from "zod";
 import * as fs15 from "fs/promises";
-import * as path18 from "path";
+import * as path19 from "path";
 import matter2 from "gray-matter";
 function getNotesInFolder(index, folder) {
   const notes = [];
@@ -17599,7 +17707,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 fs15.readFile(fullPath, "utf-8");
   } catch {
@@ -17607,7 +17715,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 fs15.writeFile(fullPath, content, "utf-8");
     return true;
@@ -17788,7 +17896,7 @@ function registerMigrationTools(server2, getIndex, getVaultPath) {
 // src/tools/read/graphAnalysis.ts
 import fs16 from "node:fs";
-import path19 from "node:path";
+import path20 from "node:path";
 import { z as z8 } from "zod";
 // src/tools/read/schema.ts
@@ -18314,7 +18422,7 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb4
           const scored = allNotes.map((note) => {
             let wordCount = 0;
             try {
-              const content = fs16.readFileSync(path19.join(vaultPath2, note.path), "utf-8");
+              const content = fs16.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 {
@@ -18945,12 +19053,12 @@ import { z as z11 } from "zod";
 // src/tools/read/bidirectional.ts
 import * as fs17 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 fs17.readFile(fullPath, "utf-8");
   } catch {
@@ -19129,10 +19237,10 @@ async function suggestWikilinksInFrontmatter(index, notePath, vaultPath2) {
 // src/tools/read/computed.ts
 import * as fs18 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 fs18.readFile(fullPath, "utf-8");
   } catch {
@@ -19140,7 +19248,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 fs18.stat(fullPath);
     return {
@@ -19413,7 +19521,7 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath, getConfi
 init_writer();
 import { z as z12 } from "zod";
 import fs24 from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 // src/core/write/validator.ts
 var TIMESTAMP_PATTERN = /^\*\*\d{2}:\d{2}\*\*/;
@@ -19632,16 +19740,16 @@ init_writer();
 init_wikilinks();
 init_wikilinkFeedback();
 import fs23 from "fs/promises";
-import path25 from "path";
+import path26 from "path";
 // src/core/write/policy/policyPaths.ts
 import fs22 from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 function getPoliciesDir(vaultPath2) {
-  return path24.join(vaultPath2, ".flywheel", "policies");
+  return path25.join(vaultPath2, ".flywheel", "policies");
 }
 function getLegacyPoliciesDir(vaultPath2) {
-  return path24.join(vaultPath2, ".claude", "policies");
+  return path25.join(vaultPath2, ".claude", "policies");
 }
 async function ensurePoliciesDir(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
@@ -19658,14 +19766,14 @@ async function migratePoliciesIfNeeded(vaultPath2) {
   const yamlFiles = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
   if (yamlFiles.length === 0) {
     await tryRmdir(legacyDir);
-    await tryRmdir(path24.join(vaultPath2, ".claude"));
+    await tryRmdir(path25.join(vaultPath2, ".claude"));
     return;
   }
   await ensurePoliciesDir(vaultPath2);
   const destDir = getPoliciesDir(vaultPath2);
   for (const file of yamlFiles) {
-    const src = path24.join(legacyDir, file);
-    const dest = path24.join(destDir, file);
+    const src = path25.join(legacyDir, file);
+    const dest = path25.join(destDir, file);
     try {
       await fs22.access(dest);
     } catch {
@@ -19674,7 +19782,7 @@ async function migratePoliciesIfNeeded(vaultPath2) {
     await fs22.unlink(src);
   }
   await tryRmdir(legacyDir);
-  await tryRmdir(path24.join(vaultPath2, ".claude"));
+  await tryRmdir(path25.join(vaultPath2, ".claude"));
 }
 async function tryRmdir(dir) {
   try {
@@ -19687,7 +19795,7 @@ async function tryRmdir(dir) {
 }
 var migrationCache = /* @__PURE__ */ new Map();
 async function ensureMigrated(vaultPath2) {
-  const key = path24.resolve(vaultPath2);
+  const key = path25.resolve(vaultPath2);
   if (!migrationCache.has(key)) {
     migrationCache.set(key, migratePoliciesIfNeeded(vaultPath2));
   }
@@ -19754,7 +19862,7 @@ async function getPolicyHint(vaultPath2) {
   return "";
 }
 async function ensureFileExists(vaultPath2, notePath) {
-  const fullPath = path25.join(vaultPath2, notePath);
+  const fullPath = path26.join(vaultPath2, notePath);
   try {
     await fs23.access(fullPath);
     return null;
@@ -19959,7 +20067,7 @@ async function executeCreateNote(options) {
     if (!pathCheck.valid) {
       return { success: false, result: errorResult(notePath, `Path blocked: ${pathCheck.reason}`), filesWritten: [] };
     }
-    const fullPath = path25.join(vaultPath2, notePath);
+    const fullPath = path26.join(vaultPath2, notePath);
     let fileExists = false;
     try {
       await fs23.access(fullPath);
@@ -19969,7 +20077,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 fs23.mkdir(path25.dirname(fullPath), { recursive: true });
+    await fs23.mkdir(path26.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;
@@ -20003,7 +20111,7 @@ async function executeDeleteNote(options) {
     if (!pathCheck.valid) {
       return { success: false, result: errorResult(notePath, `Path blocked: ${pathCheck.reason}`), filesWritten: [] };
     }
-    const fullPath = path25.join(vaultPath2, notePath);
+    const fullPath = path26.join(vaultPath2, notePath);
     try {
       await fs23.access(fullPath);
     } catch {
@@ -20027,10 +20135,10 @@ async function createNoteFromTemplate(vaultPath2, notePath, config2) {
   if (!validation.valid) {
     throw new Error(`Path blocked: ${validation.reason}`);
   }
-  const fullPath = path26.join(vaultPath2, notePath);
-  await fs24.mkdir(path26.dirname(fullPath), { recursive: true });
+  const fullPath = path27.join(vaultPath2, notePath);
+  await fs24.mkdir(path27.dirname(fullPath), { recursive: true });
   const templates = config2.templates || {};
-  const filename = path26.basename(notePath, ".md").toLowerCase();
+  const filename = path27.basename(notePath, ".md").toLowerCase();
   let templatePath;
   let periodicType;
   const dailyPattern = /^\d{4}-\d{2}-\d{2}/;
@@ -20063,7 +20171,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config2) {
     ];
     for (const candidate of candidates) {
       try {
-        await fs24.access(path26.join(vaultPath2, candidate));
+        await fs24.access(path27.join(vaultPath2, candidate));
         templatePath = candidate;
         console.error(`[Flywheel] Template not in config but found at ${candidate} \u2014 using it`);
         break;
@@ -20074,11 +20182,11 @@ async function createNoteFromTemplate(vaultPath2, notePath, config2) {
   let templateContent;
   if (templatePath) {
     try {
-      const absTemplatePath = path26.join(vaultPath2, templatePath);
+      const absTemplatePath = path27.join(vaultPath2, templatePath);
       templateContent = await fs24.readFile(absTemplatePath, "utf-8");
     } catch {
       console.error(`[Flywheel] Template at ${templatePath} not readable, using minimal fallback`);
-      const title = path26.basename(notePath, ".md");
+      const title = path27.basename(notePath, ".md");
       templateContent = `---
 ---
@@ -20090,7 +20198,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config2) {
     if (periodicType) {
       console.error(`[Flywheel] No ${periodicType} template found in config or vault \u2014 using minimal fallback`);
     }
-    const title = path26.basename(notePath, ".md");
+    const title = path27.basename(notePath, ".md");
     templateContent = `---
 ---
@@ -20099,7 +20207,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config2) {
   }
   const now = /* @__PURE__ */ new Date();
   const dateStr = now.toISOString().split("T")[0];
-  templateContent = templateContent.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, path26.basename(notePath, ".md"));
+  templateContent = templateContent.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, path27.basename(notePath, ".md"));
   const matter9 = (await import("gray-matter")).default;
   const parsed = matter9(templateContent);
   if (!parsed.data.date) {
@@ -20138,7 +20246,7 @@ function registerMutationTools(server2, getVaultPath, getConfig2 = () => ({})) {
       let noteCreated = false;
       let templateUsed;
       if (create_if_missing && !dry_run) {
-        const fullPath = path26.join(vaultPath2, notePath);
+        const fullPath = path27.join(vaultPath2, notePath);
         try {
           await fs24.access(fullPath);
         } catch {
@@ -20149,7 +20257,7 @@ function registerMutationTools(server2, getVaultPath, getConfig2 = () => ({})) {
         }
       }
       if (create_if_missing && dry_run) {
-        const fullPath = path26.join(vaultPath2, notePath);
+        const fullPath = path27.join(vaultPath2, notePath);
         try {
           await fs24.access(fullPath);
         } catch {
@@ -20636,7 +20744,7 @@ init_writer();
 init_wikilinks();
 import { z as z15 } from "zod";
 import fs25 from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 function registerNoteTools(server2, getVaultPath, getIndex) {
   server2.tool(
     "vault_create_note",
@@ -20662,23 +20770,23 @@ function registerNoteTools(server2, getVaultPath, getIndex) {
         if (!validatePath(vaultPath2, notePath)) {
           return formatMcpResult(errorResult(notePath, "Invalid path: path traversal not allowed"));
         }
-        const fullPath = path27.join(vaultPath2, notePath);
+        const fullPath = path28.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 = path27.dirname(fullPath);
+        const dir = path28.dirname(fullPath);
         await fs25.mkdir(dir, { recursive: true });
         let effectiveContent = content;
         let effectiveFrontmatter = frontmatter;
         if (template) {
-          const templatePath = path27.join(vaultPath2, template);
+          const templatePath = path28.join(vaultPath2, template);
           try {
             const raw = await fs25.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 = path27.basename(notePath, ".md");
+            const title = path28.basename(notePath, ".md");
             let templateContent = parsed.content.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, title);
             if (content) {
               templateContent = templateContent.trimEnd() + "\n\n" + content;
@@ -20697,7 +20805,7 @@ function registerNoteTools(server2, getVaultPath, getIndex) {
           effectiveFrontmatter.created = now.toISOString();
         }
         const warnings = [];
-        const noteName = path27.basename(notePath, ".md");
+        const noteName = path28.basename(notePath, ".md");
         const existingAliases = Array.isArray(effectiveFrontmatter?.aliases) ? effectiveFrontmatter.aliases.filter((a) => typeof a === "string") : [];
         const preflight = await checkPreflightSimilarity(noteName);
         if (preflight.existingEntity) {
@@ -20838,7 +20946,7 @@ ${sources}`;
           }
           return formatMcpResult(errorResult(notePath, previewLines.join("\n")));
         }
-        const fullPath = path27.join(vaultPath2, notePath);
+        const fullPath = path28.join(vaultPath2, notePath);
         await fs25.unlink(fullPath);
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Flywheel:Delete]");
         const message = backlinkWarning ? `Deleted note: ${notePath}
@@ -20860,7 +20968,7 @@ init_git();
 init_wikilinks();
 import { z as z16 } from "zod";
 import fs26 from "fs/promises";
-import path28 from "path";
+import path29 from "path";
 import matter6 from "gray-matter";
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -20879,7 +20987,7 @@ function extractWikilinks2(content) {
   return wikilinks;
 }
 function getTitleFromPath(filePath) {
-  return path28.basename(filePath, ".md");
+  return path29.basename(filePath, ".md");
 }
 async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   const results = [];
@@ -20888,7 +20996,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
     const files = [];
     const entries = await fs26.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path28.join(dir, entry.name);
+      const fullPath = path29.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         files.push(...await scanDir(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -20899,7 +21007,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   }
   const allFiles = await scanDir(vaultPath2);
   for (const filePath of allFiles) {
-    const relativePath = path28.relative(vaultPath2, filePath);
+    const relativePath = path29.relative(vaultPath2, filePath);
     const content = await fs26.readFile(filePath, "utf-8");
     const wikilinks = extractWikilinks2(content);
     const matchingLinks = [];
@@ -20986,8 +21094,8 @@ function registerMoveNoteTools(server2, getVaultPath) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const oldFullPath = path28.join(vaultPath2, oldPath);
-        const newFullPath = path28.join(vaultPath2, newPath);
+        const oldFullPath = path29.join(vaultPath2, oldPath);
+        const newFullPath = path29.join(vaultPath2, newPath);
         try {
           await fs26.access(oldFullPath);
         } catch {
@@ -21068,7 +21176,7 @@ function registerMoveNoteTools(server2, getVaultPath) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const destDir = path28.dirname(newFullPath);
+        const destDir = path29.dirname(newFullPath);
         await fs26.mkdir(destDir, { recursive: true });
         await fs26.rename(oldFullPath, newFullPath);
         let gitCommit;
@@ -21144,10 +21252,10 @@ function registerMoveNoteTools(server2, getVaultPath) {
         if (sanitizedTitle !== newTitle) {
           console.error(`[Flywheel] Title sanitized: "${newTitle}" \u2192 "${sanitizedTitle}"`);
         }
-        const fullPath = path28.join(vaultPath2, notePath);
-        const dir = path28.dirname(notePath);
-        const newPath = dir === "." ? `${sanitizedTitle}.md` : path28.join(dir, `${sanitizedTitle}.md`);
-        const newFullPath = path28.join(vaultPath2, newPath);
+        const fullPath = path29.join(vaultPath2, notePath);
+        const dir = path29.dirname(notePath);
+        const newPath = dir === "." ? `${sanitizedTitle}.md` : path29.join(dir, `${sanitizedTitle}.md`);
+        const newFullPath = path29.join(vaultPath2, newPath);
         try {
           await fs26.access(fullPath);
         } catch {
@@ -21279,7 +21387,7 @@ init_writer();
 init_wikilinks();
 import { z as z17 } from "zod";
 import fs27 from "fs/promises";
-import path29 from "path";
+import path30 from "path";
 function registerMergeTools(server2, getVaultPath) {
   server2.tool(
     "merge_entities",
@@ -21576,14 +21684,14 @@ async function findSourceNote(vaultPath2, sourceName, excludePath) {
     }
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const fullPath = path29.join(dir, entry.name);
+      const fullPath = path30.join(dir, entry.name);
       if (entry.isDirectory()) {
         const found = await scanDir(fullPath);
         if (found) return found;
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const basename5 = path29.basename(entry.name, ".md");
+        const basename5 = path30.basename(entry.name, ".md");
         if (basename5.toLowerCase() === targetLower) {
-          const relative2 = path29.relative(vaultPath2, fullPath).replace(/\\/g, "/");
+          const relative2 = path30.relative(vaultPath2, fullPath).replace(/\\/g, "/");
           if (relative2 !== excludePath) return relative2;
         }
       }
@@ -21704,7 +21812,7 @@ Message: ${undoResult.undoneCommit.message}` : void 0
 }
 // src/tools/write/policy.ts
-import * as path34 from "path";
+import * as path35 from "path";
 import { z as z20 } from "zod";
 // src/core/write/policy/index.ts
@@ -21714,7 +21822,7 @@ init_schema();
 // src/core/write/policy/parser.ts
 init_schema();
 import fs28 from "fs/promises";
-import path30 from "path";
+import path31 from "path";
 import matter7 from "gray-matter";
 function parseYaml(content) {
   const parsed = matter7(`---
@@ -21765,12 +21873,12 @@ async function loadPolicyFile(filePath) {
 async function loadPolicy(vaultPath2, policyName) {
   await ensureMigrated(vaultPath2);
   const policiesDir = getPoliciesDir(vaultPath2);
-  const policyPath = path30.join(policiesDir, `${policyName}.yaml`);
+  const policyPath = path31.join(policiesDir, `${policyName}.yaml`);
   try {
     await fs28.access(policyPath);
     return loadPolicyFile(policyPath);
   } catch {
-    const ymlPath = path30.join(policiesDir, `${policyName}.yml`);
+    const ymlPath = path31.join(policiesDir, `${policyName}.yml`);
     try {
       await fs28.access(ymlPath);
       return loadPolicyFile(ymlPath);
@@ -21913,7 +22021,7 @@ init_writer();
 init_git();
 init_wikilinks();
 import fs30 from "fs/promises";
-import path32 from "path";
+import path33 from "path";
 init_constants2();
 async function executeStep(step, vaultPath2, context, conditionResults, searchFn) {
   const { execute, reason } = shouldStepExecute(step.when, conditionResults);
@@ -22104,12 +22212,12 @@ async function executeCreateNote2(params, vaultPath2, context) {
   let frontmatter = params.frontmatter || {};
   if (params.template) {
     try {
-      const templatePath = path32.join(vaultPath2, String(params.template));
+      const templatePath = path33.join(vaultPath2, String(params.template));
       const raw = await fs30.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 = path32.basename(notePath, ".md");
+      const title = path33.basename(notePath, ".md");
       let templateContent = parsed.content.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, title);
       if (content) {
         templateContent = templateContent.trimEnd() + "\n\n" + content;
@@ -22142,7 +22250,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 = path32.join(vaultPath2, notePath);
+  const fullPath = path33.join(vaultPath2, notePath);
   try {
     await fs30.access(fullPath);
   } catch {
@@ -22425,7 +22533,7 @@ async function rollbackChanges(vaultPath2, originalContents, filesModified) {
     const pathCheck = await validatePathSecure(vaultPath2, filePath);
     if (!pathCheck.valid) continue;
     const original = originalContents.get(filePath);
-    const fullPath = path32.join(vaultPath2, filePath);
+    const fullPath = path33.join(vaultPath2, filePath);
     if (original === null) {
       try {
         await fs30.unlink(fullPath);
@@ -22480,7 +22588,7 @@ async function previewPolicy(policy, vaultPath2, variables) {
 // src/core/write/policy/storage.ts
 import fs31 from "fs/promises";
-import path33 from "path";
+import path34 from "path";
 async function listPolicies(vaultPath2) {
   await ensureMigrated(vaultPath2);
   const dir = getPoliciesDir(vaultPath2);
@@ -22491,7 +22599,7 @@ async function listPolicies(vaultPath2) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
         continue;
       }
-      const filePath = path33.join(dir, file);
+      const filePath = path34.join(dir, file);
       const stat4 = await fs31.stat(filePath);
       const content = await fs31.readFile(filePath, "utf-8");
       const metadata = extractPolicyMetadata(content);
@@ -22517,7 +22625,7 @@ async function writePolicyRaw(vaultPath2, policyName, content, overwrite = false
   const dir = getPoliciesDir(vaultPath2);
   await ensurePoliciesDir(vaultPath2);
   const filename = `${policyName}.yaml`;
-  const filePath = path33.join(dir, filename);
+  const filePath = path34.join(dir, filename);
   if (!overwrite) {
     try {
       await fs31.access(filePath);
@@ -22631,7 +22739,7 @@ function registerPolicyTools(server2, getVaultPath, getSearchFn) {
             const policies = await listPolicies(vaultPath2);
             const response = {
               success: true,
-              vault: path34.basename(vaultPath2),
+              vault: path35.basename(vaultPath2),
               vault_path: vaultPath2,
               count: policies.length,
               policies: policies.map((p) => ({
@@ -23065,7 +23173,7 @@ import { z as z21 } from "zod";
 // src/core/write/tagRename.ts
 import * as fs32 from "fs/promises";
-import * as path35 from "path";
+import * as path36 from "path";
 import matter8 from "gray-matter";
 import { getProtectedZones as getProtectedZones2 } from "@velvetmonkey/vault-core";
 function getNotesInFolder3(index, folder) {
@@ -23171,7 +23279,7 @@ async function renameTag(index, vaultPath2, oldTag, newTag, options) {
   const previews = [];
   let totalChanges = 0;
   for (const note of affectedNotes) {
-    const fullPath = path35.join(vaultPath2, note.path);
+    const fullPath = path36.join(vaultPath2, note.path);
     let fileContent;
     try {
       fileContent = await fs32.readFile(fullPath, "utf-8");
@@ -24301,7 +24409,7 @@ init_wikilinks();
 init_wikilinkFeedback();
 import { z as z28 } from "zod";
 import * as fs33 from "fs/promises";
-import * as path36 from "path";
+import * as path37 from "path";
 import { scanVaultEntities as scanVaultEntities4, SCHEMA_VERSION as SCHEMA_VERSION2 } from "@velvetmonkey/vault-core";
 init_embeddings();
 function hasSkipWikilinks(content) {
@@ -24317,13 +24425,13 @@ async function collectMarkdownFiles(dirPath, basePath, excludeFolders) {
     const entries = await fs33.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const fullPath = path36.join(dirPath, entry.name);
+      const fullPath = path37.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(path36.relative(basePath, fullPath));
+        results.push(path37.relative(basePath, fullPath));
       }
     }
   } catch {
@@ -24353,7 +24461,7 @@ var EXCLUDE_FOLDERS = [
 ];
 function buildStatusReport(stateDb2, vaultPath2) {
   const recommendations = [];
-  const dbPath = path36.join(vaultPath2, ".flywheel", "state.db");
+  const dbPath = path37.join(vaultPath2, ".flywheel", "state.db");
   const statedbExists = stateDb2 !== null;
   if (!statedbExists) {
     recommendations.push("StateDb not initialized \u2014 server needs restart");
@@ -24480,7 +24588,7 @@ async function executeRun(stateDb2, vaultPath2) {
       const allFiles = await collectMarkdownFiles(vaultPath2, vaultPath2, EXCLUDE_FOLDERS);
       let eligible = 0;
       for (const relativePath of allFiles) {
-        const fullPath = path36.join(vaultPath2, relativePath);
+        const fullPath = path37.join(vaultPath2, relativePath);
         let content;
         try {
           content = await fs33.readFile(fullPath, "utf-8");
@@ -24538,7 +24646,7 @@ async function executeEnrich(stateDb2, vaultPath2, dryRun, batchSize, offset) {
   const eligible = [];
   let notesSkipped = 0;
   for (const relativePath of allFiles) {
-    const fullPath = path36.join(vaultPath2, relativePath);
+    const fullPath = path37.join(vaultPath2, relativePath);
     let content;
     try {
       content = await fs33.readFile(fullPath, "utf-8");
@@ -24568,7 +24676,7 @@ async function executeEnrich(stateDb2, vaultPath2, dryRun, batchSize, offset) {
       match_count: result.linksAdded
     });
     if (!dryRun) {
-      const fullPath = path36.join(vaultPath2, relativePath);
+      const fullPath = path37.join(vaultPath2, relativePath);
       await fs33.writeFile(fullPath, result.content, "utf-8");
       notesModified++;
       if (stateDb2) {
@@ -24747,7 +24855,7 @@ import { z as z30 } from "zod";
 // src/core/read/similarity.ts
 import * as fs34 from "fs";
-import * as path37 from "path";
+import * as path38 from "path";
 init_embeddings();
 // src/core/read/mmr.ts
@@ -24817,7 +24925,7 @@ function extractKeyTerms(content, maxTerms = 15) {
 }
 function findSimilarNotes(db4, vaultPath2, index, sourcePath, options = {}) {
   const limit = options.limit ?? 10;
-  const absPath = path37.join(vaultPath2, sourcePath);
+  const absPath = path38.join(vaultPath2, sourcePath);
   let content;
   try {
     content = fs34.readFileSync(absPath, "utf-8");
@@ -24959,7 +25067,7 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb4) {
         diversity: z30.number().min(0).max(1).optional().describe("Relevance vs diversity tradeoff (0=max diversity, 1=pure relevance, default: 0.7)")
       }
     },
-    async ({ path: path40, limit, diversity }) => {
+    async ({ path: path41, limit, diversity }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const stateDb2 = getStateDb4();
@@ -24968,10 +25076,10 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb4) {
           content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
         };
       }
-      if (!index.notes.has(path40)) {
+      if (!index.notes.has(path41)) {
         return {
           content: [{ type: "text", text: JSON.stringify({
-            error: `Note not found: ${path40}`,
+            error: `Note not found: ${path41}`,
             hint: "Use the full relative path including .md extension"
           }, null, 2) }]
         };
@@ -24983,12 +25091,12 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb4) {
       };
       const useHybrid = hasEmbeddingsIndex();
       const method = useHybrid ? "hybrid" : "bm25";
-      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path40, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path40, opts);
+      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path41, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path41, opts);
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
-            source: path40,
+            source: path41,
             method,
             count: results.length,
             similar: results
@@ -26862,9 +26970,9 @@ function registerVaultResources(server2, getIndex) {
 }
 // src/tool-registry.ts
-var __trFilename = fileURLToPath2(import.meta.url);
-var __trDirname = dirname5(__trFilename);
-var trPkg = JSON.parse(readFileSync5(join18(__trDirname, "../package.json"), "utf-8"));
+var __trFilename = fileURLToPath3(import.meta.url);
+var __trDirname = dirname6(__trFilename);
+var trPkg = JSON.parse(readFileSync5(join19(__trDirname, "../package.json"), "utf-8"));
 var ACTIVATION_PATTERNS = [
   {
     category: "graph",
@@ -26902,6 +27010,34 @@ var ACTIVATION_PATTERNS = [
     patterns: [/\b(delete note|move note|rename note|merge entities|merge notes?)\b/i]
   }
 ];
+var MUTATING_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "vault_add_to_section",
+  "vault_remove_from_section",
+  "vault_replace_in_section",
+  "vault_add_task",
+  "vault_toggle_task",
+  "vault_update_frontmatter",
+  "vault_create_note",
+  "vault_delete_note",
+  "vault_move_note",
+  "vault_rename_note",
+  "merge_entities",
+  "absorb_as_alias",
+  "vault_undo_last_mutation",
+  "policy",
+  "rename_tag",
+  "wikilink_feedback",
+  "tool_selection_feedback",
+  "vault_record_correction",
+  "vault_resolve_correction",
+  "memory",
+  "flywheel_config",
+  "vault_init",
+  "rename_field",
+  "migrate_field_values",
+  "refresh_index",
+  "init_semantic"
+]);
 function getPatternSignals(raw) {
   if (!raw) return [];
   return ACTIVATION_PATTERNS.filter(({ patterns }) => patterns.some((pattern) => pattern.test(raw))).map(({ category, tier }) => ({ category, tier }));
@@ -27094,7 +27230,7 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
               let totalBytes = 0;
               for (const p of notePaths) {
                 try {
-                  totalBytes += statSync6(path38.join(vp, p)).size;
+                  totalBytes += statSync6(path39.join(vp, p)).size;
                 } catch {
                 }
               }
@@ -27127,6 +27263,26 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
     };
   }
   const isMultiVault = registry?.isMultiVault ?? false;
+  function getTargetVaultContext(params) {
+    if (!registry) return null;
+    if (isMultiVault) {
+      const vaultName = typeof params?.vault === "string" ? params.vault : void 0;
+      return registry.getContext(vaultName);
+    }
+    return registry.getContext();
+  }
+  function wrapWithIntegrityGate(toolName, handler) {
+    if (!MUTATING_TOOL_NAMES.has(toolName)) return handler;
+    return async (...args) => {
+      const params = args[0] && typeof args[0] === "object" ? args[0] : void 0;
+      const vaultCtx = getTargetVaultContext(params);
+      const integrityState = vaultCtx?.integrityState ?? getActiveScopeOrNull()?.integrityState;
+      if (integrityState === "failed") {
+        throw new Error("StateDb integrity failed; write operations are disabled until recovery/restart.");
+      }
+      return handler(...args);
+    };
+  }
   function wrapWithVaultActivation(toolName, handler) {
     if (!isMultiVault || !registry || !vaultCallbacks) return handler;
     return async (...args) => {
@@ -27242,6 +27398,7 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
     if (args.length > 0 && typeof args[args.length - 1] === "function") {
       let handler = args[args.length - 1];
       handler = wrapWithVaultActivation(name, handler);
+      handler = wrapWithIntegrityGate(name, handler);
       args[args.length - 1] = wrapWithTracking(name, handler);
     }
     const registered = origTool(name, ...args);
@@ -27256,6 +27413,7 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
       if (args.length > 0 && typeof args[args.length - 1] === "function") {
         let handler = args[args.length - 1];
         handler = wrapWithVaultActivation(name, handler);
+        handler = wrapWithIntegrityGate(name, handler);
         args[args.length - 1] = wrapWithTracking(name, handler);
       }
       const registered = origRegisterTool(name, ...args);
@@ -27349,7 +27507,7 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
 }
 function registerAllTools(targetServer, ctx, controller) {
   const { getVaultPath: gvp, getVaultIndex: gvi, getStateDb: gsd, getFlywheelConfig: gcf } = ctx;
-  registerHealthTools(targetServer, gvi, gvp, gcf, gsd, ctx.getWatcherStatus, () => trPkg.version, ctx.getPipelineActivity);
+  registerHealthTools(targetServer, gvi, gvp, gcf, gsd, ctx.getWatcherStatus, () => trPkg.version, ctx.getPipelineActivity, ctx.getVaultRuntimeState);
   registerSystemTools(
     targetServer,
     gvi,
@@ -27445,9 +27603,9 @@ function registerAllTools(targetServer, ctx, controller) {
 }
 // src/index.ts
-var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname = dirname7(__filename2);
-var pkg = JSON.parse(readFileSync6(join20(__dirname, "../package.json"), "utf-8"));
+var __filename2 = fileURLToPath4(import.meta.url);
+var __dirname = dirname8(__filename2);
+var pkg = JSON.parse(readFileSync6(join21(__dirname, "../package.json"), "utf-8"));
 var vaultPath;
 var resolvedVaultPath;
 var vaultIndex;
@@ -27463,6 +27621,7 @@ var lastMcpRequestAt = 0;
 var lastFullRebuildAt = 0;
 var startupScanFiles = null;
 var deferredScheduler = null;
+var integrityRuns = /* @__PURE__ */ new Map();
 function getWatcherStatus() {
   if (vaultRegistry) {
     const name = globalThis.__flywheel_active_vault;
@@ -27507,6 +27666,20 @@ function buildRegistryContext() {
     getFlywheelConfig: () => getActiveScopeOrNull()?.flywheelConfig ?? flywheelConfig,
     getWatcherStatus,
     getPipelineActivity: () => getActiveScopeOrNull()?.pipelineActivity ?? null,
+    getVaultRuntimeState: () => {
+      const scope = getActiveScopeOrNull();
+      return {
+        bootState: scope?.bootState ?? "booting",
+        integrityState: scope?.integrityState ?? "unknown",
+        integrityCheckInProgress: scope?.integrityCheckInProgress ?? false,
+        integrityStartedAt: scope?.integrityStartedAt ?? null,
+        integritySource: scope?.integritySource ?? null,
+        lastIntegrityCheckedAt: scope?.lastIntegrityCheckedAt ?? null,
+        lastIntegrityDurationMs: scope?.lastIntegrityDurationMs ?? null,
+        lastIntegrityDetail: scope?.lastIntegrityDetail ?? null,
+        lastBackupAt: scope?.lastBackupAt ?? null
+      };
+    },
     updateVaultIndex,
     updateFlywheelConfig
   };
@@ -27608,6 +27781,110 @@ function loadVaultCooccurrence(ctx) {
     serverLog("index", `[${ctx.name}] Co-occurrence: loaded from cache (${Object.keys(cachedCooc.index.associations).length} entities, ${cachedCooc.index._metadata.total_associations} associations)`);
   }
 }
+function hydrateIntegrityMetadata(ctx) {
+  if (!ctx.stateDb) return;
+  const checkedAtRow = ctx.stateDb.getMetadataValue.get(INTEGRITY_METADATA_KEYS.checkedAt);
+  const statusRow = ctx.stateDb.getMetadataValue.get(INTEGRITY_METADATA_KEYS.status);
+  const durationRow = ctx.stateDb.getMetadataValue.get(INTEGRITY_METADATA_KEYS.durationMs);
+  const detailRow = ctx.stateDb.getMetadataValue.get(INTEGRITY_METADATA_KEYS.detail);
+  ctx.lastIntegrityCheckedAt = checkedAtRow ? parseInt(checkedAtRow.value, 10) || null : null;
+  ctx.lastIntegrityDurationMs = durationRow ? parseInt(durationRow.value, 10) || null : null;
+  ctx.lastIntegrityDetail = detailRow?.value ? detailRow.value : null;
+  const status = statusRow?.value;
+  if (status === "healthy" || status === "failed" || status === "error") {
+    ctx.integrityState = status;
+  }
+}
+function setBootState(ctx, state2) {
+  ctx.bootState = state2;
+  if (globalThis.__flywheel_active_vault === ctx.name) {
+    setActiveScope(buildVaultScope(ctx));
+  }
+}
+function setIntegrityState(ctx, state2, detail = ctx.lastIntegrityDetail, durationMs = ctx.lastIntegrityDurationMs) {
+  ctx.integrityState = state2;
+  ctx.lastIntegrityDetail = detail;
+  ctx.lastIntegrityDurationMs = durationMs;
+  if (state2 === "failed") {
+    ctx.bootState = "degraded";
+  }
+  if (globalThis.__flywheel_active_vault === ctx.name) {
+    setActiveScope(buildVaultScope(ctx));
+  }
+}
+function persistIntegrityMetadata(ctx) {
+  if (!ctx.stateDb || ctx.lastIntegrityCheckedAt == null) return;
+  ctx.stateDb.setMetadataValue.run(INTEGRITY_METADATA_KEYS.checkedAt, String(ctx.lastIntegrityCheckedAt));
+  ctx.stateDb.setMetadataValue.run(INTEGRITY_METADATA_KEYS.status, ctx.integrityState);
+  if (ctx.lastIntegrityDurationMs != null) {
+    ctx.stateDb.setMetadataValue.run(INTEGRITY_METADATA_KEYS.durationMs, String(ctx.lastIntegrityDurationMs));
+  }
+  if (ctx.lastIntegrityDetail) {
+    ctx.stateDb.setMetadataValue.run(INTEGRITY_METADATA_KEYS.detail, ctx.lastIntegrityDetail);
+  } else {
+    ctx.stateDb.setMetadataValue.run(INTEGRITY_METADATA_KEYS.detail, "");
+  }
+}
+function shouldRunBackup(ctx) {
+  if (ctx.lastBackupAt == null) return true;
+  return Date.now() - ctx.lastBackupAt >= INTEGRITY_BACKUP_INTERVAL_MS;
+}
+async function runIntegrityCheck(ctx, source, options = {}) {
+  if (!ctx.stateDb) {
+    return { status: "error", detail: "StateDb not available", durationMs: 0, backupCreated: false };
+  }
+  if (!options.force && ctx.integrityState === "healthy" && ctx.lastIntegrityCheckedAt != null) {
+    if (Date.now() - ctx.lastIntegrityCheckedAt < INTEGRITY_CHECK_INTERVAL_MS) {
+      return {
+        status: "healthy",
+        detail: ctx.lastIntegrityDetail,
+        durationMs: ctx.lastIntegrityDurationMs ?? 0,
+        backupCreated: false
+      };
+    }
+  }
+  const existing = integrityRuns.get(ctx.name);
+  if (existing) return existing;
+  ctx.integrityCheckInProgress = true;
+  ctx.integrityStartedAt = Date.now();
+  ctx.integritySource = source;
+  setIntegrityState(ctx, "checking", ctx.lastIntegrityDetail, ctx.lastIntegrityDurationMs);
+  serverLog("statedb", `[${ctx.name}] Integrity check started (${source})`);
+  const promise = runIntegrityWorker({
+    dbPath: ctx.stateDb.dbPath,
+    runBackup: shouldRunBackup(ctx),
+    busyTimeoutMs: 5e3
+  }).then((result) => {
+    ctx.integrityCheckInProgress = false;
+    ctx.integrityStartedAt = null;
+    ctx.integritySource = source;
+    ctx.lastIntegrityCheckedAt = Date.now();
+    ctx.lastIntegrityDurationMs = result.durationMs;
+    ctx.lastIntegrityDetail = result.detail;
+    if (result.backupCreated) {
+      ctx.lastBackupAt = Date.now();
+    }
+    if (result.status === "healthy") {
+      setIntegrityState(ctx, "healthy", result.detail, result.durationMs);
+      serverLog("statedb", `[${ctx.name}] Integrity check passed in ${result.durationMs}ms`);
+    } else if (result.status === "failed") {
+      setIntegrityState(ctx, "failed", result.detail, result.durationMs);
+      serverLog("statedb", `[${ctx.name}] Integrity check failed: ${result.detail}`, "error");
+    } else {
+      setIntegrityState(ctx, "error", result.detail, result.durationMs);
+      serverLog("statedb", `[${ctx.name}] Integrity check error: ${result.detail}`, "warn");
+    }
+    persistIntegrityMetadata(ctx);
+    return result;
+  }).finally(() => {
+    integrityRuns.delete(ctx.name);
+    if (globalThis.__flywheel_active_vault === ctx.name) {
+      setActiveScope(buildVaultScope(ctx));
+    }
+  });
+  integrityRuns.set(ctx.name, promise);
+  return promise;
+}
 async function initializeVault(name, vaultPathArg) {
   const ctx = {
     name,
@@ -27625,11 +27902,21 @@ async function initializeVault(name, vaultPathArg) {
     lastEntityScanAt: 0,
     lastHubScoreRebuildAt: 0,
     lastIndexCacheSaveAt: 0,
-    pipelineActivity: createEmptyPipelineActivity()
+    pipelineActivity: createEmptyPipelineActivity(),
+    bootState: "booting",
+    integrityState: "unknown",
+    integrityCheckInProgress: false,
+    integrityStartedAt: null,
+    integritySource: null,
+    lastIntegrityCheckedAt: null,
+    lastIntegrityDurationMs: null,
+    lastIntegrityDetail: null,
+    lastBackupAt: null
   };
   try {
     ctx.stateDb = openStateDb(vaultPathArg);
     serverLog("statedb", `[${name}] StateDb initialized`);
+    hydrateIntegrityMetadata(ctx);
     const vaultInitRow = ctx.stateDb.getMetadataValue.get("vault_init_last_run_at");
     if (!vaultInitRow) {
       serverLog("server", `[${name}] Vault not initialized \u2014 call vault_init to enrich legacy notes`);
@@ -27653,7 +27940,16 @@ function buildVaultScope(ctx) {
     indexError: ctx.indexError,
     embeddingsBuilding: ctx.embeddingsBuilding,
     entityEmbeddingsMap: getEntityEmbeddingsMap(),
-    pipelineActivity: ctx.pipelineActivity
+    pipelineActivity: ctx.pipelineActivity,
+    bootState: ctx.bootState,
+    integrityState: ctx.integrityState,
+    integrityCheckInProgress: ctx.integrityCheckInProgress,
+    integrityStartedAt: ctx.integrityStartedAt,
+    integritySource: ctx.integritySource,
+    lastIntegrityCheckedAt: ctx.lastIntegrityCheckedAt,
+    lastIntegrityDurationMs: ctx.lastIntegrityDurationMs,
+    lastIntegrityDetail: ctx.lastIntegrityDetail,
+    lastBackupAt: ctx.lastBackupAt
   };
 }
 function activateVault(ctx, skipEmbeddingLoad = false) {
@@ -27807,6 +28103,9 @@ async function bootVault(ctx, startTime) {
       serverLog("index", `[${ctx.name}] Failed to build vault index: ${err instanceof Error ? err.message : err}`, "error");
     }
   }
+  if (ctx.bootState !== "degraded") {
+    setBootState(ctx, "ready");
+  }
 }
 async function main() {
   const vaultConfigs = parseVaultConfig();
@@ -27816,7 +28115,7 @@ async function main() {
   } catch {
     resolvedVaultPath = vaultPath.replace(/\\/g, "/");
   }
-  if (!existsSync3(resolvedVaultPath)) {
+  if (!existsSync4(resolvedVaultPath)) {
     console.error(`[flywheel] Fatal: vault path does not exist: ${resolvedVaultPath}`);
     console.error(`[flywheel] Set PROJECT_PATH or VAULT_PATH to a valid Obsidian vault directory.`);
     process.exit(1);
@@ -27831,14 +28130,17 @@ async function main() {
     vaultRegistry.addContext(primaryCtx2);
     stateDb = primaryCtx2.stateDb;
     activateVault(primaryCtx2, true);
+    serverLog("server", `[${primaryCtx2.name}] stateDb_open=${Date.now() - startTime}ms`);
   } else {
     vaultRegistry = new VaultRegistry("default");
     const ctx = await initializeVault("default", vaultPath);
     vaultRegistry.addContext(ctx);
     stateDb = ctx.stateDb;
     activateVault(ctx, true);
+    serverLog("server", `[${ctx.name}] stateDb_open=${Date.now() - startTime}ms`);
   }
   await initToolRouting();
+  serverLog("server", `tool_routing=${Date.now() - startTime}ms`);
   if (stateDb) {
     try {
       const vaultName = vaultRegistry?.primaryName ?? "default";
@@ -27930,29 +28232,16 @@ async function main() {
     });
   }
   const primaryCtx = vaultRegistry.getContext();
-  if (primaryCtx.stateDb) {
-    const integrity = checkDbIntegrity2(primaryCtx.stateDb.db);
-    if (integrity.ok) {
-      safeBackupAsync2(primaryCtx.stateDb.db, primaryCtx.stateDb.dbPath).catch((err) => {
-        serverLog("backup", `[${primaryCtx.name}] Safe backup failed: ${err}`, "error");
-      });
-    } else {
-      serverLog("statedb", `[${primaryCtx.name}] Integrity check failed: ${integrity.detail} \u2014 recreating`, "error");
-      const dbPath = primaryCtx.stateDb.dbPath;
-      preserveCorruptedDb(dbPath);
-      primaryCtx.stateDb.close();
-      deleteStateDbFiles(dbPath);
-      primaryCtx.stateDb = openStateDb(primaryCtx.vaultPath);
-      attemptSalvage(primaryCtx.stateDb.db, dbPath);
-      stateDb = primaryCtx.stateDb;
-      activateVault(primaryCtx, true);
-    }
-    serverLog("statedb", `[${primaryCtx.name}] Integrity check passed in ${Date.now() - startTime}ms`);
-  }
+  setBootState(primaryCtx, "transport_connected");
+  serverLog("server", `[${primaryCtx.name}] transport_connect=${Date.now() - startTime}ms`);
+  serverLog("server", `[${primaryCtx.name}] integrity_check_started=${Date.now() - startTime}ms`);
+  void runIntegrityCheck(primaryCtx, "startup");
+  setBootState(primaryCtx, "booting");
   loadVaultCooccurrence(primaryCtx);
   activateVault(primaryCtx);
   await bootVault(primaryCtx, startTime);
   activateVault(primaryCtx);
+  serverLog("server", `[${primaryCtx.name}] boot_complete=${Date.now() - startTime}ms`);
   serverReady = true;
   const watchdogInterval = parseInt(process.env.FLYWHEEL_WATCHDOG_INTERVAL ?? "0", 10);
   if (watchdogInterval > 0 && (transportMode === "http" || transportMode === "both")) {
@@ -28014,6 +28303,9 @@ async function main() {
           const ctx = await initializeVault(vc.name, vc.path);
           vaultRegistry.addContext(ctx);
           invalidateHttpPool();
+          setBootState(ctx, "transport_connected");
+          void runIntegrityCheck(ctx, "startup");
+          setBootState(ctx, "booting");
           loadVaultCooccurrence(ctx);
           activateVault(ctx);
           await bootVault(ctx, startTime);
@@ -28229,7 +28521,7 @@ async function runPostIndexWork(ctx) {
           if (attempt < MAX_BUILD_RETRIES) {
             const delay = 1e4;
             serverLog("semantic", `Build failed (attempt ${attempt}/${MAX_BUILD_RETRIES}): ${msg}. Retrying in ${delay / 1e3}s...`, "error");
-            await new Promise((resolve3) => setTimeout(resolve3, delay));
+            await new Promise((resolve4) => setTimeout(resolve4, delay));
             return attemptBuild(attempt + 1);
           }
           serverLog("semantic", `Embeddings build failed after ${MAX_BUILD_RETRIES} attempts: ${msg}`, "error");
@@ -28285,8 +28577,8 @@ async function runPostIndexWork(ctx) {
           }
         } catch {
           try {
-            const dir = path39.dirname(rawPath);
-            const base = path39.basename(rawPath);
+            const dir = path40.dirname(rawPath);
+            const base = path40.basename(rawPath);
             const resolvedDir = realpathSync(dir).replace(/\\/g, "/");
             for (const prefix of vaultPrefixes) {
               if (resolvedDir.startsWith(prefix + "/") || resolvedDir === prefix) {
@@ -28318,7 +28610,7 @@ async function runPostIndexWork(ctx) {
           continue;
         }
         try {
-          const content = await fs35.readFile(path39.join(vp, event.path), "utf-8");
+          const content = await fs35.readFile(path40.join(vp, event.path), "utf-8");
           const hash = createHash4("sha256").update(content).digest("hex").slice(0, 16);
           if (lastContentHashes.get(event.path) === hash) {
             serverLog("watcher", `Hash unchanged, skipping: ${event.path}`);
@@ -28405,7 +28697,8 @@ async function runPostIndexWork(ctx) {
         updateEntitiesInStateDb,
         getVaultIndex: () => vaultIndex,
         buildVaultIndex,
-        deferredScheduler: deferredScheduler ?? void 0
+        deferredScheduler: deferredScheduler ?? void 0,
+        runIntegrityCheck
       });
       await runner.run();
     };