@velvetmonkey/flywheel-memory 2.0.1 → 2.0.3

package/dist/index.js

@@ -24,7 +24,7 @@ var init_constants = __esm({
 
 // src/core/write/writer.ts
 import fs14 from "fs/promises";
-import path16 from "path";
+import path15 from "path";
 import matter5 from "gray-matter";
 function isSensitivePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
@@ -345,8 +345,8 @@ function validatePath(vaultPath2, notePath) {
   if (notePath.startsWith("\\")) {
     return false;
   }
-  const resolvedVault = path16.resolve(vaultPath2);
-  const resolvedNote = path16.resolve(vaultPath2, notePath);
+  const resolvedVault = path15.resolve(vaultPath2);
+  const resolvedNote = path15.resolve(vaultPath2, notePath);
   return resolvedNote.startsWith(resolvedVault);
 }
 async function validatePathSecure(vaultPath2, notePath) {
@@ -374,8 +374,8 @@ async function validatePathSecure(vaultPath2, notePath) {
       reason: "Path traversal not allowed"
     };
   }
-  const resolvedVault = path16.resolve(vaultPath2);
-  const resolvedNote = path16.resolve(vaultPath2, notePath);
+  const resolvedVault = path15.resolve(vaultPath2);
+  const resolvedNote = path15.resolve(vaultPath2, notePath);
   if (!resolvedNote.startsWith(resolvedVault)) {
     return {
       valid: false,
@@ -389,7 +389,7 @@ async function validatePathSecure(vaultPath2, notePath) {
     };
   }
   try {
-    const fullPath = path16.join(vaultPath2, notePath);
+    const fullPath = path15.join(vaultPath2, notePath);
     try {
       await fs14.access(fullPath);
       const realPath = await fs14.realpath(fullPath);
@@ -400,7 +400,7 @@ async function validatePathSecure(vaultPath2, notePath) {
           reason: "Symlink target is outside vault"
         };
       }
-      const relativePath = path16.relative(realVaultPath, realPath);
+      const relativePath = path15.relative(realVaultPath, realPath);
       if (isSensitivePath(relativePath)) {
         return {
           valid: false,
@@ -408,7 +408,7 @@ async function validatePathSecure(vaultPath2, notePath) {
         };
       }
     } catch {
-      const parentDir = path16.dirname(fullPath);
+      const parentDir = path15.dirname(fullPath);
       try {
         await fs14.access(parentDir);
         const realParentPath = await fs14.realpath(parentDir);
@@ -434,7 +434,7 @@ async function readVaultFile(vaultPath2, notePath) {
   if (!validatePath(vaultPath2, notePath)) {
     throw new Error("Invalid path: path traversal not allowed");
   }
-  const fullPath = path16.join(vaultPath2, notePath);
+  const fullPath = path15.join(vaultPath2, notePath);
   const rawContent = await fs14.readFile(fullPath, "utf-8");
   const lineEnding = detectLineEnding(rawContent);
   const normalizedContent = normalizeLineEndings(rawContent);
@@ -483,7 +483,7 @@ async function writeVaultFile(vaultPath2, notePath, content, frontmatter, lineEn
   if (!validation.valid) {
     throw new Error(`Invalid path: ${validation.reason}`);
   }
-  const fullPath = path16.join(vaultPath2, notePath);
+  const fullPath = path15.join(vaultPath2, notePath);
   let output = matter5.stringify(content, frontmatter);
   output = normalizeTrailingNewline(output);
   output = convertLineEndings(output, lineEnding);
@@ -710,8 +710,8 @@ function createContext(variables = {}) {
     }
   };
 }
-function resolvePath(obj, path25) {
-  const parts = path25.split(".");
+function resolvePath(obj, path24) {
+  const parts = path24.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === void 0 || current === null) {
@@ -1150,7 +1150,7 @@ __export(conditions_exports, {
   shouldStepExecute: () => shouldStepExecute
 });
 import fs20 from "fs/promises";
-import path22 from "path";
+import path21 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;
@@ -1203,7 +1203,7 @@ async function evaluateCondition(condition, vaultPath2, context) {
   }
 }
 async function evaluateFileExists(vaultPath2, notePath, expectExists) {
-  const fullPath = path22.join(vaultPath2, notePath);
+  const fullPath = path21.join(vaultPath2, notePath);
   try {
     await fs20.access(fullPath);
     return {
@@ -1218,7 +1218,7 @@ async function evaluateFileExists(vaultPath2, notePath, expectExists) {
   }
 }
 async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectExists) {
-  const fullPath = path22.join(vaultPath2, notePath);
+  const fullPath = path21.join(vaultPath2, notePath);
   try {
     await fs20.access(fullPath);
   } catch {
@@ -1249,7 +1249,7 @@ async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectEx
   }
 }
 async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expectExists) {
-  const fullPath = path22.join(vaultPath2, notePath);
+  const fullPath = path21.join(vaultPath2, notePath);
   try {
     await fs20.access(fullPath);
   } catch {
@@ -1280,7 +1280,7 @@ async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expect
   }
 }
 async function evaluateFrontmatterEquals(vaultPath2, notePath, fieldName, expectedValue) {
-  const fullPath = path22.join(vaultPath2, notePath);
+  const fullPath = path21.join(vaultPath2, notePath);
   try {
     await fs20.access(fullPath);
   } catch {
@@ -1689,8 +1689,8 @@ function updateIndexProgress(parsed, total) {
 function normalizeTarget(target) {
   return target.toLowerCase().replace(/\.md$/, "");
 }
-function normalizeNotePath(path25) {
-  return path25.toLowerCase().replace(/\.md$/, "");
+function normalizeNotePath(path24) {
+  return path24.toLowerCase().replace(/\.md$/, "");
 }
 async function buildVaultIndex(vaultPath2, options = {}) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
@@ -1884,7 +1884,7 @@ function findSimilarEntity(index, target) {
   }
   const maxDist = normalizedLen <= 10 ? 1 : 2;
   let bestMatch;
-  for (const [entity, path25] of index.entities) {
+  for (const [entity, path24] of index.entities) {
     const lenDiff = Math.abs(entity.length - normalizedLen);
     if (lenDiff > maxDist) {
       continue;
@@ -1892,7 +1892,7 @@ function findSimilarEntity(index, target) {
     const dist = levenshteinDistance(normalized, entity);
     if (dist > 0 && dist <= maxDist) {
       if (!bestMatch || dist < bestMatch.distance) {
-        bestMatch = { path: path25, entity, distance: dist };
+        bestMatch = { path: path24, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -2322,30 +2322,30 @@ var EventQueue = class {
    * Add a new event to the queue
    */
   push(type, rawPath) {
-    const path25 = normalizePath(rawPath);
+    const path24 = normalizePath(rawPath);
     const now = Date.now();
     const event = {
       type,
-      path: path25,
+      path: path24,
       timestamp: now
     };
-    let pending = this.pending.get(path25);
+    let pending = this.pending.get(path24);
     if (!pending) {
       pending = {
         events: [],
         timer: null,
         lastEvent: now
       };
-      this.pending.set(path25, pending);
+      this.pending.set(path24, pending);
     }
     pending.events.push(event);
     pending.lastEvent = now;
-    console.error(`[flywheel] QUEUE: pushed ${type} for ${path25}, pending=${this.pending.size}`);
+    console.error(`[flywheel] QUEUE: pushed ${type} for ${path24}, pending=${this.pending.size}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
     }
     pending.timer = setTimeout(() => {
-      this.flushPath(path25);
+      this.flushPath(path24);
     }, this.config.debounceMs);
     if (this.pending.size >= this.config.batchSize) {
       this.flush();
@@ -2366,10 +2366,10 @@ var EventQueue = class {
   /**
    * Flush a single path's events
    */
-  flushPath(path25) {
-    const pending = this.pending.get(path25);
+  flushPath(path24) {
+    const pending = this.pending.get(path24);
     if (!pending || pending.events.length === 0) return;
-    console.error(`[flywheel] QUEUE: flushing ${path25}, events=${pending.events.length}`);
+    console.error(`[flywheel] QUEUE: flushing ${path24}, events=${pending.events.length}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -2378,7 +2378,7 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path25,
+        path: path24,
         originalEvents: [...pending.events]
       };
       this.onBatch({
@@ -2386,7 +2386,7 @@ var EventQueue = class {
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path25);
+    this.pending.delete(path24);
   }
   /**
    * Flush all pending events
@@ -2398,7 +2398,7 @@ var EventQueue = class {
     }
     if (this.pending.size === 0) return;
     const events = [];
-    for (const [path25, pending] of this.pending) {
+    for (const [path24, pending] of this.pending) {
       if (pending.timer) {
         clearTimeout(pending.timer);
       }
@@ -2406,7 +2406,7 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path25,
+          path: path24,
           originalEvents: [...pending.events]
         });
       }
@@ -2555,31 +2555,31 @@ function createVaultWatcher(options) {
         usePolling: config.usePolling,
         interval: config.usePolling ? config.pollInterval : void 0
       });
-      watcher.on("add", (path25) => {
-        console.error(`[flywheel] RAW EVENT: add ${path25}`);
-        if (shouldWatch(path25, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: add ${path25}`);
-          eventQueue.push("add", path25);
+      watcher.on("add", (path24) => {
+        console.error(`[flywheel] RAW EVENT: add ${path24}`);
+        if (shouldWatch(path24, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: add ${path24}`);
+          eventQueue.push("add", path24);
         } else {
-          console.error(`[flywheel] FILTERED: add ${path25}`);
+          console.error(`[flywheel] FILTERED: add ${path24}`);
         }
       });
-      watcher.on("change", (path25) => {
-        console.error(`[flywheel] RAW EVENT: change ${path25}`);
-        if (shouldWatch(path25, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: change ${path25}`);
-          eventQueue.push("change", path25);
+      watcher.on("change", (path24) => {
+        console.error(`[flywheel] RAW EVENT: change ${path24}`);
+        if (shouldWatch(path24, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: change ${path24}`);
+          eventQueue.push("change", path24);
         } else {
-          console.error(`[flywheel] FILTERED: change ${path25}`);
+          console.error(`[flywheel] FILTERED: change ${path24}`);
         }
       });
-      watcher.on("unlink", (path25) => {
-        console.error(`[flywheel] RAW EVENT: unlink ${path25}`);
-        if (shouldWatch(path25, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: unlink ${path25}`);
-          eventQueue.push("unlink", path25);
+      watcher.on("unlink", (path24) => {
+        console.error(`[flywheel] RAW EVENT: unlink ${path24}`);
+        if (shouldWatch(path24, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: unlink ${path24}`);
+          eventQueue.push("unlink", path24);
         } else {
-          console.error(`[flywheel] FILTERED: unlink ${path25}`);
+          console.error(`[flywheel] FILTERED: unlink ${path24}`);
         }
       });
       watcher.on("ready", () => {
@@ -2689,7 +2689,10 @@ import {
   applyWikilinks,
   resolveAliasWikilinks,
   getEntityIndexFromDb,
-  getStateDbMetadata
+  getStateDbMetadata,
+  getEntityByName,
+  getEntitiesByAlias,
+  searchEntities as searchEntitiesDb
 } from "@velvetmonkey/vault-core";
 
 // src/core/write/git.ts
@@ -4532,6 +4535,7 @@ function suggestRelatedLinks(content, options = {}) {
   if (SUGGESTION_PATTERN.test(content)) {
     return emptyResult;
   }
+  checkAndRefreshIfStale();
   if (!isEntityIndexReady() || !entityIndex) {
     return emptyResult;
   }
@@ -4650,6 +4654,126 @@ function suggestRelatedLinks(content, options = {}) {
     suffix
   };
 }
+function detectAliasCollisions(noteName, aliases = []) {
+  if (!moduleStateDb4) return [];
+  const collisions = [];
+  const nameAsAlias = getEntitiesByAlias(moduleStateDb4, noteName);
+  for (const entity of nameAsAlias) {
+    if (entity.name.toLowerCase() === noteName.toLowerCase()) continue;
+    collisions.push({
+      term: noteName,
+      source: "name",
+      collidedWith: {
+        name: entity.name,
+        path: entity.path,
+        matchType: "alias"
+      }
+    });
+  }
+  for (const alias of aliases) {
+    const existingByName = getEntityByName(moduleStateDb4, alias);
+    if (existingByName && existingByName.name.toLowerCase() !== noteName.toLowerCase()) {
+      collisions.push({
+        term: alias,
+        source: "alias",
+        collidedWith: {
+          name: existingByName.name,
+          path: existingByName.path,
+          matchType: "name"
+        }
+      });
+    }
+    const existingByAlias = getEntitiesByAlias(moduleStateDb4, alias);
+    for (const entity of existingByAlias) {
+      if (entity.name.toLowerCase() === noteName.toLowerCase()) continue;
+      if (existingByName && existingByName.name.toLowerCase() === entity.name.toLowerCase()) continue;
+      collisions.push({
+        term: alias,
+        source: "alias",
+        collidedWith: {
+          name: entity.name,
+          path: entity.path,
+          matchType: "alias"
+        }
+      });
+    }
+  }
+  return collisions;
+}
+function suggestAliases(noteName, existingAliases = [], category) {
+  const suggestions = [];
+  const existingLower = new Set(existingAliases.map((a) => a.toLowerCase()));
+  const words = noteName.split(/\s+/).filter((w) => w.length > 0);
+  function isSafe(alias) {
+    if (existingLower.has(alias.toLowerCase())) return false;
+    if (alias.toLowerCase() === noteName.toLowerCase()) return false;
+    if (!moduleStateDb4) return true;
+    const existing = getEntityByName(moduleStateDb4, alias);
+    return !existing;
+  }
+  const inferredCategory = category || inferCategoryFromName(noteName);
+  if (inferredCategory === "people" && words.length >= 2) {
+    const firstName = words[0];
+    const lastName = words[words.length - 1];
+    if (firstName.length >= 2 && isSafe(firstName)) {
+      suggestions.push({ alias: firstName, reason: "First name for quick reference" });
+    }
+    if (lastName.length >= 2 && lastName !== firstName && isSafe(lastName)) {
+      suggestions.push({ alias: lastName, reason: "Last name for quick reference" });
+    }
+  }
+  if (words.length >= 3) {
+    const acronym = words.map((w) => w[0]).join("").toUpperCase();
+    if (acronym.length >= 3 && isSafe(acronym)) {
+      suggestions.push({ alias: acronym, reason: `Acronym for "${noteName}"` });
+    }
+  }
+  if (noteName.includes("-")) {
+    const unhyphenated = noteName.replace(/-/g, "");
+    if (unhyphenated !== noteName && isSafe(unhyphenated)) {
+      suggestions.push({ alias: unhyphenated, reason: "Unhyphenated form" });
+    }
+    const spaced = noteName.replace(/-/g, " ");
+    if (spaced !== noteName && isSafe(spaced)) {
+      suggestions.push({ alias: spaced, reason: "Space-separated form" });
+    }
+  }
+  return suggestions;
+}
+function inferCategoryFromName(name) {
+  const words = name.split(/\s+/);
+  if (words.length === 2 || words.length === 3) {
+    const allCapitalized = words.every((w) => /^[A-Z][a-z]/.test(w));
+    if (allCapitalized) return "people";
+  }
+  return void 0;
+}
+function checkPreflightSimilarity(noteName) {
+  const result = { similarEntities: [] };
+  if (!moduleStateDb4) return result;
+  const exact = getEntityByName(moduleStateDb4, noteName);
+  if (exact) {
+    result.existingEntity = {
+      name: exact.name,
+      path: exact.path,
+      category: exact.category
+    };
+  }
+  try {
+    const searchResults = searchEntitiesDb(moduleStateDb4, noteName, 5);
+    for (const sr of searchResults) {
+      if (sr.name.toLowerCase() === noteName.toLowerCase()) continue;
+      result.similarEntities.push({
+        name: sr.name,
+        path: sr.path,
+        category: sr.category,
+        rank: sr.rank
+      });
+    }
+  } catch {
+  }
+  return result;
+}
 
 // src/core/write/logging.ts
 import {
@@ -4672,11 +4796,153 @@ async function flushLogs() {
   if (logger2) await logger2.flush();
 }
 
+// src/core/read/fts5.ts
+import * as fs5 from "fs";
+var EXCLUDED_DIRS2 = /* @__PURE__ */ new Set([
+  ".obsidian",
+  ".trash",
+  ".git",
+  "node_modules",
+  "templates",
+  ".claude",
+  ".flywheel"
+]);
+var MAX_INDEX_FILE_SIZE = 5 * 1024 * 1024;
+var STALE_THRESHOLD_MS = 60 * 60 * 1e3;
+var db = null;
+var state = {
+  ready: false,
+  lastBuilt: null,
+  noteCount: 0,
+  error: null
+};
+function setFTS5Database(database) {
+  db = database;
+  try {
+    const row = db.prepare(
+      "SELECT value FROM fts_metadata WHERE key = ?"
+    ).get("last_built");
+    if (row) {
+      const lastBuilt = new Date(row.value);
+      const countRow = db.prepare("SELECT COUNT(*) as count FROM notes_fts").get();
+      state = {
+        ready: countRow.count > 0,
+        lastBuilt,
+        noteCount: countRow.count,
+        error: null
+      };
+    }
+  } catch {
+  }
+}
+function shouldIndexFile(filePath) {
+  const parts = filePath.split("/");
+  return !parts.some((part) => EXCLUDED_DIRS2.has(part));
+}
+async function buildFTS5Index(vaultPath2) {
+  try {
+    state.error = null;
+    if (!db) {
+      throw new Error("FTS5 database not initialized. Call setFTS5Database() first.");
+    }
+    db.exec("DELETE FROM notes_fts");
+    const files = await scanVault(vaultPath2);
+    const indexableFiles = files.filter((f) => shouldIndexFile(f.path));
+    const insert = db.prepare(
+      "INSERT INTO notes_fts (path, title, content) VALUES (?, ?, ?)"
+    );
+    const insertMany = db.transaction((filesToIndex) => {
+      let indexed2 = 0;
+      for (const file of filesToIndex) {
+        try {
+          const stats = fs5.statSync(file.absolutePath);
+          if (stats.size > MAX_INDEX_FILE_SIZE) {
+            continue;
+          }
+          const content = fs5.readFileSync(file.absolutePath, "utf-8");
+          const title = file.path.replace(/\.md$/, "").split("/").pop() || file.path;
+          insert.run(file.path, title, content);
+          indexed2++;
+        } catch (err) {
+          console.error(`[FTS5] Skipping ${file.path}:`, err);
+        }
+      }
+      return indexed2;
+    });
+    const indexed = insertMany(indexableFiles);
+    const now = /* @__PURE__ */ new Date();
+    db.prepare(
+      "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)"
+    ).run("last_built", now.toISOString());
+    state = {
+      ready: true,
+      lastBuilt: now,
+      noteCount: indexed,
+      error: null
+    };
+    console.error(`[FTS5] Indexed ${indexed} notes`);
+    return state;
+  } catch (err) {
+    state = {
+      ready: false,
+      lastBuilt: null,
+      noteCount: 0,
+      error: err instanceof Error ? err.message : String(err)
+    };
+    throw err;
+  }
+}
+function isIndexStale(_vaultPath) {
+  if (!db) {
+    return true;
+  }
+  try {
+    const row = db.prepare(
+      "SELECT value FROM fts_metadata WHERE key = ?"
+    ).get("last_built");
+    if (!row) {
+      return true;
+    }
+    const lastBuilt = new Date(row.value);
+    const age = Date.now() - lastBuilt.getTime();
+    return age > STALE_THRESHOLD_MS;
+  } catch {
+    return true;
+  }
+}
+function searchFTS5(_vaultPath, query, limit = 10) {
+  if (!db) {
+    throw new Error("FTS5 database not initialized. Call setFTS5Database() first.");
+  }
+  try {
+    const stmt = db.prepare(`
+      SELECT
+        path,
+        title,
+        snippet(notes_fts, 2, '[', ']', '...', 20) as snippet
+      FROM notes_fts
+      WHERE notes_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `);
+    const results = stmt.all(query, limit);
+    return results;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("fts5: syntax error")) {
+      throw new Error(`Invalid search query: ${query}. Check FTS5 syntax.`);
+    }
+    throw err;
+  }
+}
+function getFTS5State() {
+  return { ...state };
+}
+
 // src/index.ts
 import { openStateDb, scanVaultEntities as scanVaultEntities3 } from "@velvetmonkey/vault-core";
 
 // src/tools/read/graph.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as path8 from "path";
 import { z } from "zod";
 
@@ -4701,7 +4967,7 @@ function requireIndex() {
 async function getContext(vaultPath2, sourcePath, line, contextLines = 1) {
   try {
     const fullPath = path8.join(vaultPath2, sourcePath);
-    const content = await fs5.promises.readFile(fullPath, "utf-8");
+    const content = await fs6.promises.readFile(fullPath, "utf-8");
     const lines = content.split("\n");
     const startLine = Math.max(0, line - 1 - contextLines);
     const endLine = Math.min(lines.length, line + contextLines);
@@ -5091,14 +5357,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path25] of entities) {
+    for (const [name, path24] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path25;
+        return path24;
       }
     }
-    for (const [name, path25] of entities) {
+    for (const [name, path24] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path25;
+        return path24;
       }
     }
     return void 0;
@@ -5178,7 +5444,7 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
 }
 
 // src/tools/read/health.ts
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import { z as z3 } from "zod";
 var STALE_THRESHOLD_SECONDS = 300;
 function registerHealthTools(server2, getIndex, getVaultPath) {
@@ -5218,7 +5484,7 @@ function registerHealthTools(server2, getIndex, getVaultPath) {
       const indexErrorObj = getIndexError();
       let vaultAccessible = false;
       try {
-        fs6.accessSync(vaultPath2, fs6.constants.R_OK);
+        fs7.accessSync(vaultPath2, fs7.constants.R_OK);
         vaultAccessible = true;
       } catch {
         vaultAccessible = false;
@@ -5395,8 +5661,8 @@ function registerHealthTools(server2, getIndex, getVaultPath) {
     top_tags: z3.array(TagStatSchema).describe("Top 20 most used tags"),
     folders: z3.array(FolderStatSchema).describe("Note counts by top-level folder")
   };
-  function isPeriodicNote(path25) {
-    const filename = path25.split("/").pop() || "";
+  function isPeriodicNote(path24) {
+    const filename = path24.split("/").pop() || "";
     const nameWithoutExt = filename.replace(/\.md$/, "");
     const patterns = [
       /^\d{4}-\d{2}-\d{2}$/,
@@ -5411,7 +5677,7 @@ function registerHealthTools(server2, getIndex, getVaultPath) {
       // YYYY (yearly)
     ];
     const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
-    const folder = path25.split("/")[0]?.toLowerCase() || "";
+    const folder = path24.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   server2.registerTool(
@@ -5504,166 +5770,6 @@ function registerHealthTools(server2, getIndex, getVaultPath) {
 
 // src/tools/read/query.ts
 import { z as z4 } from "zod";
-
-// src/core/read/fts5.ts
-import Database from "better-sqlite3";
-import * as fs7 from "fs";
-import * as path9 from "path";
-var EXCLUDED_DIRS2 = /* @__PURE__ */ new Set([
-  ".obsidian",
-  ".trash",
-  ".git",
-  "node_modules",
-  "templates",
-  ".claude"
-]);
-var MAX_INDEX_FILE_SIZE = 5 * 1024 * 1024;
-var STALE_THRESHOLD_MS = 60 * 60 * 1e3;
-var db = null;
-var state = {
-  ready: false,
-  lastBuilt: null,
-  noteCount: 0,
-  error: null
-};
-function getDbPath(vaultPath2) {
-  const claudeDir = path9.join(vaultPath2, ".claude");
-  if (!fs7.existsSync(claudeDir)) {
-    fs7.mkdirSync(claudeDir, { recursive: true });
-  }
-  return path9.join(claudeDir, "vault-search.db");
-}
-function initDatabase(vaultPath2) {
-  const dbPath = getDbPath(vaultPath2);
-  const database = new Database(dbPath);
-  database.exec(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(
-      path,
-      title,
-      content,
-      tokenize='porter'
-    );
-
-    CREATE TABLE IF NOT EXISTS fts_metadata (
-      key TEXT PRIMARY KEY,
-      value TEXT
-    );
-  `);
-  return database;
-}
-function shouldIndexFile(filePath) {
-  const parts = filePath.split("/");
-  return !parts.some((part) => EXCLUDED_DIRS2.has(part));
-}
-async function buildFTS5Index(vaultPath2) {
-  try {
-    state.error = null;
-    db = initDatabase(vaultPath2);
-    db.exec("DELETE FROM notes_fts");
-    const files = await scanVault(vaultPath2);
-    const indexableFiles = files.filter((f) => shouldIndexFile(f.path));
-    const insert = db.prepare(
-      "INSERT INTO notes_fts (path, title, content) VALUES (?, ?, ?)"
-    );
-    const insertMany = db.transaction((filesToIndex) => {
-      let indexed2 = 0;
-      for (const file of filesToIndex) {
-        try {
-          const stats = fs7.statSync(file.absolutePath);
-          if (stats.size > MAX_INDEX_FILE_SIZE) {
-            continue;
-          }
-          const content = fs7.readFileSync(file.absolutePath, "utf-8");
-          const title = file.path.replace(/\.md$/, "").split("/").pop() || file.path;
-          insert.run(file.path, title, content);
-          indexed2++;
-        } catch (err) {
-          console.error(`[FTS5] Skipping ${file.path}:`, err);
-        }
-      }
-      return indexed2;
-    });
-    const indexed = insertMany(indexableFiles);
-    const now = /* @__PURE__ */ new Date();
-    db.prepare(
-      "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)"
-    ).run("last_built", now.toISOString());
-    state = {
-      ready: true,
-      lastBuilt: now,
-      noteCount: indexed,
-      error: null
-    };
-    console.error(`[FTS5] Indexed ${indexed} notes`);
-    return state;
-  } catch (err) {
-    state = {
-      ready: false,
-      lastBuilt: null,
-      noteCount: 0,
-      error: err instanceof Error ? err.message : String(err)
-    };
-    throw err;
-  }
-}
-function isIndexStale(vaultPath2) {
-  const dbPath = getDbPath(vaultPath2);
-  if (!fs7.existsSync(dbPath)) {
-    return true;
-  }
-  try {
-    const database = new Database(dbPath, { readonly: true });
-    const row = database.prepare(
-      "SELECT value FROM fts_metadata WHERE key = ?"
-    ).get("last_built");
-    database.close();
-    if (!row) {
-      return true;
-    }
-    const lastBuilt = new Date(row.value);
-    const age = Date.now() - lastBuilt.getTime();
-    return age > STALE_THRESHOLD_MS;
-  } catch {
-    return true;
-  }
-}
-function ensureDb(vaultPath2) {
-  if (!db) {
-    const dbPath = getDbPath(vaultPath2);
-    if (!fs7.existsSync(dbPath)) {
-      throw new Error("Search index not built. Call rebuild_search_index first.");
-    }
-    db = new Database(dbPath);
-  }
-  return db;
-}
-function searchFTS5(vaultPath2, query, limit = 10) {
-  const database = ensureDb(vaultPath2);
-  try {
-    const stmt = database.prepare(`
-      SELECT
-        path,
-        title,
-        snippet(notes_fts, 2, '[', ']', '...', 20) as snippet
-      FROM notes_fts
-      WHERE notes_fts MATCH ?
-      ORDER BY rank
-      LIMIT ?
-    `);
-    const results = stmt.all(query, limit);
-    return results;
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("fts5: syntax error")) {
-      throw new Error(`Invalid search query: ${query}. Check FTS5 syntax.`);
-    }
-    throw err;
-  }
-}
-function getFTS5State() {
-  return { ...state };
-}
-
-// src/tools/read/query.ts
 import {
   searchEntities,
   searchEntitiesPrefix
@@ -6033,7 +6139,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
 
 // src/tools/read/system.ts
 import * as fs8 from "fs";
-import * as path10 from "path";
+import * as path9 from "path";
 import { z as z5 } from "zod";
 import { scanVaultEntities as scanVaultEntities2 } from "@velvetmonkey/vault-core";
 function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfig, getStateDb) {
@@ -6311,7 +6417,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
           continue;
         }
         try {
-          const fullPath = path10.join(vaultPath2, note.path);
+          const fullPath = path9.join(vaultPath2, note.path);
           const content = await fs8.promises.readFile(fullPath, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
@@ -6427,7 +6533,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
       let wordCount;
       if (include_word_count) {
         try {
-          const fullPath = path10.join(vaultPath2, resolvedPath);
+          const fullPath = path9.join(vaultPath2, resolvedPath);
           const content = await fs8.promises.readFile(fullPath, "utf-8");
           wordCount = content.split(/\s+/).filter((w) => w.length > 0).length;
         } catch {
@@ -6593,8 +6699,8 @@ function getStaleNotes(index, days, minBacklinks = 0) {
     return b.days_since_modified - a.days_since_modified;
   });
 }
-function getContemporaneousNotes(index, path25, hours = 24) {
-  const targetNote = index.notes.get(path25);
+function getContemporaneousNotes(index, path24, hours = 24) {
+  const targetNote = index.notes.get(path24);
   if (!targetNote) {
     return [];
   }
@@ -6602,7 +6708,7 @@ function getContemporaneousNotes(index, path25, hours = 24) {
   const windowMs = hours * 60 * 60 * 1e3;
   const results = [];
   for (const note of index.notes.values()) {
-    if (note.path === path25) continue;
+    if (note.path === path24) continue;
     const timeDiff = Math.abs(note.modified.getTime() - targetTime);
     if (timeDiff <= windowMs) {
       results.push({
@@ -6651,7 +6757,7 @@ function getActivitySummary(index, days) {
 
 // src/tools/read/structure.ts
 import * as fs9 from "fs";
-import * as path11 from "path";
+import * as path10 from "path";
 var HEADING_REGEX = /^(#{1,6})\s+(.+)$/;
 function extractHeadings(content) {
   const lines = content.split("\n");
@@ -6705,7 +6811,7 @@ function buildSections(headings, totalLines) {
 async function getNoteStructure(index, notePath, vaultPath2) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path11.join(vaultPath2, notePath);
+  const absolutePath = path10.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs9.promises.readFile(absolutePath, "utf-8");
@@ -6728,7 +6834,7 @@ async function getNoteStructure(index, notePath, vaultPath2) {
 async function getHeadings(index, notePath, vaultPath2) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path11.join(vaultPath2, notePath);
+  const absolutePath = path10.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs9.promises.readFile(absolutePath, "utf-8");
@@ -6740,7 +6846,7 @@ async function getHeadings(index, notePath, vaultPath2) {
 async function getSectionContent(index, notePath, headingText, vaultPath2, includeSubheadings = true) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path11.join(vaultPath2, notePath);
+  const absolutePath = path10.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs9.promises.readFile(absolutePath, "utf-8");
@@ -6782,7 +6888,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 = path11.join(vaultPath2, note.path);
+    const absolutePath = path10.join(vaultPath2, note.path);
     let content;
     try {
       content = await fs9.promises.readFile(absolutePath, "utf-8");
@@ -6806,7 +6912,7 @@ async function findSections(index, headingPattern, vaultPath2, folder) {
 
 // src/tools/read/tasks.ts
 import * as fs10 from "fs";
-import * as path12 from "path";
+import * as path11 from "path";
 var TASK_REGEX = /^(\s*)- \[([ xX\-])\]\s+(.+)$/;
 var TAG_REGEX2 = /#([a-zA-Z][a-zA-Z0-9_/-]*)/g;
 var DATE_REGEX = /\b(\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}\/\d{2,4})\b/;
@@ -6875,7 +6981,7 @@ async function getAllTasks(index, vaultPath2, options = {}) {
   const allTasks = [];
   for (const note of index.notes.values()) {
     if (folder && !note.path.startsWith(folder)) continue;
-    const absolutePath = path12.join(vaultPath2, note.path);
+    const absolutePath = path11.join(vaultPath2, note.path);
     const tasks = await extractTasksFromNote(note.path, absolutePath);
     allTasks.push(...tasks);
   }
@@ -6906,7 +7012,7 @@ async function getAllTasks(index, vaultPath2, options = {}) {
 async function getTasksFromNote(index, notePath, vaultPath2, excludeTags = []) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path12.join(vaultPath2, notePath);
+  const absolutePath = path11.join(vaultPath2, notePath);
   let tasks = await extractTasksFromNote(notePath, absolutePath);
   if (excludeTags.length > 0) {
     tasks = tasks.filter(
@@ -7394,14 +7500,14 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         offset: z6.coerce.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path25, hours, limit: requestedLimit, offset }) => {
+    async ({ path: path24, hours, limit: requestedLimit, offset }) => {
       const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
       const index = getIndex();
-      const allResults = getContemporaneousNotes(index, path25, hours);
+      const allResults = getContemporaneousNotes(index, path24, hours);
       const result = allResults.slice(offset, offset + limit);
       return {
         content: [{ type: "text", text: JSON.stringify({
-          reference_note: path25,
+          reference_note: path24,
           window_hours: hours,
           total_count: allResults.length,
           returned_count: result.length,
@@ -7439,13 +7545,13 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         path: z6.string().describe("Path to the note")
       }
     },
-    async ({ path: path25 }) => {
+    async ({ path: path24 }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path25, vaultPath2);
+      const result = await getNoteStructure(index, path24, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path25 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path24 }, null, 2) }]
         };
       }
       return {
@@ -7462,18 +7568,18 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         path: z6.string().describe("Path to the note")
       }
     },
-    async ({ path: path25 }) => {
+    async ({ path: path24 }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getHeadings(index, path25, vaultPath2);
+      const result = await getHeadings(index, path24, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path25 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path24 }, null, 2) }]
         };
       }
       return {
         content: [{ type: "text", text: JSON.stringify({
-          path: path25,
+          path: path24,
           heading_count: result.length,
           headings: result
         }, null, 2) }]
@@ -7491,15 +7597,15 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         include_subheadings: z6.boolean().default(true).describe("Include content under subheadings")
       }
     },
-    async ({ path: path25, heading, include_subheadings }) => {
+    async ({ path: path24, heading, include_subheadings }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path25, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path24, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path25,
+            path: path24,
             heading
           }, null, 2) }]
         };
@@ -7576,19 +7682,19 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         path: z6.string().describe("Path to the note")
       }
     },
-    async ({ path: path25 }) => {
+    async ({ path: path24 }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const config = getConfig();
-      const result = await getTasksFromNote(index, path25, vaultPath2, config.exclude_task_tags || []);
+      const result = await getTasksFromNote(index, path24, vaultPath2, config.exclude_task_tags || []);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path25 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path24 }, null, 2) }]
         };
       }
       return {
         content: [{ type: "text", text: JSON.stringify({
-          path: path25,
+          path: path24,
           task_count: result.length,
           open: result.filter((t) => t.status === "open").length,
           completed: result.filter((t) => t.status === "completed").length,
@@ -7720,14 +7826,14 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         offset: z6.coerce.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path25, limit: requestedLimit, offset }) => {
+    async ({ path: path24, limit: requestedLimit, offset }) => {
       const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
       const index = getIndex();
-      const allResults = findBidirectionalLinks(index, path25);
+      const allResults = findBidirectionalLinks(index, path24);
       const result = allResults.slice(offset, offset + limit);
       return {
         content: [{ type: "text", text: JSON.stringify({
-          scope: path25 || "all",
+          scope: path24 || "all",
           total_count: allResults.length,
           returned_count: result.length,
           pairs: result
@@ -8135,13 +8241,13 @@ function registerPeriodicTools(server2, getIndex) {
 // src/tools/read/bidirectional.ts
 import { z as z8 } from "zod";
 import * as fs11 from "fs/promises";
-import * as path13 from "path";
+import * as path12 from "path";
 import matter2 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;
 var WIKILINK_REGEX2 = /\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|[^\]]+)?\]\]/g;
 async function readFileContent(notePath, vaultPath2) {
-  const fullPath = path13.join(vaultPath2, notePath);
+  const fullPath = path12.join(vaultPath2, notePath);
   try {
     return await fs11.readFile(fullPath, "utf-8");
   } catch {
@@ -8877,10 +8983,10 @@ function registerSchemaTools(server2, getIndex, getVaultPath) {
 // src/tools/read/computed.ts
 import { z as z10 } from "zod";
 import * as fs12 from "fs/promises";
-import * as path14 from "path";
+import * as path13 from "path";
 import matter3 from "gray-matter";
 async function readFileContent2(notePath, vaultPath2) {
-  const fullPath = path14.join(vaultPath2, notePath);
+  const fullPath = path13.join(vaultPath2, notePath);
   try {
     return await fs12.readFile(fullPath, "utf-8");
   } catch {
@@ -8888,7 +8994,7 @@ async function readFileContent2(notePath, vaultPath2) {
   }
 }
 async function getFileStats(notePath, vaultPath2) {
-  const fullPath = path14.join(vaultPath2, notePath);
+  const fullPath = path13.join(vaultPath2, notePath);
   try {
     const stats = await fs12.stat(fullPath);
     return {
@@ -9047,7 +9153,7 @@ function registerComputedTools(server2, getIndex, getVaultPath) {
 // src/tools/read/migrations.ts
 import { z as z11 } from "zod";
 import * as fs13 from "fs/promises";
-import * as path15 from "path";
+import * as path14 from "path";
 import matter4 from "gray-matter";
 function getNotesInFolder2(index, folder) {
   const notes = [];
@@ -9060,7 +9166,7 @@ function getNotesInFolder2(index, folder) {
   return notes;
 }
 async function readFileContent3(notePath, vaultPath2) {
-  const fullPath = path15.join(vaultPath2, notePath);
+  const fullPath = path14.join(vaultPath2, notePath);
   try {
     return await fs13.readFile(fullPath, "utf-8");
   } catch {
@@ -9068,7 +9174,7 @@ async function readFileContent3(notePath, vaultPath2) {
   }
 }
 async function writeFileContent(notePath, vaultPath2, content) {
-  const fullPath = path15.join(vaultPath2, notePath);
+  const fullPath = path14.join(vaultPath2, notePath);
   try {
     await fs13.writeFile(fullPath, content, "utf-8");
     return true;
@@ -9452,7 +9558,7 @@ function runValidationPipeline(content, format, options = {}) {
 // src/core/write/mutation-helpers.ts
 init_writer();
 import fs15 from "fs/promises";
-import path17 from "path";
+import path16 from "path";
 init_constants();
 init_writer();
 function formatMcpResult(result) {
@@ -9501,7 +9607,7 @@ async function handleGitCommit(vaultPath2, notePath, commit, prefix) {
   return info;
 }
 async function ensureFileExists(vaultPath2, notePath) {
-  const fullPath = path17.join(vaultPath2, notePath);
+  const fullPath = path16.join(vaultPath2, notePath);
   try {
     await fs15.access(fullPath);
     return null;
@@ -10060,8 +10166,8 @@ function registerFrontmatterTools(server2, vaultPath2) {
 init_writer();
 import { z as z15 } from "zod";
 import fs16 from "fs/promises";
-import path18 from "path";
-function registerNoteTools(server2, vaultPath2) {
+import path17 from "path";
+function registerNoteTools(server2, vaultPath2, getIndex) {
   server2.tool(
     "vault_create_note",
     "Create a new note in the vault with optional frontmatter and content",
@@ -10082,13 +10188,39 @@ function registerNoteTools(server2, vaultPath2) {
         if (!validatePath(vaultPath2, notePath)) {
           return formatMcpResult(errorResult(notePath, "Invalid path: path traversal not allowed"));
         }
-        const fullPath = path18.join(vaultPath2, notePath);
+        const fullPath = path17.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 = path18.dirname(fullPath);
+        const dir = path17.dirname(fullPath);
         await fs16.mkdir(dir, { recursive: true });
+        const warnings = [];
+        const noteName = path17.basename(notePath, ".md");
+        const existingAliases = Array.isArray(frontmatter?.aliases) ? frontmatter.aliases.filter((a) => typeof a === "string") : [];
+        const preflight = checkPreflightSimilarity(noteName);
+        if (preflight.existingEntity) {
+          warnings.push({
+            type: "similar_note_exists",
+            message: `An entity "${preflight.existingEntity.name}" already exists at ${preflight.existingEntity.path}`,
+            suggestion: `Consider linking to the existing note instead, or choose a different name`
+          });
+        }
+        for (const similar of preflight.similarEntities.slice(0, 3)) {
+          warnings.push({
+            type: "similar_note_exists",
+            message: `Similar entity "${similar.name}" exists at ${similar.path}`,
+            suggestion: `Check if this is a duplicate`
+          });
+        }
+        const collisions = detectAliasCollisions(noteName, existingAliases);
+        for (const collision of collisions) {
+          warnings.push({
+            type: "alias_collision",
+            message: `${collision.source === "name" ? "Note name" : "Alias"} "${collision.term}" collides with ${collision.collidedWith.matchType} of "${collision.collidedWith.name}" (${collision.collidedWith.path})`,
+            suggestion: `This may cause ambiguous wikilink resolution`
+          });
+        }
         let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(content, skipWikilinks, notePath);
         let suggestInfo;
         if (suggestOutgoingLinks && !skipWikilinks) {
@@ -10114,12 +10246,22 @@ function registerNoteTools(server2, vaultPath2) {
         }
         const hasAliases = frontmatter && "aliases" in frontmatter;
         if (!hasAliases) {
-          previewLines.push("");
-          previewLines.push('Tip: Add aliases to frontmatter for flexible wikilink matching (e.g., aliases: ["Short Name"])');
+          const aliasSuggestions = suggestAliases(noteName, existingAliases);
+          if (aliasSuggestions.length > 0) {
+            previewLines.push("");
+            previewLines.push("Suggested aliases:");
+            for (const s of aliasSuggestions) {
+              previewLines.push(`  - "${s.alias}" (${s.reason})`);
+            }
+          } else {
+            previewLines.push("");
+            previewLines.push('Tip: Add aliases to frontmatter for flexible wikilink matching (e.g., aliases: ["Short Name"])');
+          }
         }
         return formatMcpResult(
           successResult(notePath, `Created note: ${notePath}`, gitInfo, {
-            preview: previewLines.join("\n")
+            preview: previewLines.join("\n"),
+            warnings: warnings.length > 0 ? warnings : void 0
           })
         );
       } catch (error) {
@@ -10139,9 +10281,6 @@ function registerNoteTools(server2, vaultPath2) {
     },
     async ({ path: notePath, confirm, commit }) => {
       try {
-        if (!confirm) {
-          return formatMcpResult(errorResult(notePath, "Deletion requires explicit confirmation (confirm=true)"));
-        }
         if (!validatePath(vaultPath2, notePath)) {
           return formatMcpResult(errorResult(notePath, "Invalid path: path traversal not allowed"));
         }
@@ -10149,10 +10288,38 @@ function registerNoteTools(server2, vaultPath2) {
         if (existsError) {
           return formatMcpResult(existsError);
         }
-        const fullPath = path18.join(vaultPath2, notePath);
+        let backlinkWarning;
+        if (getIndex) {
+          try {
+            const index = getIndex();
+            const backlinks = getBacklinksForNote(index, notePath);
+            if (backlinks.length > 0) {
+              const sources = backlinks.slice(0, 10).map((bl) => `  - ${bl.source}${bl.context ? ` ("${bl.context.slice(0, 60)}")` : ""}`).join("\n");
+              backlinkWarning = `This note is referenced from ${backlinks.length} other note(s):
+${sources}`;
+              if (backlinks.length > 10) {
+                backlinkWarning += `
+  ... and ${backlinks.length - 10} more`;
+              }
+            }
+          } catch {
+          }
+        }
+        if (!confirm) {
+          const previewLines = ["Deletion requires explicit confirmation (confirm=true)"];
+          if (backlinkWarning) {
+            previewLines.push("");
+            previewLines.push("Warning: " + backlinkWarning);
+          }
+          return formatMcpResult(errorResult(notePath, previewLines.join("\n")));
+        }
+        const fullPath = path17.join(vaultPath2, notePath);
         await fs16.unlink(fullPath);
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Crank:Delete]");
-        return formatMcpResult(successResult(notePath, `Deleted note: ${notePath}`, gitInfo));
+        const message = backlinkWarning ? `Deleted note: ${notePath}
+
+Warning: ${backlinkWarning}` : `Deleted note: ${notePath}`;
+        return formatMcpResult(successResult(notePath, message, gitInfo));
       } catch (error) {
         return formatMcpResult(
           errorResult(notePath, `Failed to delete note: ${error instanceof Error ? error.message : String(error)}`)
@@ -10166,7 +10333,7 @@ function registerNoteTools(server2, vaultPath2) {
 init_writer();
 import { z as z16 } from "zod";
 import fs17 from "fs/promises";
-import path19 from "path";
+import path18 from "path";
 import matter6 from "gray-matter";
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -10185,7 +10352,7 @@ function extractWikilinks2(content) {
   return wikilinks;
 }
 function getTitleFromPath(filePath) {
-  return path19.basename(filePath, ".md");
+  return path18.basename(filePath, ".md");
 }
 async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   const results = [];
@@ -10194,7 +10361,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
     const files = [];
     const entries = await fs17.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path19.join(dir, entry.name);
+      const fullPath = path18.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         files.push(...await scanDir(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -10205,7 +10372,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   }
   const allFiles = await scanDir(vaultPath2);
   for (const filePath of allFiles) {
-    const relativePath = path19.relative(vaultPath2, filePath);
+    const relativePath = path18.relative(vaultPath2, filePath);
     const content = await fs17.readFile(filePath, "utf-8");
     const wikilinks = extractWikilinks2(content);
     const matchingLinks = [];
@@ -10225,7 +10392,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   return results;
 }
 async function updateBacklinksInFile(vaultPath2, filePath, oldTitles, newTitle) {
-  const fullPath = path19.join(vaultPath2, filePath);
+  const fullPath = path18.join(vaultPath2, filePath);
   const raw = await fs17.readFile(fullPath, "utf-8");
   const parsed = matter6(raw);
   let content = parsed.content;
@@ -10292,8 +10459,8 @@ function registerMoveNoteTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const oldFullPath = path19.join(vaultPath2, oldPath);
-        const newFullPath = path19.join(vaultPath2, newPath);
+        const oldFullPath = path18.join(vaultPath2, oldPath);
+        const newFullPath = path18.join(vaultPath2, newPath);
         try {
           await fs17.access(oldFullPath);
         } catch {
@@ -10343,7 +10510,7 @@ function registerMoveNoteTools(server2, vaultPath2) {
             }
           }
         }
-        const destDir = path19.dirname(newFullPath);
+        const destDir = path18.dirname(newFullPath);
         await fs17.mkdir(destDir, { recursive: true });
         await fs17.rename(oldFullPath, newFullPath);
         let gitCommit;
@@ -10429,10 +10596,10 @@ function registerMoveNoteTools(server2, vaultPath2) {
         if (sanitizedTitle !== newTitle) {
           console.error(`[Crank] Title sanitized: "${newTitle}" \u2192 "${sanitizedTitle}"`);
         }
-        const fullPath = path19.join(vaultPath2, notePath);
-        const dir = path19.dirname(notePath);
-        const newPath = dir === "." ? `${sanitizedTitle}.md` : path19.join(dir, `${sanitizedTitle}.md`);
-        const newFullPath = path19.join(vaultPath2, newPath);
+        const fullPath = path18.join(vaultPath2, notePath);
+        const dir = path18.dirname(notePath);
+        const newPath = dir === "." ? `${sanitizedTitle}.md` : path18.join(dir, `${sanitizedTitle}.md`);
+        const newFullPath = path18.join(vaultPath2, newPath);
         try {
           await fs17.access(fullPath);
         } catch {
@@ -10544,7 +10711,7 @@ function registerMoveNoteTools(server2, vaultPath2) {
 init_writer();
 import { z as z17 } from "zod";
 import fs18 from "fs/promises";
-import path20 from "path";
+import path19 from "path";
 function registerSystemTools2(server2, vaultPath2) {
   server2.tool(
     "vault_list_sections",
@@ -10564,7 +10731,7 @@ function registerSystemTools2(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const fullPath = path20.join(vaultPath2, notePath);
+        const fullPath = path19.join(vaultPath2, notePath);
         try {
           await fs18.access(fullPath);
         } catch {
@@ -10718,7 +10885,7 @@ init_schema();
 // src/core/write/policy/parser.ts
 init_schema();
 import fs19 from "fs/promises";
-import path21 from "path";
+import path20 from "path";
 import matter7 from "gray-matter";
 function parseYaml(content) {
   const parsed = matter7(`---
@@ -10767,13 +10934,13 @@ async function loadPolicyFile(filePath) {
   }
 }
 async function loadPolicy(vaultPath2, policyName) {
-  const policiesDir = path21.join(vaultPath2, ".claude", "policies");
-  const policyPath = path21.join(policiesDir, `${policyName}.yaml`);
+  const policiesDir = path20.join(vaultPath2, ".claude", "policies");
+  const policyPath = path20.join(policiesDir, `${policyName}.yaml`);
   try {
     await fs19.access(policyPath);
     return loadPolicyFile(policyPath);
   } catch {
-    const ymlPath = path21.join(policiesDir, `${policyName}.yml`);
+    const ymlPath = path20.join(policiesDir, `${policyName}.yml`);
     try {
       await fs19.access(ymlPath);
       return loadPolicyFile(ymlPath);
@@ -10914,7 +11081,7 @@ init_conditions();
 init_schema();
 init_writer();
 import fs21 from "fs/promises";
-import path23 from "path";
+import path22 from "path";
 init_constants();
 async function executeStep(step, vaultPath2, context, conditionResults) {
   const { execute, reason } = shouldStepExecute(step.when, conditionResults);
@@ -10983,7 +11150,7 @@ async function executeAddToSection(params, vaultPath2, context) {
   const preserveListNesting = params.preserveListNesting !== false;
   const suggestOutgoingLinks = params.suggestOutgoingLinks !== false;
   const maxSuggestions = Number(params.maxSuggestions) || 3;
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path22.join(vaultPath2, notePath);
   try {
     await fs21.access(fullPath);
   } catch {
@@ -11023,7 +11190,7 @@ async function executeRemoveFromSection(params, vaultPath2) {
   const pattern = String(params.pattern || "");
   const mode = params.mode || "first";
   const useRegex = Boolean(params.useRegex);
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path22.join(vaultPath2, notePath);
   try {
     await fs21.access(fullPath);
   } catch {
@@ -11054,7 +11221,7 @@ async function executeReplaceInSection(params, vaultPath2, context) {
   const mode = params.mode || "first";
   const useRegex = Boolean(params.useRegex);
   const skipWikilinks = Boolean(params.skipWikilinks);
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path22.join(vaultPath2, notePath);
   try {
     await fs21.access(fullPath);
   } catch {
@@ -11097,7 +11264,7 @@ async function executeCreateNote(params, vaultPath2, context) {
   if (!validatePath(vaultPath2, notePath)) {
     return { success: false, message: "Invalid path: path traversal not allowed", path: notePath };
   }
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path22.join(vaultPath2, notePath);
   try {
     await fs21.access(fullPath);
     if (!overwrite) {
@@ -11105,7 +11272,7 @@ async function executeCreateNote(params, vaultPath2, context) {
     }
   } catch {
   }
-  const dir = path23.dirname(fullPath);
+  const dir = path22.dirname(fullPath);
   await fs21.mkdir(dir, { recursive: true });
   const { content: processedContent } = maybeApplyWikilinks(content, skipWikilinks, notePath);
   await writeVaultFile(vaultPath2, notePath, processedContent, frontmatter);
@@ -11125,7 +11292,7 @@ async function executeDeleteNote(params, vaultPath2) {
   if (!validatePath(vaultPath2, notePath)) {
     return { success: false, message: "Invalid path: path traversal not allowed", path: notePath };
   }
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path22.join(vaultPath2, notePath);
   try {
     await fs21.access(fullPath);
   } catch {
@@ -11142,7 +11309,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 = path23.join(vaultPath2, notePath);
+  const fullPath = path22.join(vaultPath2, notePath);
   try {
     await fs21.access(fullPath);
   } catch {
@@ -11185,7 +11352,7 @@ async function executeAddTask(params, vaultPath2, context) {
   const completed = Boolean(params.completed);
   const skipWikilinks = Boolean(params.skipWikilinks);
   const preserveListNesting = params.preserveListNesting !== false;
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path22.join(vaultPath2, notePath);
   try {
     await fs21.access(fullPath);
   } catch {
@@ -11222,7 +11389,7 @@ async function executeAddTask(params, vaultPath2, context) {
 async function executeUpdateFrontmatter(params, vaultPath2) {
   const notePath = String(params.path || "");
   const updates = params.frontmatter || {};
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path22.join(vaultPath2, notePath);
   try {
     await fs21.access(fullPath);
   } catch {
@@ -11244,7 +11411,7 @@ async function executeAddFrontmatterField(params, vaultPath2) {
   const notePath = String(params.path || "");
   const key = String(params.key || "");
   const value = params.value;
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path22.join(vaultPath2, notePath);
   try {
     await fs21.access(fullPath);
   } catch {
@@ -11404,7 +11571,7 @@ async function executePolicy(policy, vaultPath2, variables, commit = false) {
 async function rollbackChanges(vaultPath2, originalContents, filesModified) {
   for (const filePath of filesModified) {
     const original = originalContents.get(filePath);
-    const fullPath = path23.join(vaultPath2, filePath);
+    const fullPath = path22.join(vaultPath2, filePath);
     if (original === null) {
       try {
         await fs21.unlink(fullPath);
@@ -11459,9 +11626,9 @@ async function previewPolicy(policy, vaultPath2, variables) {
 
 // src/core/write/policy/storage.ts
 import fs22 from "fs/promises";
-import path24 from "path";
+import path23 from "path";
 function getPoliciesDir(vaultPath2) {
-  return path24.join(vaultPath2, ".claude", "policies");
+  return path23.join(vaultPath2, ".claude", "policies");
 }
 async function ensurePoliciesDir(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
@@ -11476,7 +11643,7 @@ async function listPolicies(vaultPath2) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
         continue;
       }
-      const filePath = path24.join(dir, file);
+      const filePath = path23.join(dir, file);
       const stat3 = await fs22.stat(filePath);
       const content = await fs22.readFile(filePath, "utf-8");
       const metadata = extractPolicyMetadata(content);
@@ -11499,8 +11666,8 @@ async function listPolicies(vaultPath2) {
 }
 async function getPolicyPath(vaultPath2, policyName) {
   const dir = getPoliciesDir(vaultPath2);
-  const yamlPath = path24.join(dir, `${policyName}.yaml`);
-  const ymlPath = path24.join(dir, `${policyName}.yml`);
+  const yamlPath = path23.join(dir, `${policyName}.yaml`);
+  const ymlPath = path23.join(dir, `${policyName}.yml`);
   try {
     await fs22.access(yamlPath);
     return yamlPath;
@@ -11517,7 +11684,7 @@ async function savePolicy(vaultPath2, policy, overwrite = false) {
   const dir = getPoliciesDir(vaultPath2);
   await ensurePoliciesDir(vaultPath2);
   const filename = `${policy.name}.yaml`;
-  const filePath = path24.join(dir, filename);
+  const filePath = path23.join(dir, filename);
   if (!overwrite) {
     try {
       await fs22.access(filePath);
@@ -11556,7 +11723,7 @@ async function writePolicyRaw(vaultPath2, policyName, content, overwrite = false
   const dir = getPoliciesDir(vaultPath2);
   await ensurePoliciesDir(vaultPath2);
   const filename = `${policyName}.yaml`;
-  const filePath = path24.join(dir, filename);
+  const filePath = path23.join(dir, filename);
   if (!overwrite) {
     try {
       await fs22.access(filePath);
@@ -12554,7 +12721,7 @@ registerMigrationTools(server, () => vaultIndex, () => vaultPath);
 registerMutationTools(server, vaultPath);
 registerTaskTools(server, vaultPath);
 registerFrontmatterTools(server, vaultPath);
-registerNoteTools(server, vaultPath);
+registerNoteTools(server, vaultPath, () => vaultIndex);
 registerMoveNoteTools(server, vaultPath);
 registerSystemTools2(server, vaultPath);
 registerPolicyTools(server, vaultPath);
@@ -12566,6 +12733,7 @@ async function main() {
   try {
     stateDb = openStateDb(vaultPath);
     console.error("[Memory] StateDb initialized");
+    setFTS5Database(stateDb.db);
     setCrankStateDb(stateDb);
     await initializeEntityIndex(vaultPath);
   } catch (err) {
@@ -12723,8 +12891,8 @@ async function runPostIndexWork(index) {
         }
       });
       let rebuildTimer;
-      legacyWatcher.on("all", (event, path25) => {
-        if (!path25.endsWith(".md")) return;
+      legacyWatcher.on("all", (event, path24) => {
+        if (!path24.endsWith(".md")) return;
         clearTimeout(rebuildTimer);
         rebuildTimer = setTimeout(() => {
           console.error("[Memory] Rebuilding index (file changed)");