@velvetmonkey/flywheel-memory 2.0.19 → 2.0.20

package/dist/index.js

@@ -9,6 +9,41 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/core/shared/levenshtein.ts
+function levenshteinDistance(a, b) {
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+var init_levenshtein = __esm({
+  "src/core/shared/levenshtein.ts"() {
+    "use strict";
+  }
+});
+
 // src/core/write/constants.ts
 function estimateTokens(content) {
   const str = typeof content === "string" ? content : JSON.stringify(content);
@@ -23,8 +58,8 @@ var init_constants = __esm({
 });
 
 // src/core/write/writer.ts
-import fs17 from "fs/promises";
-import path16 from "path";
+import fs18 from "fs/promises";
+import path17 from "path";
 import matter5 from "gray-matter";
 function isSensitivePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
@@ -263,9 +298,51 @@ function detectSectionBaseIndentation(lines, sectionStartLine, sectionEndLine) {
   }
   return "";
 }
+function bumpHeadingLevels(content, parentLevel) {
+  const lines = content.split("\n");
+  let inCodeBlock = false;
+  let minLevel = Infinity;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+    const match = line.match(HEADING_REGEX3);
+    if (match) {
+      const level = match[1].length;
+      if (level < minLevel) {
+        minLevel = level;
+      }
+    }
+  }
+  if (minLevel === Infinity) return content;
+  const bump = parentLevel + 1 - minLevel;
+  if (bump <= 0) return content;
+  inCodeBlock = false;
+  const result = lines.map((line) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+      inCodeBlock = !inCodeBlock;
+      return line;
+    }
+    if (inCodeBlock) return line;
+    const match = line.match(HEADING_REGEX3);
+    if (match) {
+      const newLevel = Math.min(match[1].length + bump, 6);
+      return "#".repeat(newLevel) + " " + match[2];
+    }
+    return line;
+  });
+  return result.join("\n");
+}
 function insertInSection(content, section, newContent, position, options) {
   const lines = content.split("\n");
-  const formattedContent = newContent.trim();
+  let formattedContent = newContent.trim();
+  if (options?.bumpHeadings !== false) {
+    formattedContent = bumpHeadingLevels(formattedContent, section.level);
+  }
   if (position === "prepend") {
     if (options?.preserveListNesting) {
       const indent = detectSectionBaseIndentation(lines, section.contentStartLine, section.endLine);
@@ -345,8 +422,8 @@ function validatePath(vaultPath2, notePath) {
   if (notePath.startsWith("\\")) {
     return false;
   }
-  const resolvedVault = path16.resolve(vaultPath2);
-  const resolvedNote = path16.resolve(vaultPath2, notePath);
+  const resolvedVault = path17.resolve(vaultPath2);
+  const resolvedNote = path17.resolve(vaultPath2, notePath);
   return resolvedNote.startsWith(resolvedVault);
 }
 async function validatePathSecure(vaultPath2, notePath) {
@@ -374,8 +451,8 @@ async function validatePathSecure(vaultPath2, notePath) {
       reason: "Path traversal not allowed"
     };
   }
-  const resolvedVault = path16.resolve(vaultPath2);
-  const resolvedNote = path16.resolve(vaultPath2, notePath);
+  const resolvedVault = path17.resolve(vaultPath2);
+  const resolvedNote = path17.resolve(vaultPath2, notePath);
   if (!resolvedNote.startsWith(resolvedVault)) {
     return {
       valid: false,
@@ -389,18 +466,18 @@ async function validatePathSecure(vaultPath2, notePath) {
     };
   }
   try {
-    const fullPath = path16.join(vaultPath2, notePath);
+    const fullPath = path17.join(vaultPath2, notePath);
     try {
-      await fs17.access(fullPath);
-      const realPath = await fs17.realpath(fullPath);
-      const realVaultPath = await fs17.realpath(vaultPath2);
+      await fs18.access(fullPath);
+      const realPath = await fs18.realpath(fullPath);
+      const realVaultPath = await fs18.realpath(vaultPath2);
       if (!realPath.startsWith(realVaultPath)) {
         return {
           valid: false,
           reason: "Symlink target is outside vault"
         };
       }
-      const relativePath = path16.relative(realVaultPath, realPath);
+      const relativePath = path17.relative(realVaultPath, realPath);
       if (isSensitivePath(relativePath)) {
         return {
           valid: false,
@@ -408,11 +485,11 @@ async function validatePathSecure(vaultPath2, notePath) {
         };
       }
     } catch {
-      const parentDir = path16.dirname(fullPath);
+      const parentDir = path17.dirname(fullPath);
       try {
-        await fs17.access(parentDir);
-        const realParentPath = await fs17.realpath(parentDir);
-        const realVaultPath = await fs17.realpath(vaultPath2);
+        await fs18.access(parentDir);
+        const realParentPath = await fs18.realpath(parentDir);
+        const realVaultPath = await fs18.realpath(vaultPath2);
         if (!realParentPath.startsWith(realVaultPath)) {
           return {
             valid: false,
@@ -434,8 +511,8 @@ 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 rawContent = await fs17.readFile(fullPath, "utf-8");
+  const fullPath = path17.join(vaultPath2, notePath);
+  const rawContent = await fs18.readFile(fullPath, "utf-8");
   const lineEnding = detectLineEnding(rawContent);
   const normalizedContent = normalizeLineEndings(rawContent);
   const parsed = matter5(normalizedContent);
@@ -483,11 +560,11 @@ 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 = path17.join(vaultPath2, notePath);
   let output = matter5.stringify(content, frontmatter);
   output = normalizeTrailingNewline(output);
   output = convertLineEndings(output, lineEnding);
-  await fs17.writeFile(fullPath, output, "utf-8");
+  await fs18.writeFile(fullPath, output, "utf-8");
 }
 function removeFromSection(content, section, pattern, mode = "first", useRegex = false) {
   const lines = content.split("\n");
@@ -555,6 +632,76 @@ function replaceInSection(content, section, search, replacement, mode = "first",
     newLines
   };
 }
+function buildReplaceNotFoundDiagnostic(sectionContent, searchText, sectionName, sectionStartLine) {
+  const sectionLines = sectionContent.split("\n");
+  const sectionLineCount = sectionLines.length;
+  const sectionEndLine = sectionStartLine + sectionLineCount - 1;
+  const searchLines = searchText.split("\n");
+  const isMultiLine = searchLines.length > 1;
+  let closestMatch = null;
+  if (!isMultiLine) {
+    for (let i = 0; i < sectionLines.length; i++) {
+      const line = sectionLines[i].trim();
+      if (line === "") continue;
+      const dist = levenshteinDistance(searchText.trim(), line);
+      if (closestMatch === null || dist < closestMatch.distance) {
+        closestMatch = {
+          text: sectionLines[i],
+          distance: dist,
+          line: sectionStartLine + i
+        };
+      }
+    }
+  } else {
+    const windowSize = searchLines.length;
+    for (let i = 0; i <= sectionLines.length - windowSize; i++) {
+      const windowText = sectionLines.slice(i, i + windowSize).join("\n");
+      const dist = levenshteinDistance(searchText, windowText);
+      if (closestMatch === null || dist < closestMatch.distance) {
+        closestMatch = {
+          text: windowText,
+          distance: dist,
+          line: sectionStartLine + i
+        };
+      }
+    }
+  }
+  let lineAnalysis = null;
+  if (isMultiLine) {
+    lineAnalysis = searchLines.map((searchLine, idx) => {
+      const trimmedSearch = searchLine.trim();
+      const found = sectionLines.some((sl) => sl.includes(trimmedSearch));
+      return {
+        lineNumber: idx + 1,
+        searchLine: trimmedSearch,
+        found
+      };
+    });
+  }
+  const suggestions = [];
+  if (closestMatch && closestMatch.distance <= Math.max(3, Math.floor(searchText.length * 0.2))) {
+    suggestions.push(`Did you mean: "${closestMatch.text.trim()}"?`);
+  }
+  suggestions.push("Try using useRegex: true for pattern matching");
+  if (isMultiLine) {
+    suggestions.push("For multi-line content, try breaking into smaller replacements");
+  }
+  if (searchText !== searchText.trim() || /^\s|\s$/.test(searchText)) {
+    suggestions.push("Check for whitespace differences");
+  }
+  return {
+    sectionName,
+    sectionLineRange: { start: sectionStartLine, end: sectionEndLine },
+    sectionLineCount,
+    closestMatch: closestMatch ? {
+      text: closestMatch.text,
+      distance: closestMatch.distance,
+      line: closestMatch.line
+    } : null,
+    lineAnalysis,
+    suggestions
+  };
+}
 function injectMutationMetadata(frontmatter, scoping) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   frontmatter._last_modified_at = now;
@@ -578,11 +725,12 @@ function injectMutationMetadata(frontmatter, scoping) {
   }
   return frontmatter;
 }
-var SENSITIVE_PATH_PATTERNS, REDOS_PATTERNS, MAX_REGEX_LENGTH, EMPTY_PLACEHOLDER_PATTERNS;
+var SENSITIVE_PATH_PATTERNS, REDOS_PATTERNS, MAX_REGEX_LENGTH, EMPTY_PLACEHOLDER_PATTERNS, DiagnosticError;
 var init_writer = __esm({
   "src/core/write/writer.ts"() {
     "use strict";
     init_constants();
+    init_levenshtein();
     SENSITIVE_PATH_PATTERNS = [
       // Environment files (including backups, variations, and Windows ADS)
       /\.env($|\..*|~|\.swp|\.swo|:)/i,
@@ -683,6 +831,14 @@ var init_writer = __esm({
       /^\*\s*$/
       // "* " (asterisk bullet placeholder)
     ];
+    DiagnosticError = class extends Error {
+      diagnostic;
+      constructor(message, diagnostic) {
+        super(message);
+        this.name = "DiagnosticError";
+        this.diagnostic = diagnostic;
+      }
+    };
   }
 });
 
@@ -711,8 +867,8 @@ function createContext(variables = {}) {
     }
   };
 }
-function resolvePath(obj, path28) {
-  const parts = path28.split(".");
+function resolvePath(obj, path29) {
+  const parts = path29.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === void 0 || current === null) {
@@ -1150,8 +1306,8 @@ __export(conditions_exports, {
   evaluateCondition: () => evaluateCondition,
   shouldStepExecute: () => shouldStepExecute
 });
-import fs23 from "fs/promises";
-import path22 from "path";
+import fs24 from "fs/promises";
+import path23 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;
@@ -1204,9 +1360,9 @@ async function evaluateCondition(condition, vaultPath2, context) {
   }
 }
 async function evaluateFileExists(vaultPath2, notePath, expectExists) {
-  const fullPath = path22.join(vaultPath2, notePath);
+  const fullPath = path23.join(vaultPath2, notePath);
   try {
-    await fs23.access(fullPath);
+    await fs24.access(fullPath);
     return {
       met: expectExists,
       reason: expectExists ? `File exists: ${notePath}` : `File exists (expected not to): ${notePath}`
@@ -1219,9 +1375,9 @@ async function evaluateFileExists(vaultPath2, notePath, expectExists) {
   }
 }
 async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectExists) {
-  const fullPath = path22.join(vaultPath2, notePath);
+  const fullPath = path23.join(vaultPath2, notePath);
   try {
-    await fs23.access(fullPath);
+    await fs24.access(fullPath);
   } catch {
     return {
       met: !expectExists,
@@ -1250,9 +1406,9 @@ async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectEx
   }
 }
 async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expectExists) {
-  const fullPath = path22.join(vaultPath2, notePath);
+  const fullPath = path23.join(vaultPath2, notePath);
   try {
-    await fs23.access(fullPath);
+    await fs24.access(fullPath);
   } catch {
     return {
       met: !expectExists,
@@ -1281,9 +1437,9 @@ async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expect
   }
 }
 async function evaluateFrontmatterEquals(vaultPath2, notePath, fieldName, expectedValue) {
-  const fullPath = path22.join(vaultPath2, notePath);
+  const fullPath = path23.join(vaultPath2, notePath);
   try {
-    await fs23.access(fullPath);
+    await fs24.access(fullPath);
   } catch {
     return {
       met: false,
@@ -1424,7 +1580,7 @@ var init_taskHelpers = __esm({
 });
 
 // src/index.ts
-import * as path27 from "path";
+import * as path28 from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -1663,6 +1819,376 @@ function createEmptyNote(file) {
 }
 
 // src/core/read/graph.ts
+init_levenshtein();
+
+// src/core/read/embeddings.ts
+import * as crypto from "crypto";
+import * as fs3 from "fs";
+import * as path2 from "path";
+var MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+var EXCLUDED_DIRS2 = /* @__PURE__ */ new Set([
+  ".obsidian",
+  ".trash",
+  ".git",
+  "node_modules",
+  "templates",
+  ".claude",
+  ".flywheel"
+]);
+var MAX_FILE_SIZE2 = 5 * 1024 * 1024;
+var db = null;
+var pipeline = null;
+var initPromise = null;
+var embeddingCache = /* @__PURE__ */ new Map();
+var EMBEDDING_CACHE_MAX = 500;
+var entityEmbeddingsMap = /* @__PURE__ */ new Map();
+function setEmbeddingsDatabase(database) {
+  db = database;
+}
+async function initEmbeddings() {
+  if (pipeline) return;
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    try {
+      const transformers = await Function("specifier", "return import(specifier)")("@huggingface/transformers");
+      pipeline = await transformers.pipeline("feature-extraction", MODEL_ID, {
+        dtype: "fp32"
+      });
+    } catch (err) {
+      initPromise = null;
+      if (err instanceof Error && (err.message.includes("Cannot find package") || err.message.includes("MODULE_NOT_FOUND") || err.message.includes("Cannot find module") || err.message.includes("ERR_MODULE_NOT_FOUND"))) {
+        throw new Error(
+          "Semantic search requires @huggingface/transformers. Install it with: npm install @huggingface/transformers"
+        );
+      }
+      throw err;
+    }
+  })();
+  return initPromise;
+}
+async function embedText(text) {
+  await initEmbeddings();
+  const truncated = text.slice(0, 2e3);
+  const result = await pipeline(truncated, { pooling: "mean", normalize: true });
+  return new Float32Array(result.data);
+}
+async function embedTextCached(text) {
+  const existing = embeddingCache.get(text);
+  if (existing) return existing;
+  const embedding = await embedText(text);
+  if (embeddingCache.size >= EMBEDDING_CACHE_MAX) {
+    const firstKey = embeddingCache.keys().next().value;
+    if (firstKey !== void 0) embeddingCache.delete(firstKey);
+  }
+  embeddingCache.set(text, embedding);
+  return embedding;
+}
+function contentHash(content) {
+  return crypto.createHash("md5").update(content).digest("hex");
+}
+function shouldIndexFile(filePath) {
+  const parts = filePath.split("/");
+  return !parts.some((part) => EXCLUDED_DIRS2.has(part));
+}
+async function buildEmbeddingsIndex(vaultPath2, onProgress) {
+  if (!db) {
+    throw new Error("Embeddings database not initialized. Call setEmbeddingsDatabase() first.");
+  }
+  await initEmbeddings();
+  const files = await scanVault(vaultPath2);
+  const indexable = files.filter((f) => shouldIndexFile(f.path));
+  const existingHashes = /* @__PURE__ */ new Map();
+  const rows = db.prepare("SELECT path, content_hash FROM note_embeddings").all();
+  for (const row of rows) {
+    existingHashes.set(row.path, row.content_hash);
+  }
+  const upsert = db.prepare(`
+    INSERT OR REPLACE INTO note_embeddings (path, embedding, content_hash, model, updated_at)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+  const progress = { total: indexable.length, current: 0, skipped: 0 };
+  for (const file of indexable) {
+    progress.current++;
+    try {
+      const stats = fs3.statSync(file.absolutePath);
+      if (stats.size > MAX_FILE_SIZE2) {
+        progress.skipped++;
+        continue;
+      }
+      const content = fs3.readFileSync(file.absolutePath, "utf-8");
+      const hash = contentHash(content);
+      if (existingHashes.get(file.path) === hash) {
+        progress.skipped++;
+        if (onProgress) onProgress(progress);
+        continue;
+      }
+      const embedding = await embedText(content);
+      const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+      upsert.run(file.path, buf, hash, MODEL_ID, Date.now());
+    } catch {
+      progress.skipped++;
+    }
+    if (onProgress) onProgress(progress);
+  }
+  const currentPaths = new Set(indexable.map((f) => f.path));
+  const deleteStmt = db.prepare("DELETE FROM note_embeddings WHERE path = ?");
+  for (const existingPath of existingHashes.keys()) {
+    if (!currentPaths.has(existingPath)) {
+      deleteStmt.run(existingPath);
+    }
+  }
+  console.error(`[Semantic] Indexed ${progress.current - progress.skipped} notes, skipped ${progress.skipped}`);
+  return progress;
+}
+async function updateEmbedding(notePath, absolutePath) {
+  if (!db) return;
+  try {
+    const content = fs3.readFileSync(absolutePath, "utf-8");
+    const hash = contentHash(content);
+    const existing = db.prepare("SELECT content_hash FROM note_embeddings WHERE path = ?").get(notePath);
+    if (existing?.content_hash === hash) return;
+    const embedding = await embedText(content);
+    const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+    db.prepare(`
+      INSERT OR REPLACE INTO note_embeddings (path, embedding, content_hash, model, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(notePath, buf, hash, MODEL_ID, Date.now());
+  } catch {
+  }
+}
+function removeEmbedding(notePath) {
+  if (!db) return;
+  db.prepare("DELETE FROM note_embeddings WHERE path = ?").run(notePath);
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denom === 0) return 0;
+  return dot / denom;
+}
+async function semanticSearch(query, limit = 10) {
+  if (!db) {
+    throw new Error("Embeddings database not initialized. Call setEmbeddingsDatabase() first.");
+  }
+  const queryEmbedding = await embedText(query);
+  const rows = db.prepare("SELECT path, embedding FROM note_embeddings").all();
+  const scored = [];
+  for (const row of rows) {
+    const noteEmbedding = new Float32Array(
+      row.embedding.buffer,
+      row.embedding.byteOffset,
+      row.embedding.byteLength / Float32Array.BYTES_PER_ELEMENT
+    );
+    const score = cosineSimilarity(queryEmbedding, noteEmbedding);
+    const title = row.path.replace(/\.md$/, "").split("/").pop() || row.path;
+    scored.push({ path: row.path, title, score: Math.round(score * 1e3) / 1e3 });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit);
+}
+async function findSemanticallySimilar(sourcePath, limit = 10, excludePaths) {
+  if (!db) {
+    throw new Error("Embeddings database not initialized. Call setEmbeddingsDatabase() first.");
+  }
+  const sourceRow = db.prepare("SELECT embedding FROM note_embeddings WHERE path = ?").get(sourcePath);
+  if (!sourceRow) {
+    return [];
+  }
+  const sourceEmbedding = new Float32Array(
+    sourceRow.embedding.buffer,
+    sourceRow.embedding.byteOffset,
+    sourceRow.embedding.byteLength / Float32Array.BYTES_PER_ELEMENT
+  );
+  const rows = db.prepare("SELECT path, embedding FROM note_embeddings WHERE path != ?").all(sourcePath);
+  const scored = [];
+  for (const row of rows) {
+    if (excludePaths?.has(row.path)) continue;
+    const noteEmbedding = new Float32Array(
+      row.embedding.buffer,
+      row.embedding.byteOffset,
+      row.embedding.byteLength / Float32Array.BYTES_PER_ELEMENT
+    );
+    const score = cosineSimilarity(sourceEmbedding, noteEmbedding);
+    const title = row.path.replace(/\.md$/, "").split("/").pop() || row.path;
+    scored.push({ path: row.path, title, score: Math.round(score * 1e3) / 1e3 });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit);
+}
+function reciprocalRankFusion(...lists) {
+  const k = 60;
+  const scores = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    for (let rank = 0; rank < list.length; rank++) {
+      const item = list[rank];
+      const rrfScore = 1 / (k + rank + 1);
+      scores.set(item.path, (scores.get(item.path) || 0) + rrfScore);
+    }
+  }
+  return scores;
+}
+function hasEmbeddingsIndex() {
+  if (!db) return false;
+  try {
+    const row = db.prepare("SELECT COUNT(*) as count FROM note_embeddings").get();
+    return row.count > 0;
+  } catch {
+    return false;
+  }
+}
+function getEmbeddingsCount() {
+  if (!db) return 0;
+  try {
+    const row = db.prepare("SELECT COUNT(*) as count FROM note_embeddings").get();
+    return row.count;
+  } catch {
+    return 0;
+  }
+}
+function loadAllNoteEmbeddings() {
+  const result = /* @__PURE__ */ new Map();
+  if (!db) return result;
+  try {
+    const rows = db.prepare("SELECT path, embedding FROM note_embeddings").all();
+    for (const row of rows) {
+      const embedding = new Float32Array(
+        row.embedding.buffer,
+        row.embedding.byteOffset,
+        row.embedding.byteLength / Float32Array.BYTES_PER_ELEMENT
+      );
+      result.set(row.path, embedding);
+    }
+  } catch {
+  }
+  return result;
+}
+function buildEntityEmbeddingText(entity, vaultPath2) {
+  const parts = [entity.name, entity.name];
+  if (entity.aliases.length > 0) {
+    parts.push(entity.aliases.join(" "));
+  }
+  parts.push(entity.category);
+  if (entity.path) {
+    try {
+      const absPath = path2.join(vaultPath2, entity.path);
+      const content = fs3.readFileSync(absPath, "utf-8");
+      parts.push(content.slice(0, 500));
+    } catch {
+    }
+  }
+  return parts.join(" ");
+}
+async function buildEntityEmbeddingsIndex(vaultPath2, entities, onProgress) {
+  if (!db) {
+    throw new Error("Embeddings database not initialized. Call setEmbeddingsDatabase() first.");
+  }
+  await initEmbeddings();
+  const existingHashes = /* @__PURE__ */ new Map();
+  const rows = db.prepare("SELECT entity_name, source_hash FROM entity_embeddings").all();
+  for (const row of rows) {
+    existingHashes.set(row.entity_name, row.source_hash);
+  }
+  const upsert = db.prepare(`
+    INSERT OR REPLACE INTO entity_embeddings (entity_name, embedding, source_hash, model, updated_at)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+  const total = entities.size;
+  let done = 0;
+  let updated = 0;
+  for (const [name, entity] of entities) {
+    done++;
+    try {
+      const text = buildEntityEmbeddingText(entity, vaultPath2);
+      const hash = contentHash(text);
+      if (existingHashes.get(name) === hash) {
+        if (onProgress) onProgress(done, total);
+        continue;
+      }
+      const embedding = await embedTextCached(text);
+      const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+      upsert.run(name, buf, hash, MODEL_ID, Date.now());
+      updated++;
+    } catch {
+    }
+    if (onProgress) onProgress(done, total);
+  }
+  const deleteStmt = db.prepare("DELETE FROM entity_embeddings WHERE entity_name = ?");
+  for (const existingName of existingHashes.keys()) {
+    if (!entities.has(existingName)) {
+      deleteStmt.run(existingName);
+    }
+  }
+  console.error(`[Semantic] Entity embeddings: ${updated} updated, ${total - updated} unchanged`);
+  return updated;
+}
+async function updateEntityEmbedding(entityName, entity, vaultPath2) {
+  if (!db) return;
+  try {
+    const text = buildEntityEmbeddingText(entity, vaultPath2);
+    const hash = contentHash(text);
+    const existing = db.prepare("SELECT source_hash FROM entity_embeddings WHERE entity_name = ?").get(entityName);
+    if (existing?.source_hash === hash) return;
+    const embedding = await embedTextCached(text);
+    const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+    db.prepare(`
+      INSERT OR REPLACE INTO entity_embeddings (entity_name, embedding, source_hash, model, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(entityName, buf, hash, MODEL_ID, Date.now());
+    entityEmbeddingsMap.set(entityName, embedding);
+  } catch {
+  }
+}
+function findSemanticallySimilarEntities(queryEmbedding, limit, excludeEntities) {
+  const scored = [];
+  for (const [entityName, embedding] of entityEmbeddingsMap) {
+    if (excludeEntities?.has(entityName)) continue;
+    const similarity = cosineSimilarity(queryEmbedding, embedding);
+    scored.push({ entityName, similarity: Math.round(similarity * 1e3) / 1e3 });
+  }
+  scored.sort((a, b) => b.similarity - a.similarity);
+  return scored.slice(0, limit);
+}
+function hasEntityEmbeddingsIndex() {
+  return entityEmbeddingsMap.size > 0;
+}
+function loadEntityEmbeddingsToMemory() {
+  if (!db) return;
+  try {
+    const rows = db.prepare("SELECT entity_name, embedding FROM entity_embeddings").all();
+    entityEmbeddingsMap.clear();
+    for (const row of rows) {
+      const embedding = new Float32Array(
+        row.embedding.buffer,
+        row.embedding.byteOffset,
+        row.embedding.byteLength / Float32Array.BYTES_PER_ELEMENT
+      );
+      entityEmbeddingsMap.set(row.entity_name, embedding);
+    }
+    if (rows.length > 0) {
+      console.error(`[Semantic] Loaded ${rows.length} entity embeddings into memory`);
+    }
+  } catch {
+  }
+}
+function getEntityEmbeddingsCount() {
+  if (!db) return 0;
+  try {
+    const row = db.prepare("SELECT COUNT(*) as count FROM entity_embeddings").get();
+    return row.count;
+  } catch {
+    return 0;
+  }
+}
+
+// src/core/read/graph.ts
+init_levenshtein();
 var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
 var PARSE_CONCURRENCY = 50;
 var PROGRESS_INTERVAL = 100;
@@ -1690,8 +2216,8 @@ function updateIndexProgress(parsed, total) {
 function normalizeTarget(target) {
   return target.toLowerCase().replace(/\.md$/, "");
 }
-function normalizeNotePath(path28) {
-  return path28.toLowerCase().replace(/\.md$/, "");
+function normalizeNotePath(path29) {
+  return path29.toLowerCase().replace(/\.md$/, "");
 }
 async function buildVaultIndex(vaultPath2, options = {}) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
@@ -1843,39 +2369,11 @@ function findHubNotes(index, minLinks = 5) {
         title: note.title,
         backlink_count: backlinkCount,
         forward_link_count: forwardLinkCount,
-        total_connections: totalConnections
-      });
-    }
-  }
-  return hubs.sort((a, b) => b.total_connections - a.total_connections);
-}
-function levenshteinDistance(a, b) {
-  if (a.length === 0) return b.length;
-  if (b.length === 0) return a.length;
-  const matrix = [];
-  for (let i = 0; i <= b.length; i++) {
-    matrix[i] = [i];
-  }
-  for (let j = 0; j <= a.length; j++) {
-    matrix[0][j] = j;
-  }
-  for (let i = 1; i <= b.length; i++) {
-    for (let j = 1; j <= a.length; j++) {
-      if (b.charAt(i - 1) === a.charAt(j - 1)) {
-        matrix[i][j] = matrix[i - 1][j - 1];
-      } else {
-        matrix[i][j] = Math.min(
-          matrix[i - 1][j - 1] + 1,
-          // substitution
-          matrix[i][j - 1] + 1,
-          // insertion
-          matrix[i - 1][j] + 1
-          // deletion
-        );
-      }
+        total_connections: totalConnections
+      });
     }
   }
-  return matrix[b.length][a.length];
+  return hubs.sort((a, b) => b.total_connections - a.total_connections);
 }
 function findSimilarEntity(index, target) {
   const normalized = normalizeTarget(target);
@@ -1885,7 +2383,7 @@ function findSimilarEntity(index, target) {
   }
   const maxDist = normalizedLen <= 10 ? 1 : 2;
   let bestMatch;
-  for (const [entity, path28] of index.entities) {
+  for (const [entity, path29] of index.entities) {
     const lenDiff = Math.abs(entity.length - normalizedLen);
     if (lenDiff > maxDist) {
       continue;
@@ -1893,7 +2391,7 @@ function findSimilarEntity(index, target) {
     const dist = levenshteinDistance(normalized, entity);
     if (dist > 0 && dist <= maxDist) {
       if (!bestMatch || dist < bestMatch.distance) {
-        bestMatch = { path: path28, entity, distance: dist };
+        bestMatch = { path: path29, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -1986,8 +2484,8 @@ function saveVaultIndexToCache(stateDb2, index) {
 }
 
 // src/core/read/config.ts
-import * as fs3 from "fs";
-import * as path2 from "path";
+import * as fs4 from "fs";
+import * as path3 from "path";
 import {
   loadFlywheelConfigFromDb,
   saveFlywheelConfigToDb
@@ -2030,7 +2528,7 @@ var FOLDER_PATTERNS = {
 function extractFolders(index) {
   const folders = /* @__PURE__ */ new Set();
   for (const notePath of index.notes.keys()) {
-    const dir = path2.dirname(notePath);
+    const dir = path3.dirname(notePath);
     if (dir && dir !== ".") {
       const parts = dir.split(/[/\\]/);
       for (let i = 1; i <= parts.length; i++) {
@@ -2047,7 +2545,7 @@ function extractFolders(index) {
 function findMatchingFolder(folders, patterns) {
   const lowerPatterns = patterns.map((p) => p.toLowerCase());
   for (const folder of folders) {
-    const folderName = path2.basename(folder).toLowerCase();
+    const folderName = path3.basename(folder).toLowerCase();
     if (lowerPatterns.includes(folderName)) {
       return folder;
     }
@@ -2060,7 +2558,7 @@ function inferConfig(index, vaultPath2) {
     paths: {}
   };
   if (vaultPath2) {
-    inferred.vault_name = path2.basename(vaultPath2);
+    inferred.vault_name = path3.basename(vaultPath2);
   }
   const folders = extractFolders(index);
   const detectedPath = findMatchingFolder(folders, FOLDER_PATTERNS.daily_notes);
@@ -2095,9 +2593,9 @@ var TEMPLATE_PATTERNS = {
 };
 function scanTemplatesFolder(vaultPath2, templatesFolder) {
   const templates = {};
-  const absFolder = path2.join(vaultPath2, templatesFolder);
+  const absFolder = path3.join(vaultPath2, templatesFolder);
   try {
-    const files = fs3.readdirSync(absFolder);
+    const files = fs4.readdirSync(absFolder);
     for (const file of files) {
       for (const [type, pattern] of Object.entries(TEMPLATE_PATTERNS)) {
         if (pattern.test(file) && !templates[type]) {
@@ -2135,19 +2633,19 @@ function saveConfig(stateDb2, inferred, existing) {
 }
 
 // src/core/read/vaultRoot.ts
-import * as fs4 from "fs";
-import * as path3 from "path";
+import * as fs5 from "fs";
+import * as path4 from "path";
 var VAULT_MARKERS = [".obsidian", ".claude"];
 function findVaultRoot(startPath) {
-  let current = path3.resolve(startPath || process.cwd());
+  let current = path4.resolve(startPath || process.cwd());
   while (true) {
     for (const marker of VAULT_MARKERS) {
-      const markerPath = path3.join(current, marker);
-      if (fs4.existsSync(markerPath) && fs4.statSync(markerPath).isDirectory()) {
+      const markerPath = path4.join(current, marker);
+      if (fs5.existsSync(markerPath) && fs5.statSync(markerPath).isDirectory()) {
         return current;
       }
     }
-    const parent = path3.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current) {
       return startPath || process.cwd();
     }
@@ -2159,7 +2657,7 @@ function findVaultRoot(startPath) {
 import chokidar from "chokidar";
 
 // src/core/read/watch/pathFilter.ts
-import path4 from "path";
+import path5 from "path";
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
   ".git",
   ".obsidian",
@@ -2257,7 +2755,7 @@ function isIgnoredDirectory(segment) {
   return IGNORED_DIRECTORIES.has(segment);
 }
 function hasIgnoredExtension(filePath) {
-  const ext = path4.extname(filePath).toLowerCase();
+  const ext = path5.extname(filePath).toLowerCase();
   return IGNORED_EXTENSIONS.has(ext);
 }
 function matchesIgnoredPattern(filename) {
@@ -2271,7 +2769,7 @@ function normalizePath(filePath) {
   return normalized;
 }
 function getRelativePath(vaultPath2, filePath) {
-  const relative = path4.relative(vaultPath2, filePath);
+  const relative = path5.relative(vaultPath2, filePath);
   return normalizePath(relative);
 }
 function shouldWatch(filePath, vaultPath2) {
@@ -2355,30 +2853,30 @@ var EventQueue = class {
    * Add a new event to the queue
    */
   push(type, rawPath) {
-    const path28 = normalizePath(rawPath);
+    const path29 = normalizePath(rawPath);
     const now = Date.now();
     const event = {
       type,
-      path: path28,
+      path: path29,
       timestamp: now
     };
-    let pending = this.pending.get(path28);
+    let pending = this.pending.get(path29);
     if (!pending) {
       pending = {
         events: [],
         timer: null,
         lastEvent: now
       };
-      this.pending.set(path28, pending);
+      this.pending.set(path29, pending);
     }
     pending.events.push(event);
     pending.lastEvent = now;
-    console.error(`[flywheel] QUEUE: pushed ${type} for ${path28}, pending=${this.pending.size}`);
+    console.error(`[flywheel] QUEUE: pushed ${type} for ${path29}, pending=${this.pending.size}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
     }
     pending.timer = setTimeout(() => {
-      this.flushPath(path28);
+      this.flushPath(path29);
     }, this.config.debounceMs);
     if (this.pending.size >= this.config.batchSize) {
       this.flush();
@@ -2399,10 +2897,10 @@ var EventQueue = class {
   /**
    * Flush a single path's events
    */
-  flushPath(path28) {
-    const pending = this.pending.get(path28);
+  flushPath(path29) {
+    const pending = this.pending.get(path29);
     if (!pending || pending.events.length === 0) return;
-    console.error(`[flywheel] QUEUE: flushing ${path28}, events=${pending.events.length}`);
+    console.error(`[flywheel] QUEUE: flushing ${path29}, events=${pending.events.length}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -2411,7 +2909,7 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path28,
+        path: path29,
         originalEvents: [...pending.events]
       };
       this.onBatch({
@@ -2419,7 +2917,7 @@ var EventQueue = class {
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path28);
+    this.pending.delete(path29);
   }
   /**
    * Flush all pending events
@@ -2431,7 +2929,7 @@ var EventQueue = class {
     }
     if (this.pending.size === 0) return;
     const events = [];
-    for (const [path28, pending] of this.pending) {
+    for (const [path29, pending] of this.pending) {
       if (pending.timer) {
         clearTimeout(pending.timer);
       }
@@ -2439,7 +2937,7 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path28,
+          path: path29,
           originalEvents: [...pending.events]
         });
       }
@@ -2588,31 +3086,31 @@ function createVaultWatcher(options) {
         usePolling: config.usePolling,
         interval: config.usePolling ? config.pollInterval : void 0
       });
-      watcher.on("add", (path28) => {
-        console.error(`[flywheel] RAW EVENT: add ${path28}`);
-        if (shouldWatch(path28, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: add ${path28}`);
-          eventQueue.push("add", path28);
+      watcher.on("add", (path29) => {
+        console.error(`[flywheel] RAW EVENT: add ${path29}`);
+        if (shouldWatch(path29, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: add ${path29}`);
+          eventQueue.push("add", path29);
         } else {
-          console.error(`[flywheel] FILTERED: add ${path28}`);
+          console.error(`[flywheel] FILTERED: add ${path29}`);
         }
       });
-      watcher.on("change", (path28) => {
-        console.error(`[flywheel] RAW EVENT: change ${path28}`);
-        if (shouldWatch(path28, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: change ${path28}`);
-          eventQueue.push("change", path28);
+      watcher.on("change", (path29) => {
+        console.error(`[flywheel] RAW EVENT: change ${path29}`);
+        if (shouldWatch(path29, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: change ${path29}`);
+          eventQueue.push("change", path29);
         } else {
-          console.error(`[flywheel] FILTERED: change ${path28}`);
+          console.error(`[flywheel] FILTERED: change ${path29}`);
         }
       });
-      watcher.on("unlink", (path28) => {
-        console.error(`[flywheel] RAW EVENT: unlink ${path28}`);
-        if (shouldWatch(path28, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: unlink ${path28}`);
-          eventQueue.push("unlink", path28);
+      watcher.on("unlink", (path29) => {
+        console.error(`[flywheel] RAW EVENT: unlink ${path29}`);
+        if (shouldWatch(path29, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: unlink ${path29}`);
+          eventQueue.push("unlink", path29);
         } else {
-          console.error(`[flywheel] FILTERED: unlink ${path28}`);
+          console.error(`[flywheel] FILTERED: unlink ${path29}`);
         }
       });
       watcher.on("ready", () => {
@@ -2902,10 +3400,10 @@ function getAllFeedbackBoosts(stateDb2, folder) {
   for (const row of globalRows) {
     let accuracy;
     let sampleCount;
-    const fs28 = folderStats?.get(row.entity);
-    if (fs28 && fs28.count >= FEEDBACK_BOOST_MIN_SAMPLES) {
-      accuracy = fs28.accuracy;
-      sampleCount = fs28.count;
+    const fs29 = folderStats?.get(row.entity);
+    if (fs29 && fs29.count >= FEEDBACK_BOOST_MIN_SAMPLES) {
+      accuracy = fs29.accuracy;
+      sampleCount = fs29.count;
     } else {
       accuracy = row.correct_count / row.total;
       sampleCount = row.total;
@@ -2961,8 +3459,8 @@ function processImplicitFeedback(stateDb2, notePath, currentContent) {
 
 // src/core/write/git.ts
 import { simpleGit, CheckRepoActions } from "simple-git";
-import path5 from "path";
-import fs5 from "fs/promises";
+import path6 from "path";
+import fs6 from "fs/promises";
 import {
   setWriteState,
   getWriteState,
@@ -3015,9 +3513,9 @@ function clearLastMutationCommit() {
   }
 }
 async function checkGitLock(vaultPath2) {
-  const lockPath = path5.join(vaultPath2, ".git/index.lock");
+  const lockPath = path6.join(vaultPath2, ".git/index.lock");
   try {
-    const stat3 = await fs5.stat(lockPath);
+    const stat3 = await fs6.stat(lockPath);
     const ageMs = Date.now() - stat3.mtimeMs;
     return {
       locked: true,
@@ -3038,9 +3536,9 @@ async function isGitRepo(vaultPath2) {
   }
 }
 async function checkLockFile(vaultPath2) {
-  const lockPath = path5.join(vaultPath2, ".git/index.lock");
+  const lockPath = path6.join(vaultPath2, ".git/index.lock");
   try {
-    const stat3 = await fs5.stat(lockPath);
+    const stat3 = await fs6.stat(lockPath);
     const ageMs = Date.now() - stat3.mtimeMs;
     return { stale: ageMs > STALE_LOCK_THRESHOLD_MS, ageMs };
   } catch {
@@ -3088,7 +3586,7 @@ async function commitChange(vaultPath2, filePath, messagePrefix, retryConfig = D
         }
       }
       await git.add(filePath);
-      const fileName = path5.basename(filePath);
+      const fileName = path6.basename(filePath);
       const commitMessage = `${messagePrefix} Update ${fileName}`;
       const result = await git.commit(commitMessage);
       if (result.commit) {
@@ -3282,7 +3780,7 @@ function setHintsStateDb(stateDb2) {
 
 // src/core/shared/recency.ts
 import { readdir, readFile, stat } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 import {
   getEntityName,
   recordEntityMention,
@@ -3304,9 +3802,9 @@ async function* walkMarkdownFiles(dir, baseDir) {
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path6.join(dir, entry.name);
-      const relativePath = path6.relative(baseDir, fullPath);
-      const topFolder = relativePath.split(path6.sep)[0];
+      const fullPath = path7.join(dir, entry.name);
+      const relativePath = path7.relative(baseDir, fullPath);
+      const topFolder = relativePath.split(path7.sep)[0];
       if (EXCLUDED_FOLDERS.has(topFolder)) {
         continue;
       }
@@ -4184,7 +4682,7 @@ function tokenize(text) {
 
 // src/core/shared/cooccurrence.ts
 import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 var DEFAULT_MIN_COOCCURRENCE = 2;
 var EXCLUDED_FOLDERS2 = /* @__PURE__ */ new Set([
   "templates",
@@ -4218,9 +4716,9 @@ async function* walkMarkdownFiles2(dir, baseDir) {
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path7.join(dir, entry.name);
-      const relativePath = path7.relative(baseDir, fullPath);
-      const topFolder = relativePath.split(path7.sep)[0];
+      const fullPath = path8.join(dir, entry.name);
+      const relativePath = path8.relative(baseDir, fullPath);
+      const topFolder = relativePath.split(path8.sep)[0];
       if (EXCLUDED_FOLDERS2.has(topFolder)) {
         continue;
       }
@@ -4674,6 +5172,8 @@ var HUB_TIERS = [
   { threshold: 5, boost: 1 }
   // Small hubs
 ];
+var SEMANTIC_MIN_SIMILARITY = 0.3;
+var SEMANTIC_MAX_BOOST = 12;
 function getCrossFolderBoost(entityPath, notePath) {
   if (!entityPath || !notePath) return 0;
   const entityFolder = entityPath.split("/")[0];
@@ -4797,7 +5297,7 @@ function scoreEntity(entity, contentTokens, contentStems, config) {
   }
   return score;
 }
-function suggestRelatedLinks(content, options = {}) {
+async function suggestRelatedLinks(content, options = {}) {
   const {
     maxSuggestions = 3,
     excludeLinked = true,
@@ -4944,6 +5444,62 @@ function suggestRelatedLinks(content, options = {}) {
       }
     }
   }
+  if (content.length >= 20 && hasEntityEmbeddingsIndex()) {
+    try {
+      const contentEmbedding = await embedTextCached(content);
+      const alreadyScoredNames = new Set(scoredEntities.map((e) => e.name));
+      const semanticStrictnessMultiplier = strictness === "conservative" ? 0.6 : strictness === "aggressive" ? 1.3 : 1;
+      const semanticMatches = findSemanticallySimilarEntities(
+        contentEmbedding,
+        (maxSuggestions || 3) * 3,
+        linkedEntities
+      );
+      for (const match of semanticMatches) {
+        if (match.similarity < SEMANTIC_MIN_SIMILARITY) continue;
+        const boost = match.similarity * SEMANTIC_MAX_BOOST * semanticStrictnessMultiplier;
+        const existing = scoredEntities.find((e) => e.name === match.entityName);
+        if (existing) {
+          existing.score += boost;
+          existing.breakdown.semanticBoost = boost;
+        } else if (!linkedEntities.has(match.entityName.toLowerCase())) {
+          const entityWithType = entitiesWithTypes.find(
+            (et) => et.entity.name === match.entityName
+          );
+          if (!entityWithType) continue;
+          if (match.entityName.length > MAX_ENTITY_LENGTH) continue;
+          if (isLikelyArticleTitle(match.entityName)) continue;
+          const { entity, category } = entityWithType;
+          const layerTypeBoost = TYPE_BOOST[category] || 0;
+          const layerContextBoost = contextBoosts[category] || 0;
+          const layerHubBoost = getHubBoost(entity);
+          const layerCrossFolderBoost = notePath && entity.path ? getCrossFolderBoost(entity.path, notePath) : 0;
+          const layerFeedbackAdj = feedbackBoosts.get(match.entityName) ?? 0;
+          const totalScore = boost + layerTypeBoost + layerContextBoost + layerHubBoost + layerCrossFolderBoost + layerFeedbackAdj;
+          if (totalScore >= adaptiveMinScore) {
+            scoredEntities.push({
+              name: match.entityName,
+              path: entity.path || "",
+              score: totalScore,
+              category,
+              breakdown: {
+                contentMatch: 0,
+                cooccurrenceBoost: 0,
+                typeBoost: layerTypeBoost,
+                contextBoost: layerContextBoost,
+                recencyBoost: 0,
+                crossFolderBoost: layerCrossFolderBoost,
+                hubBoost: layerHubBoost,
+                feedbackAdjustment: layerFeedbackAdj,
+                semanticBoost: boost
+              }
+            });
+            entitiesWithContentMatch.add(match.entityName);
+          }
+        }
+      }
+    } catch {
+    }
+  }
   const relevantEntities = scoredEntities.filter(
     (e) => entitiesWithContentMatch.has(e.name)
   );
@@ -5082,7 +5638,7 @@ function inferCategoryFromName(name) {
   }
   return void 0;
 }
-function checkPreflightSimilarity(noteName) {
+async function checkPreflightSimilarity(noteName) {
   const result = { similarEntities: [] };
   if (!moduleStateDb4) return result;
   const exact = getEntityByName(moduleStateDb4, noteName);
@@ -5093,10 +5649,12 @@ function checkPreflightSimilarity(noteName) {
       category: exact.category
     };
   }
+  const ftsNames = /* @__PURE__ */ new Set();
   try {
     const searchResults = searchEntitiesDb(moduleStateDb4, noteName, 5);
     for (const sr of searchResults) {
       if (sr.name.toLowerCase() === noteName.toLowerCase()) continue;
+      ftsNames.add(sr.name.toLowerCase());
       result.similarEntities.push({
         name: sr.name,
         path: sr.path,
@@ -5106,6 +5664,27 @@ function checkPreflightSimilarity(noteName) {
     }
   } catch {
   }
+  try {
+    if (hasEntityEmbeddingsIndex()) {
+      const titleEmbedding = await embedTextCached(noteName);
+      const semanticMatches = findSemanticallySimilarEntities(titleEmbedding, 5);
+      for (const match of semanticMatches) {
+        if (match.similarity < 0.85) continue;
+        if (match.entityName.toLowerCase() === noteName.toLowerCase()) continue;
+        if (ftsNames.has(match.entityName.toLowerCase())) continue;
+        const entity = getEntityByName(moduleStateDb4, match.entityName);
+        if (entity) {
+          result.similarEntities.push({
+            name: entity.name,
+            path: entity.path,
+            category: entity.category,
+            rank: match.similarity
+          });
+        }
+      }
+    }
+  } catch {
+  }
   return result;
 }
 
@@ -5131,8 +5710,8 @@ async function flushLogs() {
 }
 
 // src/core/read/fts5.ts
-import * as fs6 from "fs";
-var EXCLUDED_DIRS2 = /* @__PURE__ */ new Set([
+import * as fs7 from "fs";
+var EXCLUDED_DIRS3 = /* @__PURE__ */ new Set([
   ".obsidian",
   ".trash",
   ".git",
@@ -5143,7 +5722,7 @@ var EXCLUDED_DIRS2 = /* @__PURE__ */ new Set([
 ]);
 var MAX_INDEX_FILE_SIZE = 5 * 1024 * 1024;
 var STALE_THRESHOLD_MS = 60 * 60 * 1e3;
-var db = null;
+var db2 = null;
 var state = {
   ready: false,
   lastBuilt: null,
@@ -5151,14 +5730,14 @@ var state = {
   error: null
 };
 function setFTS5Database(database) {
-  db = database;
+  db2 = database;
   try {
-    const row = db.prepare(
+    const row = db2.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();
+      const countRow = db2.prepare("SELECT COUNT(*) as count FROM notes_fts").get();
       state = {
         ready: countRow.count > 0,
         lastBuilt,
@@ -5169,31 +5748,31 @@ function setFTS5Database(database) {
   } catch {
   }
 }
-function shouldIndexFile(filePath) {
+function shouldIndexFile2(filePath) {
   const parts = filePath.split("/");
-  return !parts.some((part) => EXCLUDED_DIRS2.has(part));
+  return !parts.some((part) => EXCLUDED_DIRS3.has(part));
 }
 async function buildFTS5Index(vaultPath2) {
   try {
     state.error = null;
-    if (!db) {
+    if (!db2) {
       throw new Error("FTS5 database not initialized. Call setFTS5Database() first.");
     }
-    db.exec("DELETE FROM notes_fts");
+    db2.exec("DELETE FROM notes_fts");
     const files = await scanVault(vaultPath2);
-    const indexableFiles = files.filter((f) => shouldIndexFile(f.path));
-    const insert = db.prepare(
+    const indexableFiles = files.filter((f) => shouldIndexFile2(f.path));
+    const insert = db2.prepare(
       "INSERT INTO notes_fts (path, title, content) VALUES (?, ?, ?)"
     );
-    const insertMany = db.transaction((filesToIndex) => {
+    const insertMany = db2.transaction((filesToIndex) => {
       let indexed2 = 0;
       for (const file of filesToIndex) {
         try {
-          const stats = fs6.statSync(file.absolutePath);
+          const stats = fs7.statSync(file.absolutePath);
           if (stats.size > MAX_INDEX_FILE_SIZE) {
             continue;
           }
-          const content = fs6.readFileSync(file.absolutePath, "utf-8");
+          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++;
@@ -5205,296 +5784,79 @@ async function buildFTS5Index(vaultPath2) {
     });
     const indexed = insertMany(indexableFiles);
     const now = /* @__PURE__ */ new Date();
-    db.prepare(
+    db2.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/core/read/embeddings.ts
-import * as crypto from "crypto";
-import * as fs7 from "fs";
-var MODEL_ID = "Xenova/all-MiniLM-L6-v2";
-var EXCLUDED_DIRS3 = /* @__PURE__ */ new Set([
-  ".obsidian",
-  ".trash",
-  ".git",
-  "node_modules",
-  "templates",
-  ".claude",
-  ".flywheel"
-]);
-var MAX_FILE_SIZE2 = 5 * 1024 * 1024;
-var db2 = null;
-var pipeline = null;
-var initPromise = null;
-function setEmbeddingsDatabase(database) {
-  db2 = database;
-}
-async function initEmbeddings() {
-  if (pipeline) return;
-  if (initPromise) return initPromise;
-  initPromise = (async () => {
-    try {
-      const transformers = await Function("specifier", "return import(specifier)")("@huggingface/transformers");
-      pipeline = await transformers.pipeline("feature-extraction", MODEL_ID, {
-        dtype: "fp32"
-      });
-    } catch (err) {
-      initPromise = null;
-      if (err instanceof Error && (err.message.includes("Cannot find package") || err.message.includes("MODULE_NOT_FOUND") || err.message.includes("Cannot find module") || err.message.includes("ERR_MODULE_NOT_FOUND"))) {
-        throw new Error(
-          "Semantic search requires @huggingface/transformers. Install it with: npm install @huggingface/transformers"
-        );
-      }
-      throw err;
-    }
-  })();
-  return initPromise;
-}
-async function embedText(text) {
-  await initEmbeddings();
-  const truncated = text.slice(0, 2e3);
-  const result = await pipeline(truncated, { pooling: "mean", normalize: true });
-  return new Float32Array(result.data);
-}
-function contentHash(content) {
-  return crypto.createHash("md5").update(content).digest("hex");
-}
-function shouldIndexFile2(filePath) {
-  const parts = filePath.split("/");
-  return !parts.some((part) => EXCLUDED_DIRS3.has(part));
-}
-async function buildEmbeddingsIndex(vaultPath2, onProgress) {
-  if (!db2) {
-    throw new Error("Embeddings database not initialized. Call setEmbeddingsDatabase() first.");
-  }
-  await initEmbeddings();
-  const files = await scanVault(vaultPath2);
-  const indexable = files.filter((f) => shouldIndexFile2(f.path));
-  const existingHashes = /* @__PURE__ */ new Map();
-  const rows = db2.prepare("SELECT path, content_hash FROM note_embeddings").all();
-  for (const row of rows) {
-    existingHashes.set(row.path, row.content_hash);
-  }
-  const upsert = db2.prepare(`
-    INSERT OR REPLACE INTO note_embeddings (path, embedding, content_hash, model, updated_at)
-    VALUES (?, ?, ?, ?, ?)
-  `);
-  const progress = { total: indexable.length, current: 0, skipped: 0 };
-  for (const file of indexable) {
-    progress.current++;
-    try {
-      const stats = fs7.statSync(file.absolutePath);
-      if (stats.size > MAX_FILE_SIZE2) {
-        progress.skipped++;
-        continue;
-      }
-      const content = fs7.readFileSync(file.absolutePath, "utf-8");
-      const hash = contentHash(content);
-      if (existingHashes.get(file.path) === hash) {
-        progress.skipped++;
-        if (onProgress) onProgress(progress);
-        continue;
-      }
-      const embedding = await embedText(content);
-      const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
-      upsert.run(file.path, buf, hash, MODEL_ID, Date.now());
-    } catch {
-      progress.skipped++;
-    }
-    if (onProgress) onProgress(progress);
-  }
-  const currentPaths = new Set(indexable.map((f) => f.path));
-  const deleteStmt = db2.prepare("DELETE FROM note_embeddings WHERE path = ?");
-  for (const existingPath of existingHashes.keys()) {
-    if (!currentPaths.has(existingPath)) {
-      deleteStmt.run(existingPath);
-    }
-  }
-  console.error(`[Semantic] Indexed ${progress.current - progress.skipped} notes, skipped ${progress.skipped}`);
-  return progress;
-}
-async function updateEmbedding(notePath, absolutePath) {
-  if (!db2) return;
-  try {
-    const content = fs7.readFileSync(absolutePath, "utf-8");
-    const hash = contentHash(content);
-    const existing = db2.prepare("SELECT content_hash FROM note_embeddings WHERE path = ?").get(notePath);
-    if (existing?.content_hash === hash) return;
-    const embedding = await embedText(content);
-    const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
-    db2.prepare(`
-      INSERT OR REPLACE INTO note_embeddings (path, embedding, content_hash, model, updated_at)
-      VALUES (?, ?, ?, ?, ?)
-    `).run(notePath, buf, hash, MODEL_ID, Date.now());
-  } catch {
-  }
-}
-function removeEmbedding(notePath) {
-  if (!db2) return;
-  db2.prepare("DELETE FROM note_embeddings WHERE path = ?").run(notePath);
-}
-function cosineSimilarity(a, b) {
-  let dot = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const denom = Math.sqrt(normA) * Math.sqrt(normB);
-  if (denom === 0) return 0;
-  return dot / denom;
-}
-async function semanticSearch(query, limit = 10) {
-  if (!db2) {
-    throw new Error("Embeddings database not initialized. Call setEmbeddingsDatabase() first.");
-  }
-  const queryEmbedding = await embedText(query);
-  const rows = db2.prepare("SELECT path, embedding FROM note_embeddings").all();
-  const scored = [];
-  for (const row of rows) {
-    const noteEmbedding = new Float32Array(
-      row.embedding.buffer,
-      row.embedding.byteOffset,
-      row.embedding.byteLength / Float32Array.BYTES_PER_ELEMENT
-    );
-    const score = cosineSimilarity(queryEmbedding, noteEmbedding);
-    const title = row.path.replace(/\.md$/, "").split("/").pop() || row.path;
-    scored.push({ path: row.path, title, score: Math.round(score * 1e3) / 1e3 });
+      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;
   }
-  scored.sort((a, b) => b.score - a.score);
-  return scored.slice(0, limit);
 }
-async function findSemanticallySimilar(sourcePath, limit = 10, excludePaths) {
+function isIndexStale(_vaultPath) {
   if (!db2) {
-    throw new Error("Embeddings database not initialized. Call setEmbeddingsDatabase() first.");
-  }
-  const sourceRow = db2.prepare("SELECT embedding FROM note_embeddings WHERE path = ?").get(sourcePath);
-  if (!sourceRow) {
-    return [];
-  }
-  const sourceEmbedding = new Float32Array(
-    sourceRow.embedding.buffer,
-    sourceRow.embedding.byteOffset,
-    sourceRow.embedding.byteLength / Float32Array.BYTES_PER_ELEMENT
-  );
-  const rows = db2.prepare("SELECT path, embedding FROM note_embeddings WHERE path != ?").all(sourcePath);
-  const scored = [];
-  for (const row of rows) {
-    if (excludePaths?.has(row.path)) continue;
-    const noteEmbedding = new Float32Array(
-      row.embedding.buffer,
-      row.embedding.byteOffset,
-      row.embedding.byteLength / Float32Array.BYTES_PER_ELEMENT
-    );
-    const score = cosineSimilarity(sourceEmbedding, noteEmbedding);
-    const title = row.path.replace(/\.md$/, "").split("/").pop() || row.path;
-    scored.push({ path: row.path, title, score: Math.round(score * 1e3) / 1e3 });
-  }
-  scored.sort((a, b) => b.score - a.score);
-  return scored.slice(0, limit);
-}
-function reciprocalRankFusion(...lists) {
-  const k = 60;
-  const scores = /* @__PURE__ */ new Map();
-  for (const list of lists) {
-    for (let rank = 0; rank < list.length; rank++) {
-      const item = list[rank];
-      const rrfScore = 1 / (k + rank + 1);
-      scores.set(item.path, (scores.get(item.path) || 0) + rrfScore);
-    }
+    return true;
   }
-  return scores;
-}
-function hasEmbeddingsIndex() {
-  if (!db2) return false;
   try {
-    const row = db2.prepare("SELECT COUNT(*) as count FROM note_embeddings").get();
-    return row.count > 0;
+    const row = db2.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 false;
+    return true;
   }
 }
-function getEmbeddingsCount() {
-  if (!db2) return 0;
+function searchFTS5(_vaultPath, query, limit = 10) {
+  if (!db2) {
+    throw new Error("FTS5 database not initialized. Call setFTS5Database() first.");
+  }
   try {
-    const row = db2.prepare("SELECT COUNT(*) as count FROM note_embeddings").get();
-    return row.count;
-  } catch {
-    return 0;
+    const stmt = db2.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, getSessionId } from "@velvetmonkey/vault-core";
+import { openStateDb, scanVaultEntities as scanVaultEntities3, getSessionId, getAllEntitiesFromDb as getAllEntitiesFromDb2 } from "@velvetmonkey/vault-core";
 
 // src/tools/read/graph.ts
 import * as fs8 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 import { z } from "zod";
 
 // src/core/read/constants.ts
@@ -5778,7 +6140,7 @@ function requireIndex() {
 // src/tools/read/graph.ts
 async function getContext(vaultPath2, sourcePath, line, contextLines = 1) {
   try {
-    const fullPath = path8.join(vaultPath2, sourcePath);
+    const fullPath = path9.join(vaultPath2, sourcePath);
     const content = await fs8.promises.readFile(fullPath, "utf-8");
     const lines = content.split("\n");
     const startLine = Math.max(0, line - 1 - contextLines);
@@ -6046,7 +6408,7 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
         suggestions: matches
       };
       if (detail) {
-        const scored = suggestRelatedLinks(text, {
+        const scored = await suggestRelatedLinks(text, {
           detail: true,
           maxSuggestions: limit,
           strictness: "balanced"
@@ -6082,14 +6444,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path28] of entities) {
+    for (const [name, path29] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path28;
+        return path29;
       }
     }
-    for (const [name, path28] of entities) {
+    for (const [name, path29] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path28;
+        return path29;
       }
     }
     return void 0;
@@ -6665,8 +7027,8 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       daily_counts: z3.record(z3.number())
     }).describe("Activity summary for the last 7 days")
   };
-  function isPeriodicNote(path28) {
-    const filename = path28.split("/").pop() || "";
+  function isPeriodicNote(path29) {
+    const filename = path29.split("/").pop() || "";
     const nameWithoutExt = filename.replace(/\.md$/, "");
     const patterns = [
       /^\d{4}-\d{2}-\d{2}$/,
@@ -6681,7 +7043,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       // YYYY (yearly)
     ];
     const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
-    const folder = path28.split("/")[0]?.toLowerCase() || "";
+    const folder = path29.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   server2.registerTool(
@@ -7007,7 +7369,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
 
 // src/tools/read/system.ts
 import * as fs10 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 import { z as z5 } from "zod";
 import { scanVaultEntities as scanVaultEntities2 } from "@velvetmonkey/vault-core";
 function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfig, getStateDb) {
@@ -7240,7 +7602,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
           continue;
         }
         try {
-          const fullPath = path9.join(vaultPath2, note.path);
+          const fullPath = path10.join(vaultPath2, note.path);
           const content = await fs10.promises.readFile(fullPath, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
@@ -7356,7 +7718,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
       let wordCount;
       if (include_word_count) {
         try {
-          const fullPath = path9.join(vaultPath2, resolvedPath);
+          const fullPath = path10.join(vaultPath2, resolvedPath);
           const content = await fs10.promises.readFile(fullPath, "utf-8");
           wordCount = content.split(/\s+/).filter((w) => w.length > 0).length;
         } catch {
@@ -7460,7 +7822,7 @@ import { z as z6 } from "zod";
 
 // src/tools/read/structure.ts
 import * as fs11 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 var HEADING_REGEX = /^(#{1,6})\s+(.+)$/;
 function extractHeadings(content) {
   const lines = content.split("\n");
@@ -7514,7 +7876,7 @@ function buildSections(headings, totalLines) {
 async function getNoteStructure(index, notePath, vaultPath2) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path10.join(vaultPath2, notePath);
+  const absolutePath = path11.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs11.promises.readFile(absolutePath, "utf-8");
@@ -7537,7 +7899,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 = path10.join(vaultPath2, notePath);
+  const absolutePath = path11.join(vaultPath2, notePath);
   let content;
   try {
     content = await fs11.promises.readFile(absolutePath, "utf-8");
@@ -7579,7 +7941,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 = path10.join(vaultPath2, note.path);
+    const absolutePath = path11.join(vaultPath2, note.path);
     let content;
     try {
       content = await fs11.promises.readFile(absolutePath, "utf-8");
@@ -7603,7 +7965,7 @@ async function findSections(index, headingPattern, vaultPath2, folder) {
 
 // src/tools/read/tasks.ts
 import * as fs12 from "fs";
-import * as path11 from "path";
+import * as path12 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/;
@@ -7672,7 +8034,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 = path11.join(vaultPath2, note.path);
+    const absolutePath = path12.join(vaultPath2, note.path);
     const tasks = await extractTasksFromNote(note.path, absolutePath);
     allTasks.push(...tasks);
   }
@@ -7703,7 +8065,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 = path11.join(vaultPath2, notePath);
+  const absolutePath = path12.join(vaultPath2, notePath);
   let tasks = await extractTasksFromNote(notePath, absolutePath);
   if (excludeTags.length > 0) {
     tasks = tasks.filter(
@@ -7734,18 +8096,18 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         include_content: z6.boolean().default(false).describe("Include the text content under each top-level section")
       }
     },
-    async ({ path: path28, include_content }) => {
+    async ({ path: path29, include_content }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path28, vaultPath2);
+      const result = await getNoteStructure(index, path29, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path28 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path29 }, null, 2) }]
         };
       }
       if (include_content) {
         for (const section of result.sections) {
-          const sectionResult = await getSectionContent(index, path28, section.heading.text, vaultPath2, true);
+          const sectionResult = await getSectionContent(index, path29, section.heading.text, vaultPath2, true);
           if (sectionResult) {
             section.content = sectionResult.content;
           }
@@ -7767,15 +8129,15 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         include_subheadings: z6.boolean().default(true).describe("Include content under subheadings")
       }
     },
-    async ({ path: path28, heading, include_subheadings }) => {
+    async ({ path: path29, heading, include_subheadings }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path28, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path29, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path28,
+            path: path29,
             heading
           }, null, 2) }]
         };
@@ -7829,16 +8191,16 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         offset: z6.coerce.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path28, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
+    async ({ path: path29, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
       const limit = Math.min(requestedLimit ?? 25, MAX_LIMIT);
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const config = getConfig();
-      if (path28) {
-        const result2 = await getTasksFromNote(index, path28, vaultPath2, config.exclude_task_tags || []);
+      if (path29) {
+        const result2 = await getTasksFromNote(index, path29, vaultPath2, config.exclude_task_tags || []);
         if (!result2) {
           return {
-            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path28 }, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path29 }, null, 2) }]
           };
         }
         let filtered = result2;
@@ -7848,7 +8210,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         const paged2 = filtered.slice(offset, offset + limit);
         return {
           content: [{ type: "text", text: JSON.stringify({
-            path: path28,
+            path: path29,
             total_count: filtered.length,
             returned_count: paged2.length,
             open: result2.filter((t) => t.status === "open").length,
@@ -7964,7 +8326,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
 // src/tools/read/migrations.ts
 import { z as z7 } from "zod";
 import * as fs13 from "fs/promises";
-import * as path12 from "path";
+import * as path13 from "path";
 import matter2 from "gray-matter";
 function getNotesInFolder(index, folder) {
   const notes = [];
@@ -7977,7 +8339,7 @@ function getNotesInFolder(index, folder) {
   return notes;
 }
 async function readFileContent(notePath, vaultPath2) {
-  const fullPath = path12.join(vaultPath2, notePath);
+  const fullPath = path13.join(vaultPath2, notePath);
   try {
     return await fs13.readFile(fullPath, "utf-8");
   } catch {
@@ -7985,7 +8347,7 @@ async function readFileContent(notePath, vaultPath2) {
   }
 }
 async function writeFileContent(notePath, vaultPath2, content) {
-  const fullPath = path12.join(vaultPath2, notePath);
+  const fullPath = path13.join(vaultPath2, notePath);
   try {
     await fs13.writeFile(fullPath, content, "utf-8");
     return true;
@@ -8166,7 +8528,7 @@ function registerMigrationTools(server2, getIndex, getVaultPath) {
 
 // src/tools/read/graphAnalysis.ts
 import fs14 from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 import { z as z8 } from "zod";
 
 // src/tools/read/schema.ts
@@ -8725,9 +9087,9 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb)
     "graph_analysis",
     {
       title: "Graph Analysis",
-      description: 'Analyze vault link graph structure. Use analysis to pick the mode:\n- "orphans": Notes with no backlinks (disconnected content)\n- "dead_ends": Notes with backlinks but no outgoing links\n- "sources": Notes with outgoing links but no backlinks\n- "hubs": Highly connected notes (many links to/from)\n- "stale": Important notes (by backlink count) not recently modified\n- "immature": Notes scored by maturity (word count, links, frontmatter completeness, backlinks)\n- "evolution": Graph topology metrics over time (avg_degree, cluster_count, etc.)\n- "emerging_hubs": Entities growing fastest in connection count\n\nExample: graph_analysis({ analysis: "hubs", limit: 10 })\nExample: graph_analysis({ analysis: "stale", days: 30, min_backlinks: 3 })\nExample: graph_analysis({ analysis: "immature", folder: "projects", limit: 20 })\nExample: graph_analysis({ analysis: "evolution", days: 30 })\nExample: graph_analysis({ analysis: "emerging_hubs", days: 30 })',
+      description: 'Analyze vault link graph structure. Use analysis to pick the mode:\n- "orphans": Notes with no backlinks (disconnected content)\n- "dead_ends": Notes with backlinks but no outgoing links\n- "sources": Notes with outgoing links but no backlinks\n- "hubs": Highly connected notes (many links to/from)\n- "stale": Important notes (by backlink count) not recently modified\n- "immature": Notes scored by maturity (word count, links, frontmatter completeness, backlinks)\n- "evolution": Graph topology metrics over time (avg_degree, cluster_count, etc.)\n- "emerging_hubs": Entities growing fastest in connection count\n- "semantic_clusters": Group notes by embedding similarity (requires init_semantic)\n- "semantic_bridges": Find semantically similar but unlinked notes (highest-value link suggestions)\n\nExample: graph_analysis({ analysis: "hubs", limit: 10 })\nExample: graph_analysis({ analysis: "stale", days: 30, min_backlinks: 3 })\nExample: graph_analysis({ analysis: "immature", folder: "projects", limit: 20 })\nExample: graph_analysis({ analysis: "evolution", days: 30 })\nExample: graph_analysis({ analysis: "emerging_hubs", days: 30 })\nExample: graph_analysis({ analysis: "semantic_clusters", limit: 20 })\nExample: graph_analysis({ analysis: "semantic_bridges", limit: 20 })',
       inputSchema: {
-        analysis: z8.enum(["orphans", "dead_ends", "sources", "hubs", "stale", "immature", "evolution", "emerging_hubs"]).describe("Type of graph analysis to perform"),
+        analysis: z8.enum(["orphans", "dead_ends", "sources", "hubs", "stale", "immature", "evolution", "emerging_hubs", "semantic_clusters", "semantic_bridges"]).describe("Type of graph analysis to perform"),
         folder: z8.string().optional().describe("Limit to notes in this folder (orphans, dead_ends, sources)"),
         min_links: z8.coerce.number().default(5).describe("Minimum total connections for hubs"),
         min_backlinks: z8.coerce.number().default(1).describe("Minimum backlinks (dead_ends, stale)"),
@@ -8835,7 +9197,7 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb)
           const scored = allNotes.map((note) => {
             let wordCount = 0;
             try {
-              const content = fs14.readFileSync(path13.join(vaultPath2, note.path), "utf-8");
+              const content = fs14.readFileSync(path14.join(vaultPath2, note.path), "utf-8");
               const body = content.replace(/^---[\s\S]*?---\n?/, "");
               wordCount = body.split(/\s+/).filter((w) => w.length > 0).length;
             } catch {
@@ -8922,6 +9284,128 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb)
             }, null, 2) }]
           };
         }
+        case "semantic_clusters": {
+          if (!hasEmbeddingsIndex()) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({
+                error: "Note embeddings not available. Run init_semantic first."
+              }, null, 2) }]
+            };
+          }
+          const embeddings = loadAllNoteEmbeddings();
+          const CLUSTER_THRESHOLD = 0.6;
+          const unassigned = new Set(embeddings.keys());
+          const clusters = [];
+          while (unassigned.size > 0) {
+            const seedPath = unassigned.values().next().value;
+            unassigned.delete(seedPath);
+            const seedEmb = embeddings.get(seedPath);
+            const clusterNotes = [
+              { path: seedPath, title: seedPath.replace(/\.md$/, "").split("/").pop() || seedPath }
+            ];
+            for (const candidatePath of [...unassigned]) {
+              const candidateEmb = embeddings.get(candidatePath);
+              const sim = cosineSimilarity(seedEmb, candidateEmb);
+              if (sim >= CLUSTER_THRESHOLD) {
+                unassigned.delete(candidatePath);
+                clusterNotes.push({
+                  path: candidatePath,
+                  title: candidatePath.replace(/\.md$/, "").split("/").pop() || candidatePath
+                });
+              }
+            }
+            if (clusterNotes.length >= 2) {
+              const commonPrefix = clusterNotes[0].path.split("/").slice(0, -1).join("/");
+              const label = commonPrefix || clusterNotes[0].title;
+              clusters.push({ label, notes: clusterNotes });
+            }
+          }
+          clusters.sort((a, b) => b.notes.length - a.notes.length);
+          const paginated = clusters.slice(offset, offset + limit);
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              analysis: "semantic_clusters",
+              total_clusters: clusters.length,
+              returned_count: paginated.length,
+              clusters: paginated.map((c) => ({
+                label: c.label,
+                note_count: c.notes.length,
+                notes: c.notes
+              }))
+            }, null, 2) }]
+          };
+        }
+        case "semantic_bridges": {
+          if (!hasEmbeddingsIndex()) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({
+                error: "Note embeddings not available. Run init_semantic first."
+              }, null, 2) }]
+            };
+          }
+          const embeddings = loadAllNoteEmbeddings();
+          const BRIDGE_SIM_THRESHOLD = 0.5;
+          const linkedPairs = /* @__PURE__ */ new Set();
+          for (const note of index.notes.values()) {
+            for (const link of note.outlinks) {
+              const targetPath = resolveTarget(index, link.target);
+              if (targetPath) {
+                linkedPairs.add(`${note.path}|${targetPath}`);
+                linkedPairs.add(`${targetPath}|${note.path}`);
+              }
+            }
+          }
+          const twoHopConnected = (pathA, pathB) => {
+            if (linkedPairs.has(`${pathA}|${pathB}`)) return true;
+            const noteA = index.notes.get(pathA);
+            const noteB = index.notes.get(pathB);
+            if (!noteA || !noteB) return false;
+            const neighborsA = /* @__PURE__ */ new Set();
+            for (const link of noteA.outlinks) {
+              const resolved = resolveTarget(index, link.target);
+              if (resolved) neighborsA.add(resolved);
+            }
+            const backlinksA = getBacklinksForNote(index, pathA);
+            for (const bl of backlinksA) {
+              neighborsA.add(bl.source);
+            }
+            for (const link of noteB.outlinks) {
+              const resolved = resolveTarget(index, link.target);
+              if (resolved && neighborsA.has(resolved)) return true;
+            }
+            const backlinksB = getBacklinksForNote(index, pathB);
+            for (const bl of backlinksB) {
+              if (neighborsA.has(bl.source)) return true;
+            }
+            return false;
+          };
+          const paths = [...embeddings.keys()];
+          const bridges = [];
+          for (let i = 0; i < paths.length; i++) {
+            const embA = embeddings.get(paths[i]);
+            for (let j = i + 1; j < paths.length; j++) {
+              const sim = cosineSimilarity(embA, embeddings.get(paths[j]));
+              if (sim >= BRIDGE_SIM_THRESHOLD && !twoHopConnected(paths[i], paths[j])) {
+                bridges.push({
+                  noteA: { path: paths[i], title: paths[i].replace(/\.md$/, "").split("/").pop() || paths[i] },
+                  noteB: { path: paths[j], title: paths[j].replace(/\.md$/, "").split("/").pop() || paths[j] },
+                  similarity: Math.round(sim * 1e3) / 1e3
+                });
+              }
+            }
+          }
+          bridges.sort((a, b) => b.similarity - a.similarity);
+          const paginatedBridges = bridges.slice(offset, offset + limit);
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              analysis: "semantic_bridges",
+              total_bridges: bridges.length,
+              returned_count: paginatedBridges.length,
+              description: "Notes with high semantic similarity but no direct or 2-hop link path. These represent the highest-value missing link suggestions.",
+              bridges: paginatedBridges
+            }, null, 2) }]
+          };
+        }
       }
     }
   );
@@ -9279,13 +9763,13 @@ import { z as z10 } from "zod";
 
 // src/tools/read/bidirectional.ts
 import * as fs15 from "fs/promises";
-import * as path14 from "path";
+import * as path15 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;
 var WIKILINK_REGEX2 = /\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|[^\]]+)?\]\]/g;
 async function readFileContent2(notePath, vaultPath2) {
-  const fullPath = path14.join(vaultPath2, notePath);
+  const fullPath = path15.join(vaultPath2, notePath);
   try {
     return await fs15.readFile(fullPath, "utf-8");
   } catch {
@@ -9555,10 +10039,10 @@ async function validateCrossLayer(index, notePath, vaultPath2) {
 
 // src/tools/read/computed.ts
 import * as fs16 from "fs/promises";
-import * as path15 from "path";
+import * as path16 from "path";
 import matter4 from "gray-matter";
 async function readFileContent3(notePath, vaultPath2) {
-  const fullPath = path15.join(vaultPath2, notePath);
+  const fullPath = path16.join(vaultPath2, notePath);
   try {
     return await fs16.readFile(fullPath, "utf-8");
   } catch {
@@ -9566,7 +10050,7 @@ async function readFileContent3(notePath, vaultPath2) {
   }
 }
 async function getFileStats(notePath, vaultPath2) {
-  const fullPath = path15.join(vaultPath2, notePath);
+  const fullPath = path16.join(vaultPath2, notePath);
   try {
     const stats = await fs16.stat(fullPath);
     return {
@@ -9697,12 +10181,14 @@ async function computeFrontmatter(index, notePath, vaultPath2, fields) {
 }
 
 // src/tools/read/noteIntelligence.ts
+import fs17 from "node:fs";
+import nodePath from "node:path";
 function registerNoteIntelligenceTools(server2, getIndex, getVaultPath) {
   server2.registerTool(
     "note_intelligence",
     {
       title: "Note Intelligence",
-      description: 'Analyze a note for patterns, suggestions, and consistency. Use analysis to pick the mode:\n- "prose_patterns": Find "Key: Value" or "Key: [[wikilink]]" patterns in prose\n- "suggest_frontmatter": Suggest YAML frontmatter from detected prose patterns\n- "suggest_wikilinks": Find frontmatter values that could be wikilinks\n- "cross_layer": Check consistency between frontmatter and prose references\n- "compute": Auto-compute derived fields (word_count, link_count, etc.)\n- "all": Run all analyses and return combined result\n\nExample: note_intelligence({ path: "projects/alpha.md", analysis: "wikilinks" })\nExample: note_intelligence({ path: "projects/alpha.md", analysis: "compute", fields: ["word_count", "link_count"] })',
+      description: 'Analyze a note for patterns, suggestions, and consistency. Use analysis to pick the mode:\n- "prose_patterns": Find "Key: Value" or "Key: [[wikilink]]" patterns in prose\n- "suggest_frontmatter": Suggest YAML frontmatter from detected prose patterns\n- "suggest_wikilinks": Find frontmatter values that could be wikilinks\n- "cross_layer": Check consistency between frontmatter and prose references\n- "compute": Auto-compute derived fields (word_count, link_count, etc.)\n- "semantic_links": Find semantically related entities not currently linked in the note (requires init_semantic)\n- "all": Run all analyses and return combined result\n\nExample: note_intelligence({ path: "projects/alpha.md", analysis: "wikilinks" })\nExample: note_intelligence({ path: "projects/alpha.md", analysis: "compute", fields: ["word_count", "link_count"] })\nExample: note_intelligence({ path: "projects/alpha.md", analysis: "semantic_links" })',
       inputSchema: {
         analysis: z10.enum([
           "prose_patterns",
@@ -9710,6 +10196,7 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath) {
           "suggest_wikilinks",
           "cross_layer",
           "compute",
+          "semantic_links",
           "all"
         ]).describe("Type of note analysis to perform"),
         path: z10.string().describe("Path to the note to analyze"),
@@ -9751,6 +10238,54 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath) {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
           };
         }
+        case "semantic_links": {
+          if (!hasEntityEmbeddingsIndex()) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({
+                error: "Entity embeddings not available. Run init_semantic first."
+              }, null, 2) }]
+            };
+          }
+          let noteContent;
+          try {
+            noteContent = fs17.readFileSync(nodePath.join(vaultPath2, notePath), "utf-8");
+          } catch {
+            return {
+              content: [{ type: "text", text: JSON.stringify({
+                error: `Could not read note: ${notePath}`
+              }, null, 2) }]
+            };
+          }
+          const linkedEntities = /* @__PURE__ */ new Set();
+          const wikilinkRegex = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+          let wlMatch;
+          while ((wlMatch = wikilinkRegex.exec(noteContent)) !== null) {
+            linkedEntities.add(wlMatch[1].toLowerCase());
+          }
+          try {
+            const contentEmbedding = await embedTextCached(noteContent);
+            const matches = findSemanticallySimilarEntities(contentEmbedding, 20, linkedEntities);
+            const suggestions = matches.filter((m) => m.similarity >= 0.3).map((m) => ({
+              entity: m.entityName,
+              similarity: m.similarity
+            }));
+            return {
+              content: [{ type: "text", text: JSON.stringify({
+                path: notePath,
+                analysis: "semantic_links",
+                linked_count: linkedEntities.size,
+                suggestion_count: suggestions.length,
+                suggestions
+              }, null, 2) }]
+            };
+          } catch {
+            return {
+              content: [{ type: "text", text: JSON.stringify({
+                error: "Failed to compute semantic links"
+              }, null, 2) }]
+            };
+          }
+        }
         case "all": {
           const [prosePatterns, suggestedFrontmatter, suggestedWikilinks, crossLayer, computed] = await Promise.all([
             detectProsePatterns(index, notePath, vaultPath2),
@@ -9778,8 +10313,8 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath) {
 // src/tools/write/mutations.ts
 init_writer();
 import { z as z11 } from "zod";
-import fs19 from "fs/promises";
-import path18 from "path";
+import fs20 from "fs/promises";
+import path19 from "path";
 
 // src/core/write/validator.ts
 var TIMESTAMP_PATTERN = /^\*\*\d{2}:\d{2}\*\*/;
@@ -9981,8 +10516,8 @@ function runValidationPipeline(content, format, options = {}) {
 
 // src/core/write/mutation-helpers.ts
 init_writer();
-import fs18 from "fs/promises";
-import path17 from "path";
+import fs19 from "fs/promises";
+import path18 from "path";
 init_constants();
 init_writer();
 function formatMcpResult(result) {
@@ -10031,9 +10566,9 @@ async function handleGitCommit(vaultPath2, notePath, commit, prefix) {
   return info;
 }
 async function ensureFileExists(vaultPath2, notePath) {
-  const fullPath = path17.join(vaultPath2, notePath);
+  const fullPath = path18.join(vaultPath2, notePath);
   try {
-    await fs18.access(fullPath);
+    await fs19.access(fullPath);
     return null;
   } catch {
     return errorResult(notePath, `File not found: ${notePath}`);
@@ -10097,9 +10632,14 @@ async function withVaultFile(options, operation) {
     });
     return formatMcpResult(result);
   } catch (error) {
+    const extras = {};
+    if (error instanceof DiagnosticError) {
+      extras.diagnostic = error.diagnostic;
+    }
     const result = errorResult(
       notePath,
-      `Failed to ${actionDescription}: ${error instanceof Error ? error.message : String(error)}`
+      `Failed to ${actionDescription}: ${error instanceof Error ? error.message : String(error)}`,
+      extras
     );
     return formatMcpResult(result);
   }
@@ -10131,10 +10671,10 @@ async function withVaultFrontmatter(options, operation) {
 
 // src/tools/write/mutations.ts
 async function createNoteFromTemplate(vaultPath2, notePath, config) {
-  const fullPath = path18.join(vaultPath2, notePath);
-  await fs19.mkdir(path18.dirname(fullPath), { recursive: true });
+  const fullPath = path19.join(vaultPath2, notePath);
+  await fs20.mkdir(path19.dirname(fullPath), { recursive: true });
   const templates = config.templates || {};
-  const filename = path18.basename(notePath, ".md").toLowerCase();
+  const filename = path19.basename(notePath, ".md").toLowerCase();
   let templatePath;
   const dailyPattern = /^\d{4}-\d{2}-\d{2}/;
   const weeklyPattern = /^\d{4}-W\d{2}/;
@@ -10155,10 +10695,10 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   let templateContent;
   if (templatePath) {
     try {
-      const absTemplatePath = path18.join(vaultPath2, templatePath);
-      templateContent = await fs19.readFile(absTemplatePath, "utf-8");
+      const absTemplatePath = path19.join(vaultPath2, templatePath);
+      templateContent = await fs20.readFile(absTemplatePath, "utf-8");
     } catch {
-      const title = path18.basename(notePath, ".md");
+      const title = path19.basename(notePath, ".md");
       templateContent = `---
 ---
 
@@ -10167,7 +10707,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
       templatePath = void 0;
     }
   } else {
-    const title = path18.basename(notePath, ".md");
+    const title = path19.basename(notePath, ".md");
     templateContent = `---
 ---
 
@@ -10176,8 +10716,8 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   }
   const now = /* @__PURE__ */ new Date();
   const dateStr = now.toISOString().split("T")[0];
-  templateContent = templateContent.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, path18.basename(notePath, ".md"));
-  await fs19.writeFile(fullPath, templateContent, "utf-8");
+  templateContent = templateContent.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, path19.basename(notePath, ".md"));
+  await fs20.writeFile(fullPath, templateContent, "utf-8");
   return { created: true, templateUsed: templatePath };
 }
 function registerMutationTools(server2, vaultPath2, getConfig = () => ({})) {
@@ -10196,6 +10736,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
       commit: z11.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
       skipWikilinks: z11.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)"),
       preserveListNesting: z11.boolean().default(true).describe("Detect and preserve the indentation level of surrounding list items. Set false to disable."),
+      bumpHeadings: z11.boolean().default(true).describe("Auto-bump heading levels in inserted content so they nest under the target section (e.g., ## in a ## section becomes ###). Set false to disable."),
       suggestOutgoingLinks: z11.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]], [[Philosophy]]"). Set false to disable.'),
       maxSuggestions: z11.number().min(1).max(10).default(3).describe("Maximum number of suggested wikilinks to append (1-10, default: 3)"),
       validate: z11.boolean().default(true).describe("Check input for common issues (double timestamps, non-markdown bullets, etc.)"),
@@ -10204,13 +10745,13 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
       agent_id: z11.string().optional().describe('Agent identifier for multi-agent scoping (e.g., "claude-opus", "planning-agent")'),
       session_id: z11.string().optional().describe('Session identifier for conversation scoping (e.g., "sess-abc123")')
     },
-    async ({ path: notePath, section, content, create_if_missing, position, format, commit, skipWikilinks, preserveListNesting, suggestOutgoingLinks, maxSuggestions, validate, normalize, guardrails, agent_id, session_id }) => {
+    async ({ path: notePath, section, content, create_if_missing, position, format, commit, skipWikilinks, preserveListNesting, bumpHeadings, suggestOutgoingLinks, maxSuggestions, validate, normalize, guardrails, agent_id, session_id }) => {
       let noteCreated = false;
       let templateUsed;
       if (create_if_missing) {
-        const fullPath = path18.join(vaultPath2, notePath);
+        const fullPath = path19.join(vaultPath2, notePath);
         try {
-          await fs19.access(fullPath);
+          await fs20.access(fullPath);
         } catch {
           const config = getConfig();
           const result = await createNoteFromTemplate(vaultPath2, notePath, config);
@@ -10247,7 +10788,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
           };
           let suggestInfo;
           if (suggestOutgoingLinks && !skipWikilinks) {
-            const result = suggestRelatedLinks(processedContent, { maxSuggestions, notePath });
+            const result = await suggestRelatedLinks(processedContent, { maxSuggestions, notePath });
             if (result.suffix) {
               processedContent = processedContent + " " + result.suffix;
               suggestInfo = `Suggested: ${result.suggestions.join(", ")}`;
@@ -10259,7 +10800,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
             ctx.sectionBoundary,
             formattedContent,
             position,
-            { preserveListNesting }
+            { preserveListNesting, bumpHeadings }
           );
           const infoLines = [wikilinkInfo, suggestInfo].filter(Boolean);
           const preview = formattedContent + (infoLines.length > 0 ? `
@@ -10366,7 +10907,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
           let workingReplacement = validationResult.content;
           let { content: processedReplacement } = maybeApplyWikilinks(workingReplacement, skipWikilinks, notePath);
           if (suggestOutgoingLinks && !skipWikilinks) {
-            const result = suggestRelatedLinks(processedReplacement, { maxSuggestions, notePath });
+            const result = await suggestRelatedLinks(processedReplacement, { maxSuggestions, notePath });
             if (result.suffix) {
               processedReplacement = processedReplacement + " " + result.suffix;
             }
@@ -10380,7 +10921,20 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
             useRegex
           );
           if (replaceResult.replacedCount === 0) {
-            throw new Error(`No content matching "${search}" found in section "${ctx.sectionBoundary.name}"`);
+            const lines = ctx.content.split("\n");
+            const boundary = ctx.sectionBoundary;
+            const sectionLines = lines.slice(boundary.contentStartLine, boundary.endLine + 1);
+            const sectionContent = sectionLines.join("\n");
+            const diagnostic = buildReplaceNotFoundDiagnostic(
+              sectionContent,
+              search,
+              boundary.name,
+              boundary.contentStartLine
+            );
+            throw new DiagnosticError(
+              `No content matching "${search}" found in section "${boundary.name}"`,
+              diagnostic
+            );
           }
           const previewLines = replaceResult.originalLines.map(
             (orig, i) => `- ${orig}
@@ -10551,7 +11105,7 @@ function registerTaskTools(server2, vaultPath2) {
           let { content: processedTask, wikilinkInfo } = maybeApplyWikilinks(workingTask, skipWikilinks, notePath);
           let suggestInfo;
           if (suggestOutgoingLinks && !skipWikilinks) {
-            const result = suggestRelatedLinks(processedTask, { maxSuggestions, notePath });
+            const result = await suggestRelatedLinks(processedTask, { maxSuggestions, notePath });
             if (result.suffix) {
               processedTask = processedTask + " " + result.suffix;
               suggestInfo = `Suggested: ${result.suggestions.join(", ")}`;
@@ -10645,8 +11199,8 @@ Example: vault_update_frontmatter({ path: "projects/alpha.md", frontmatter: { st
 // src/tools/write/notes.ts
 init_writer();
 import { z as z14 } from "zod";
-import fs20 from "fs/promises";
-import path19 from "path";
+import fs21 from "fs/promises";
+import path20 from "path";
 function registerNoteTools(server2, vaultPath2, getIndex) {
   server2.tool(
     "vault_create_note",
@@ -10669,23 +11223,23 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
         if (!validatePath(vaultPath2, notePath)) {
           return formatMcpResult(errorResult(notePath, "Invalid path: path traversal not allowed"));
         }
-        const fullPath = path19.join(vaultPath2, notePath);
+        const fullPath = path20.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 = path19.dirname(fullPath);
-        await fs20.mkdir(dir, { recursive: true });
+        const dir = path20.dirname(fullPath);
+        await fs21.mkdir(dir, { recursive: true });
         let effectiveContent = content;
         let effectiveFrontmatter = frontmatter;
         if (template) {
-          const templatePath = path19.join(vaultPath2, template);
+          const templatePath = path20.join(vaultPath2, template);
           try {
-            const raw = await fs20.readFile(templatePath, "utf-8");
+            const raw = await fs21.readFile(templatePath, "utf-8");
             const matter9 = (await import("gray-matter")).default;
             const parsed = matter9(raw);
             const dateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-            const title = path19.basename(notePath, ".md");
+            const title = path20.basename(notePath, ".md");
             let templateContent = parsed.content.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, title);
             if (content) {
               templateContent = templateContent.trimEnd() + "\n\n" + content;
@@ -10697,9 +11251,9 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
           }
         }
         const warnings = [];
-        const noteName = path19.basename(notePath, ".md");
+        const noteName = path20.basename(notePath, ".md");
         const existingAliases = Array.isArray(effectiveFrontmatter?.aliases) ? effectiveFrontmatter.aliases.filter((a) => typeof a === "string") : [];
-        const preflight = checkPreflightSimilarity(noteName);
+        const preflight = await checkPreflightSimilarity(noteName);
         if (preflight.existingEntity) {
           warnings.push({
             type: "similar_note_exists",
@@ -10725,7 +11279,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
         let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(effectiveContent, skipWikilinks, notePath);
         let suggestInfo;
         if (suggestOutgoingLinks && !skipWikilinks) {
-          const result = suggestRelatedLinks(processedContent, { maxSuggestions, notePath });
+          const result = await suggestRelatedLinks(processedContent, { maxSuggestions, notePath });
           if (result.suffix) {
             processedContent = processedContent + " " + result.suffix;
             suggestInfo = `Suggested: ${result.suggestions.join(", ")}`;
@@ -10814,8 +11368,8 @@ ${sources}`;
           }
           return formatMcpResult(errorResult(notePath, previewLines.join("\n")));
         }
-        const fullPath = path19.join(vaultPath2, notePath);
-        await fs20.unlink(fullPath);
+        const fullPath = path20.join(vaultPath2, notePath);
+        await fs21.unlink(fullPath);
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Flywheel:Delete]");
         const message = backlinkWarning ? `Deleted note: ${notePath}
 
@@ -10833,8 +11387,8 @@ Warning: ${backlinkWarning}` : `Deleted note: ${notePath}`;
 // src/tools/write/move-notes.ts
 init_writer();
 import { z as z15 } from "zod";
-import fs21 from "fs/promises";
-import path20 from "path";
+import fs22 from "fs/promises";
+import path21 from "path";
 import matter6 from "gray-matter";
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -10853,16 +11407,16 @@ function extractWikilinks2(content) {
   return wikilinks;
 }
 function getTitleFromPath(filePath) {
-  return path20.basename(filePath, ".md");
+  return path21.basename(filePath, ".md");
 }
 async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   const results = [];
   const allTargets = [targetTitle, ...targetAliases].map((t) => t.toLowerCase());
   async function scanDir(dir) {
     const files = [];
-    const entries = await fs21.readdir(dir, { withFileTypes: true });
+    const entries = await fs22.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path20.join(dir, entry.name);
+      const fullPath = path21.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         files.push(...await scanDir(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -10873,8 +11427,8 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   }
   const allFiles = await scanDir(vaultPath2);
   for (const filePath of allFiles) {
-    const relativePath = path20.relative(vaultPath2, filePath);
-    const content = await fs21.readFile(filePath, "utf-8");
+    const relativePath = path21.relative(vaultPath2, filePath);
+    const content = await fs22.readFile(filePath, "utf-8");
     const wikilinks = extractWikilinks2(content);
     const matchingLinks = [];
     for (const link of wikilinks) {
@@ -10893,8 +11447,8 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   return results;
 }
 async function updateBacklinksInFile(vaultPath2, filePath, oldTitles, newTitle) {
-  const fullPath = path20.join(vaultPath2, filePath);
-  const raw = await fs21.readFile(fullPath, "utf-8");
+  const fullPath = path21.join(vaultPath2, filePath);
+  const raw = await fs22.readFile(fullPath, "utf-8");
   const parsed = matter6(raw);
   let content = parsed.content;
   let totalUpdated = 0;
@@ -10960,10 +11514,10 @@ function registerMoveNoteTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const oldFullPath = path20.join(vaultPath2, oldPath);
-        const newFullPath = path20.join(vaultPath2, newPath);
+        const oldFullPath = path21.join(vaultPath2, oldPath);
+        const newFullPath = path21.join(vaultPath2, newPath);
         try {
-          await fs21.access(oldFullPath);
+          await fs22.access(oldFullPath);
         } catch {
           const result2 = {
             success: false,
@@ -10973,7 +11527,7 @@ function registerMoveNoteTools(server2, vaultPath2) {
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
         try {
-          await fs21.access(newFullPath);
+          await fs22.access(newFullPath);
           const result2 = {
             success: false,
             message: `Destination already exists: ${newPath}`,
@@ -10982,7 +11536,7 @@ function registerMoveNoteTools(server2, vaultPath2) {
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         } catch {
         }
-        const sourceContent = await fs21.readFile(oldFullPath, "utf-8");
+        const sourceContent = await fs22.readFile(oldFullPath, "utf-8");
         const parsed = matter6(sourceContent);
         const aliases = extractAliases2(parsed.data);
         const oldTitle = getTitleFromPath(oldPath);
@@ -11011,9 +11565,9 @@ function registerMoveNoteTools(server2, vaultPath2) {
             }
           }
         }
-        const destDir = path20.dirname(newFullPath);
-        await fs21.mkdir(destDir, { recursive: true });
-        await fs21.rename(oldFullPath, newFullPath);
+        const destDir = path21.dirname(newFullPath);
+        await fs22.mkdir(destDir, { recursive: true });
+        await fs22.rename(oldFullPath, newFullPath);
         let gitCommit;
         let undoAvailable;
         let staleLockDetected;
@@ -11097,12 +11651,12 @@ function registerMoveNoteTools(server2, vaultPath2) {
         if (sanitizedTitle !== newTitle) {
           console.error(`[Flywheel] Title sanitized: "${newTitle}" \u2192 "${sanitizedTitle}"`);
         }
-        const fullPath = path20.join(vaultPath2, notePath);
-        const dir = path20.dirname(notePath);
-        const newPath = dir === "." ? `${sanitizedTitle}.md` : path20.join(dir, `${sanitizedTitle}.md`);
-        const newFullPath = path20.join(vaultPath2, newPath);
+        const fullPath = path21.join(vaultPath2, notePath);
+        const dir = path21.dirname(notePath);
+        const newPath = dir === "." ? `${sanitizedTitle}.md` : path21.join(dir, `${sanitizedTitle}.md`);
+        const newFullPath = path21.join(vaultPath2, newPath);
         try {
-          await fs21.access(fullPath);
+          await fs22.access(fullPath);
         } catch {
           const result2 = {
             success: false,
@@ -11113,7 +11667,7 @@ function registerMoveNoteTools(server2, vaultPath2) {
         }
         if (fullPath !== newFullPath) {
           try {
-            await fs21.access(newFullPath);
+            await fs22.access(newFullPath);
             const result2 = {
               success: false,
               message: `A note with this title already exists: ${newPath}`,
@@ -11123,7 +11677,7 @@ function registerMoveNoteTools(server2, vaultPath2) {
           } catch {
           }
         }
-        const sourceContent = await fs21.readFile(fullPath, "utf-8");
+        const sourceContent = await fs22.readFile(fullPath, "utf-8");
         const parsed = matter6(sourceContent);
         const aliases = extractAliases2(parsed.data);
         const oldTitle = getTitleFromPath(notePath);
@@ -11152,7 +11706,7 @@ function registerMoveNoteTools(server2, vaultPath2) {
           }
         }
         if (fullPath !== newFullPath) {
-          await fs21.rename(fullPath, newFullPath);
+          await fs22.rename(fullPath, newFullPath);
         }
         let gitCommit;
         let undoAvailable;
@@ -11325,8 +11879,8 @@ init_schema();
 
 // src/core/write/policy/parser.ts
 init_schema();
-import fs22 from "fs/promises";
-import path21 from "path";
+import fs23 from "fs/promises";
+import path22 from "path";
 import matter7 from "gray-matter";
 function parseYaml(content) {
   const parsed = matter7(`---
@@ -11351,7 +11905,7 @@ function parsePolicyString(yamlContent) {
 }
 async function loadPolicyFile(filePath) {
   try {
-    const content = await fs22.readFile(filePath, "utf-8");
+    const content = await fs23.readFile(filePath, "utf-8");
     return parsePolicyString(content);
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -11375,15 +11929,15 @@ 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 = path22.join(vaultPath2, ".claude", "policies");
+  const policyPath = path22.join(policiesDir, `${policyName}.yaml`);
   try {
-    await fs22.access(policyPath);
+    await fs23.access(policyPath);
     return loadPolicyFile(policyPath);
   } catch {
-    const ymlPath = path21.join(policiesDir, `${policyName}.yml`);
+    const ymlPath = path22.join(policiesDir, `${policyName}.yml`);
     try {
-      await fs22.access(ymlPath);
+      await fs23.access(ymlPath);
       return loadPolicyFile(ymlPath);
     } catch {
       return {
@@ -11521,8 +12075,8 @@ init_template();
 init_conditions();
 init_schema();
 init_writer();
-import fs24 from "fs/promises";
-import path23 from "path";
+import fs25 from "fs/promises";
+import path24 from "path";
 init_constants();
 async function executeStep(step, vaultPath2, context, conditionResults) {
   const { execute, reason } = shouldStepExecute(step.when, conditionResults);
@@ -11591,9 +12145,9 @@ 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 = path24.join(vaultPath2, notePath);
   try {
-    await fs24.access(fullPath);
+    await fs25.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -11631,9 +12185,9 @@ 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 = path24.join(vaultPath2, notePath);
   try {
-    await fs24.access(fullPath);
+    await fs25.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -11662,9 +12216,9 @@ 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 = path24.join(vaultPath2, notePath);
   try {
-    await fs24.access(fullPath);
+    await fs25.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -11705,16 +12259,16 @@ 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 = path24.join(vaultPath2, notePath);
   try {
-    await fs24.access(fullPath);
+    await fs25.access(fullPath);
     if (!overwrite) {
       return { success: false, message: `File already exists: ${notePath}`, path: notePath };
     }
   } catch {
   }
-  const dir = path23.dirname(fullPath);
-  await fs24.mkdir(dir, { recursive: true });
+  const dir = path24.dirname(fullPath);
+  await fs25.mkdir(dir, { recursive: true });
   const { content: processedContent } = maybeApplyWikilinks(content, skipWikilinks, notePath);
   await writeVaultFile(vaultPath2, notePath, processedContent, frontmatter);
   return {
@@ -11733,13 +12287,13 @@ 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 = path24.join(vaultPath2, notePath);
   try {
-    await fs24.access(fullPath);
+    await fs25.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
-  await fs24.unlink(fullPath);
+  await fs25.unlink(fullPath);
   return {
     success: true,
     message: `Deleted note: ${notePath}`,
@@ -11750,9 +12304,9 @@ 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 = path24.join(vaultPath2, notePath);
   try {
-    await fs24.access(fullPath);
+    await fs25.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -11793,9 +12347,9 @@ 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 = path24.join(vaultPath2, notePath);
   try {
-    await fs24.access(fullPath);
+    await fs25.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -11830,9 +12384,9 @@ 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 = path24.join(vaultPath2, notePath);
   try {
-    await fs24.access(fullPath);
+    await fs25.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -11852,9 +12406,9 @@ 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 = path24.join(vaultPath2, notePath);
   try {
-    await fs24.access(fullPath);
+    await fs25.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -12012,15 +12566,15 @@ 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 = path24.join(vaultPath2, filePath);
     if (original === null) {
       try {
-        await fs24.unlink(fullPath);
+        await fs25.unlink(fullPath);
       } catch {
       }
     } else if (original !== void 0) {
       try {
-        await fs24.writeFile(fullPath, original);
+        await fs25.writeFile(fullPath, original);
       } catch {
       }
     }
@@ -12066,27 +12620,27 @@ async function previewPolicy(policy, vaultPath2, variables) {
 }
 
 // src/core/write/policy/storage.ts
-import fs25 from "fs/promises";
-import path24 from "path";
+import fs26 from "fs/promises";
+import path25 from "path";
 function getPoliciesDir(vaultPath2) {
-  return path24.join(vaultPath2, ".claude", "policies");
+  return path25.join(vaultPath2, ".claude", "policies");
 }
 async function ensurePoliciesDir(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
-  await fs25.mkdir(dir, { recursive: true });
+  await fs26.mkdir(dir, { recursive: true });
 }
 async function listPolicies(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
   const policies = [];
   try {
-    const files = await fs25.readdir(dir);
+    const files = await fs26.readdir(dir);
     for (const file of files) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
         continue;
       }
-      const filePath = path24.join(dir, file);
-      const stat3 = await fs25.stat(filePath);
-      const content = await fs25.readFile(filePath, "utf-8");
+      const filePath = path25.join(dir, file);
+      const stat3 = await fs26.stat(filePath);
+      const content = await fs26.readFile(filePath, "utf-8");
       const metadata = extractPolicyMetadata(content);
       policies.push({
         name: metadata.name || file.replace(/\.ya?ml$/, ""),
@@ -12109,10 +12663,10 @@ 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 = path25.join(dir, filename);
   if (!overwrite) {
     try {
-      await fs25.access(filePath);
+      await fs26.access(filePath);
       return {
         success: false,
         path: filename,
@@ -12129,7 +12683,7 @@ async function writePolicyRaw(vaultPath2, policyName, content, overwrite = false
       message: `Invalid policy: ${validation.errors.map((e) => e.message).join("; ")}`
     };
   }
-  await fs25.writeFile(filePath, content, "utf-8");
+  await fs26.writeFile(filePath, content, "utf-8");
   return {
     success: true,
     path: filename,
@@ -12652,8 +13206,8 @@ function registerPolicyTools(server2, vaultPath2) {
 import { z as z19 } from "zod";
 
 // src/core/write/tagRename.ts
-import * as fs26 from "fs/promises";
-import * as path25 from "path";
+import * as fs27 from "fs/promises";
+import * as path26 from "path";
 import matter8 from "gray-matter";
 import { getProtectedZones } from "@velvetmonkey/vault-core";
 function getNotesInFolder3(index, folder) {
@@ -12759,10 +13313,10 @@ async function renameTag(index, vaultPath2, oldTag, newTag, options) {
   const previews = [];
   let totalChanges = 0;
   for (const note of affectedNotes) {
-    const fullPath = path25.join(vaultPath2, note.path);
+    const fullPath = path26.join(vaultPath2, note.path);
     let fileContent;
     try {
-      fileContent = await fs26.readFile(fullPath, "utf-8");
+      fileContent = await fs27.readFile(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -12835,7 +13389,7 @@ async function renameTag(index, vaultPath2, oldTag, newTag, options) {
       previews.push(preview);
       if (!dryRun) {
         const newContent = matter8.stringify(updatedContent, fm);
-        await fs26.writeFile(fullPath, newContent, "utf-8");
+        await fs27.writeFile(fullPath, newContent, "utf-8");
       }
     }
   }
@@ -13287,8 +13841,8 @@ function getNoteAccessFrequency(stateDb2, daysBack = 30) {
       }
     }
   }
-  return Array.from(noteMap.entries()).map(([path28, stats]) => ({
-    path: path28,
+  return Array.from(noteMap.entries()).map(([path29, stats]) => ({
+    path: path29,
     access_count: stats.access_count,
     last_accessed: stats.last_accessed,
     tools_used: Array.from(stats.tools)
@@ -13440,8 +13994,8 @@ function registerActivityTools(server2, getStateDb, getSessionId2) {
 import { z as z23 } from "zod";
 
 // src/core/read/similarity.ts
-import * as fs27 from "fs";
-import * as path26 from "path";
+import * as fs28 from "fs";
+import * as path27 from "path";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
   "be",
@@ -13578,10 +14132,10 @@ function extractKeyTerms(content, maxTerms = 15) {
 }
 function findSimilarNotes(db3, vaultPath2, index, sourcePath, options = {}) {
   const limit = options.limit ?? 10;
-  const absPath = path26.join(vaultPath2, sourcePath);
+  const absPath = path27.join(vaultPath2, sourcePath);
   let content;
   try {
-    content = fs27.readFileSync(absPath, "utf-8");
+    content = fs28.readFileSync(absPath, "utf-8");
   } catch {
     return [];
   }
@@ -13706,7 +14260,7 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
         exclude_linked: z23.boolean().optional().describe("Exclude notes already linked to/from the source note (default: true)")
       }
     },
-    async ({ path: path28, limit, exclude_linked }) => {
+    async ({ path: path29, limit, exclude_linked }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const stateDb2 = getStateDb();
@@ -13715,10 +14269,10 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
           content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
         };
       }
-      if (!index.notes.has(path28)) {
+      if (!index.notes.has(path29)) {
         return {
           content: [{ type: "text", text: JSON.stringify({
-            error: `Note not found: ${path28}`,
+            error: `Note not found: ${path29}`,
             hint: "Use the full relative path including .md extension"
           }, null, 2) }]
         };
@@ -13729,12 +14283,12 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
       };
       const useHybrid = hasEmbeddingsIndex();
       const method = useHybrid ? "hybrid" : "bm25";
-      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path28, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path28, opts);
+      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path29, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path29, opts);
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
-            source: path28,
+            source: path29,
             method,
             exclude_linked: exclude_linked ?? true,
             count: results.length,
@@ -13748,6 +14302,7 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
 
 // src/tools/read/semantic.ts
 import { z as z24 } from "zod";
+import { getAllEntitiesFromDb } from "@velvetmonkey/vault-core";
 function registerSemanticTools(server2, getVaultPath, getStateDb) {
   server2.registerTool(
     "init_semantic",
@@ -13792,6 +14347,29 @@ function registerSemanticTools(server2, getVaultPath, getStateDb) {
         }
       });
       const embedded = progress.total - progress.skipped;
+      let entityEmbedded = 0;
+      try {
+        const allEntities = getAllEntitiesFromDb(stateDb2);
+        const entityMap = /* @__PURE__ */ new Map();
+        for (const e of allEntities) {
+          entityMap.set(e.name, {
+            name: e.name,
+            path: e.path,
+            category: e.category,
+            aliases: e.aliases
+          });
+        }
+        if (entityMap.size > 0) {
+          entityEmbedded = await buildEntityEmbeddingsIndex(vaultPath2, entityMap, (done, total) => {
+            if (done % 50 === 0 || done === total) {
+              console.error(`[Semantic] Entity embedding ${done}/${total}...`);
+            }
+          });
+          loadEntityEmbeddingsToMemory();
+        }
+      } catch (err) {
+        console.error("[Semantic] Entity embeddings failed:", err instanceof Error ? err.message : err);
+      }
       return {
         content: [{
           type: "text",
@@ -13800,6 +14378,8 @@ function registerSemanticTools(server2, getVaultPath, getStateDb) {
             embedded,
             skipped: progress.skipped,
             total: progress.total,
+            entity_embeddings: entityEmbedded,
+            entity_total: getEntityEmbeddingsCount(),
             hint: "Embeddings built. All searches now automatically use hybrid ranking."
           }, null, 2)
         }]
@@ -14181,6 +14761,7 @@ async function main() {
     console.error("[Memory] StateDb initialized");
     setFTS5Database(stateDb.db);
     setEmbeddingsDatabase(stateDb.db);
+    loadEntityEmbeddingsToMemory();
     setWriteStateDb(stateDb);
     await initializeEntityIndex(vaultPath);
   } catch (err) {
@@ -14368,13 +14949,31 @@ async function runPostIndexWork(index) {
                 if (event.type === "delete") {
                   removeEmbedding(event.path);
                 } else if (event.path.endsWith(".md")) {
-                  const absPath = path27.join(vaultPath, event.path);
+                  const absPath = path28.join(vaultPath, event.path);
                   await updateEmbedding(event.path, absPath);
                 }
               } catch {
               }
             }
           }
+          if (hasEntityEmbeddingsIndex() && stateDb) {
+            try {
+              const allEntities = getAllEntitiesFromDb2(stateDb);
+              for (const event of batch.events) {
+                if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+                const matching = allEntities.filter((e) => e.path === event.path);
+                for (const entity of matching) {
+                  await updateEntityEmbedding(entity.name, {
+                    name: entity.name,
+                    path: entity.path,
+                    category: entity.category,
+                    aliases: entity.aliases
+                  }, vaultPath);
+                }
+              }
+            } catch {
+            }
+          }
           if (stateDb) {
             try {
               saveVaultIndexToCache(stateDb, vaultIndex);