@velvetmonkey/flywheel-memory 2.5.11 → 2.5.13

package/dist/index.js

@@ -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);
@@ -5185,16 +5185,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 +5206,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 +5219,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 +5240,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 +5260,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 +5271,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 +5279,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 +6058,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 +6069,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 +6124,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 +6192,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 +6651,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 +6704,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 +6719,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 +6750,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 +6781,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 +6925,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 +7165,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 +7214,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 +7340,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 +7348,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 +7907,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 +7951,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 +7963,7 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path40,
+        path: path41,
         originalEvents: [...pending.events]
       };
       this.onBatch({
@@ -7972,7 +7972,7 @@ var EventQueue = class {
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path40);
+    this.pending.delete(path41);
   }
   /**
    * Flush all pending events
@@ -7984,7 +7984,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 +7992,7 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path40,
+          path: path41,
           originalEvents: [...pending.events]
         });
       }
@@ -8292,7 +8292,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 +8384,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 +8448,6 @@ import {
   getProtectedZones,
   rangeOverlapsProtectedZone,
   detectImplicitEntities as detectImplicitEntities2,
-  checkDbIntegrity,
-  safeBackupAsync,
   recordEntityMention as recordEntityMention2
 } from "@velvetmonkey/vault-core";
 init_serverLog();
@@ -9740,6 +9738,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 +10634,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 +11002,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 +12146,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 +12834,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 +13186,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 +13429,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 +13483,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 +13507,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 +13550,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 +13652,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 +14209,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 +14643,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 +15188,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 +15738,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 +15901,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 +16102,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 +16161,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 +16170,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 +16233,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 +16249,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 +17356,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 +17373,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 +17388,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 +17432,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 +17501,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 +17520,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 +17676,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 +17689,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 +17697,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 +17878,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 +18404,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 +19035,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 +19219,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 +19230,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 +19503,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 +19722,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 +19748,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 +19764,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 +19777,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 +19844,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 +20049,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 +20059,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 +20093,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 +20117,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 +20153,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 +20164,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 +20180,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 +20189,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 +20228,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 +20239,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 +20726,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 +20752,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 +20787,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 +20928,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 +20950,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 +20969,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 +20978,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 +20989,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 +21076,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 +21158,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 +21234,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 +21369,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 +21666,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 +21794,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 +21804,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 +21855,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 +22003,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 +22194,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 +22232,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 +22515,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 +22570,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 +22581,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 +22607,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 +22721,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 +23155,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 +23261,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 +24391,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 +24407,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 +24443,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 +24570,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 +24628,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 +24658,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 +24837,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 +24907,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 +25049,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 +25058,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 +25073,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 +26952,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 +26992,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 +27212,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 +27245,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 +27380,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 +27395,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 +27489,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 +27585,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 +27603,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 +27648,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 +27763,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,25 +27884,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`);
-    const integrity = checkDbIntegrity2(ctx.stateDb.db);
-    if (integrity.ok) {
-      safeBackupAsync2(ctx.stateDb.db, ctx.stateDb.dbPath).catch((err) => {
-        serverLog("backup", `[${name}] Safe backup failed: ${err}`, "error");
-      });
-    } else {
-      serverLog("statedb", `[${name}] Integrity check failed: ${integrity.detail} \u2014 recreating`, "error");
-      const dbPath = ctx.stateDb.dbPath;
-      preserveCorruptedDb(dbPath);
-      ctx.stateDb.close();
-      deleteStateDbFiles(dbPath);
-      ctx.stateDb = openStateDb(vaultPathArg);
-      attemptSalvage(ctx.stateDb.db, dbPath);
-    }
+    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`);
@@ -27667,7 +27922,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) {
@@ -27821,6 +28085,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();
@@ -27830,7 +28097,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);
@@ -27845,14 +28112,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";
@@ -27944,10 +28214,16 @@ async function main() {
     });
   }
   const primaryCtx = vaultRegistry.getContext();
+  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")) {
@@ -28009,6 +28285,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);
@@ -28224,7 +28503,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");
@@ -28280,8 +28559,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) {
@@ -28313,7 +28592,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}`);
@@ -28400,7 +28679,8 @@ async function runPostIndexWork(ctx) {
         updateEntitiesInStateDb,
         getVaultIndex: () => vaultIndex,
         buildVaultIndex,
-        deferredScheduler: deferredScheduler ?? void 0
+        deferredScheduler: deferredScheduler ?? void 0,
+        runIntegrityCheck
       });
       await runner.run();
     };