@velvetmonkey/flywheel-memory 2.0.44 → 2.0.45

package/dist/index.js

@@ -836,8 +836,8 @@ function createContext(variables = {}) {
     steps: {}
   };
 }
-function resolvePath(obj, path32) {
-  const parts = path32.split(".");
+function resolvePath(obj, path33) {
+  const parts = path33.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === void 0 || current === null) {
@@ -1552,10 +1552,10 @@ var init_taskHelpers = __esm({
 });
 
 // src/index.ts
-import * as path31 from "path";
+import * as path32 from "path";
 import { readFileSync as readFileSync4, realpathSync } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname4, join as join16 } from "path";
+import { dirname as dirname4, join as join17 } from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -2216,8 +2216,8 @@ function updateIndexProgress(parsed, total) {
 function normalizeTarget(target) {
   return target.toLowerCase().replace(/\.md$/, "");
 }
-function normalizeNotePath(path32) {
-  return path32.toLowerCase().replace(/\.md$/, "");
+function normalizeNotePath(path33) {
+  return path33.toLowerCase().replace(/\.md$/, "");
 }
 async function buildVaultIndex(vaultPath2, options = {}) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
@@ -2386,7 +2386,7 @@ function findSimilarEntity(index, target) {
   }
   const maxDist = normalizedLen <= 10 ? 1 : 2;
   let bestMatch;
-  for (const [entity, path32] of index.entities) {
+  for (const [entity, path33] of index.entities) {
     const lenDiff = Math.abs(entity.length - normalizedLen);
     if (lenDiff > maxDist) {
       continue;
@@ -2394,7 +2394,7 @@ function findSimilarEntity(index, target) {
     const dist = levenshteinDistance(normalized, entity);
     if (dist > 0 && dist <= maxDist) {
       if (!bestMatch || dist < bestMatch.distance) {
-        bestMatch = { path: path32, entity, distance: dist };
+        bestMatch = { path: path33, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -2783,8 +2783,8 @@ function normalizePath(filePath) {
   return normalized;
 }
 function getRelativePath(vaultPath2, filePath) {
-  const relative2 = path5.relative(vaultPath2, filePath);
-  return normalizePath(relative2);
+  const relative3 = path5.relative(vaultPath2, filePath);
+  return normalizePath(relative3);
 }
 function shouldWatch(filePath, vaultPath2) {
   const normalized = normalizePath(filePath);
@@ -2913,30 +2913,30 @@ var EventQueue = class {
    * Add a new event to the queue
    */
   push(type, rawPath) {
-    const path32 = normalizePath(rawPath);
+    const path33 = normalizePath(rawPath);
     const now = Date.now();
     const event = {
       type,
-      path: path32,
+      path: path33,
       timestamp: now
     };
-    let pending = this.pending.get(path32);
+    let pending = this.pending.get(path33);
     if (!pending) {
       pending = {
         events: [],
         timer: null,
         lastEvent: now
       };
-      this.pending.set(path32, pending);
+      this.pending.set(path33, pending);
     }
     pending.events.push(event);
     pending.lastEvent = now;
-    console.error(`[flywheel] QUEUE: pushed ${type} for ${path32}, pending=${this.pending.size}`);
+    console.error(`[flywheel] QUEUE: pushed ${type} for ${path33}, pending=${this.pending.size}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
     }
     pending.timer = setTimeout(() => {
-      this.flushPath(path32);
+      this.flushPath(path33);
     }, this.config.debounceMs);
     if (this.pending.size >= this.config.batchSize) {
       this.flush();
@@ -2957,10 +2957,10 @@ var EventQueue = class {
   /**
    * Flush a single path's events
    */
-  flushPath(path32) {
-    const pending = this.pending.get(path32);
+  flushPath(path33) {
+    const pending = this.pending.get(path33);
     if (!pending || pending.events.length === 0) return;
-    console.error(`[flywheel] QUEUE: flushing ${path32}, events=${pending.events.length}`);
+    console.error(`[flywheel] QUEUE: flushing ${path33}, events=${pending.events.length}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -2969,7 +2969,7 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path32,
+        path: path33,
         originalEvents: [...pending.events]
       };
       this.onBatch({
@@ -2978,7 +2978,7 @@ var EventQueue = class {
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path32);
+    this.pending.delete(path33);
   }
   /**
    * Flush all pending events
@@ -2990,7 +2990,7 @@ var EventQueue = class {
     }
     if (this.pending.size === 0) return;
     const events = [];
-    for (const [path32, pending] of this.pending) {
+    for (const [path33, pending] of this.pending) {
       if (pending.timer) {
         clearTimeout(pending.timer);
       }
@@ -2998,7 +2998,7 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path32,
+          path: path33,
           originalEvents: [...pending.events]
         });
       }
@@ -3168,8 +3168,8 @@ async function upsertNote(index, vaultPath2, notePath) {
       removeNoteFromIndex(index, notePath);
     }
     const fullPath = path7.join(vaultPath2, notePath);
-    const fs31 = await import("fs/promises");
-    const stats = await fs31.stat(fullPath);
+    const fs32 = await import("fs/promises");
+    const stats = await fs32.stat(fullPath);
     const vaultFile = {
       path: notePath,
       absolutePath: fullPath,
@@ -3351,31 +3351,31 @@ function createVaultWatcher(options) {
         usePolling: config.usePolling,
         interval: config.usePolling ? config.pollInterval : void 0
       });
-      watcher.on("add", (path32) => {
-        console.error(`[flywheel] RAW EVENT: add ${path32}`);
-        if (shouldWatch(path32, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: add ${path32}`);
-          eventQueue.push("add", path32);
+      watcher.on("add", (path33) => {
+        console.error(`[flywheel] RAW EVENT: add ${path33}`);
+        if (shouldWatch(path33, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: add ${path33}`);
+          eventQueue.push("add", path33);
         } else {
-          console.error(`[flywheel] FILTERED: add ${path32}`);
+          console.error(`[flywheel] FILTERED: add ${path33}`);
         }
       });
-      watcher.on("change", (path32) => {
-        console.error(`[flywheel] RAW EVENT: change ${path32}`);
-        if (shouldWatch(path32, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: change ${path32}`);
-          eventQueue.push("change", path32);
+      watcher.on("change", (path33) => {
+        console.error(`[flywheel] RAW EVENT: change ${path33}`);
+        if (shouldWatch(path33, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: change ${path33}`);
+          eventQueue.push("change", path33);
         } else {
-          console.error(`[flywheel] FILTERED: change ${path32}`);
+          console.error(`[flywheel] FILTERED: change ${path33}`);
         }
       });
-      watcher.on("unlink", (path32) => {
-        console.error(`[flywheel] RAW EVENT: unlink ${path32}`);
-        if (shouldWatch(path32, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: unlink ${path32}`);
-          eventQueue.push("unlink", path32);
+      watcher.on("unlink", (path33) => {
+        console.error(`[flywheel] RAW EVENT: unlink ${path33}`);
+        if (shouldWatch(path33, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: unlink ${path33}`);
+          eventQueue.push("unlink", path33);
         } else {
-          console.error(`[flywheel] FILTERED: unlink ${path32}`);
+          console.error(`[flywheel] FILTERED: unlink ${path33}`);
         }
       });
       watcher.on("ready", () => {
@@ -3681,10 +3681,10 @@ function getAllFeedbackBoosts(stateDb2, folder) {
   for (const row of globalRows) {
     let accuracy;
     let sampleCount;
-    const fs31 = folderStats?.get(row.entity);
-    if (fs31 && fs31.count >= FEEDBACK_BOOST_MIN_SAMPLES) {
-      accuracy = fs31.accuracy;
-      sampleCount = fs31.count;
+    const fs32 = folderStats?.get(row.entity);
+    if (fs32 && fs32.count >= FEEDBACK_BOOST_MIN_SAMPLES) {
+      accuracy = fs32.accuracy;
+      sampleCount = fs32.count;
     } else {
       accuracy = row.correct_count / row.total;
       sampleCount = row.total;
@@ -7898,14 +7898,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path32] of entities) {
+    for (const [name, path33] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path32;
+        return path33;
       }
     }
-    for (const [name, path32] of entities) {
+    for (const [name, path33] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path32;
+        return path33;
       }
     }
     return void 0;
@@ -8882,8 +8882,8 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       daily_counts: z3.record(z3.number())
     }).describe("Activity summary for the last 7 days")
   };
-  function isPeriodicNote2(path32) {
-    const filename = path32.split("/").pop() || "";
+  function isPeriodicNote2(path33) {
+    const filename = path33.split("/").pop() || "";
     const nameWithoutExt = filename.replace(/\.md$/, "");
     const patterns = [
       /^\d{4}-\d{2}-\d{2}$/,
@@ -8898,7 +8898,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       // YYYY (yearly)
     ];
     const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
-    const folder = path32.split("/")[0]?.toLowerCase() || "";
+    const folder = path33.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   server2.registerTool(
@@ -10150,18 +10150,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: path32, include_content }) => {
+    async ({ path: path33, include_content }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path32, vaultPath2);
+      const result = await getNoteStructure(index, path33, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path32 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path33 }, null, 2) }]
         };
       }
       if (include_content) {
         for (const section of result.sections) {
-          const sectionResult = await getSectionContent(index, path32, section.heading.text, vaultPath2, true);
+          const sectionResult = await getSectionContent(index, path33, section.heading.text, vaultPath2, true);
           if (sectionResult) {
             section.content = sectionResult.content;
           }
@@ -10183,15 +10183,15 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         include_subheadings: z6.boolean().default(true).describe("Include content under subheadings")
       }
     },
-    async ({ path: path32, heading, include_subheadings }) => {
+    async ({ path: path33, heading, include_subheadings }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path32, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path33, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path32,
+            path: path33,
             heading
           }, null, 2) }]
         };
@@ -10245,16 +10245,16 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         offset: z6.coerce.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path32, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
+    async ({ path: path33, 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 (path32) {
-        const result2 = await getTasksFromNote(index, path32, vaultPath2, config.exclude_task_tags || []);
+      if (path33) {
+        const result2 = await getTasksFromNote(index, path33, vaultPath2, config.exclude_task_tags || []);
         if (!result2) {
           return {
-            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path32 }, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path33 }, null, 2) }]
           };
         }
         let filtered = result2;
@@ -10264,7 +10264,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         const paged2 = filtered.slice(offset, offset + limit);
         return {
           content: [{ type: "text", text: JSON.stringify({
-            path: path32,
+            path: path33,
             total_count: filtered.length,
             returned_count: paged2.length,
             open: result2.filter((t) => t.status === "open").length,
@@ -16040,8 +16040,160 @@ function registerConfigTools(server2, getConfig, setConfig, getStateDb) {
   );
 }
 
-// src/tools/read/metrics.ts
+// src/tools/write/enrich.ts
 import { z as z23 } from "zod";
+import * as fs29 from "fs/promises";
+import * as path30 from "path";
+function hasSkipWikilinks(content) {
+  if (!content.startsWith("---")) return false;
+  const endIndex = content.indexOf("\n---", 3);
+  if (endIndex === -1) return false;
+  const frontmatter = content.substring(4, endIndex);
+  return /^skipWikilinks:\s*true\s*$/m.test(frontmatter);
+}
+async function collectMarkdownFiles(dirPath, basePath, excludeFolders) {
+  const results = [];
+  try {
+    const entries = await fs29.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const fullPath = path30.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        if (excludeFolders.some((f) => entry.name.toLowerCase() === f.toLowerCase())) continue;
+        const sub = await collectMarkdownFiles(fullPath, basePath, excludeFolders);
+        results.push(...sub);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        results.push(path30.relative(basePath, fullPath));
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+var EXCLUDE_FOLDERS = [
+  "daily-notes",
+  "daily",
+  "weekly",
+  "weekly-notes",
+  "monthly",
+  "monthly-notes",
+  "quarterly",
+  "yearly-notes",
+  "periodic",
+  "journal",
+  "inbox",
+  "templates",
+  "attachments",
+  "tmp",
+  "clippings",
+  "readwise",
+  "articles",
+  "bookmarks",
+  "web-clips"
+];
+function registerInitTools(server2, vaultPath2, getStateDb) {
+  server2.tool(
+    "vault_init",
+    "Initialize vault for Flywheel \u2014 scans legacy notes with zero wikilinks and applies entity links. Safe to re-run (idempotent). Use dry_run (default) to preview.",
+    {
+      dry_run: z23.boolean().default(true).describe("If true (default), preview what would be linked without modifying files"),
+      batch_size: z23.number().default(50).describe("Maximum notes to process per invocation (default: 50)"),
+      offset: z23.number().default(0).describe("Skip this many eligible notes (for pagination across invocations)")
+    },
+    async ({ dry_run, batch_size, offset }) => {
+      const startTime = Date.now();
+      const stateDb2 = getStateDb();
+      const lastRunRow = stateDb2?.getMetadataValue.get("vault_init_last_run_at");
+      const totalEnrichedRow = stateDb2?.getMetadataValue.get("vault_init_total_enriched");
+      const previousTotal = totalEnrichedRow ? parseInt(totalEnrichedRow.value, 10) : 0;
+      checkAndRefreshIfStale();
+      if (!isEntityIndexReady()) {
+        const result = {
+          success: false,
+          mode: dry_run ? "dry_run" : "apply",
+          notes_scanned: 0,
+          notes_with_matches: 0,
+          notes_skipped: 0,
+          total_matches: 0,
+          preview: [],
+          duration_ms: Date.now() - startTime,
+          last_run_at: lastRunRow?.value ?? null,
+          total_enriched: previousTotal
+        };
+        return { content: [{ type: "text", text: JSON.stringify({ ...result, error: "Entity index not ready" }, null, 2) }] };
+      }
+      const allFiles = await collectMarkdownFiles(vaultPath2, vaultPath2, EXCLUDE_FOLDERS);
+      const eligible = [];
+      let notesSkipped = 0;
+      for (const relativePath of allFiles) {
+        const fullPath = path30.join(vaultPath2, relativePath);
+        let content;
+        try {
+          content = await fs29.readFile(fullPath, "utf-8");
+        } catch {
+          continue;
+        }
+        if (hasSkipWikilinks(content)) {
+          notesSkipped++;
+          continue;
+        }
+        const existingLinks = extractLinkedEntities(content);
+        if (existingLinks.size > 0) continue;
+        eligible.push({ relativePath, content });
+      }
+      const paged = eligible.slice(offset, offset + batch_size);
+      const preview = [];
+      let totalMatches = 0;
+      let notesModified = 0;
+      for (const { relativePath, content } of paged) {
+        const result = processWikilinks(content, relativePath);
+        if (result.linksAdded === 0) continue;
+        const entities = result.linkedEntities;
+        totalMatches += result.linksAdded;
+        preview.push({
+          note: relativePath,
+          entities,
+          match_count: result.linksAdded
+        });
+        if (!dry_run) {
+          const fullPath = path30.join(vaultPath2, relativePath);
+          await fs29.writeFile(fullPath, result.content, "utf-8");
+          notesModified++;
+          if (stateDb2) {
+            trackWikilinkApplications(stateDb2, relativePath, entities);
+            const newLinks = extractLinkedEntities(result.content);
+            updateStoredNoteLinks(stateDb2, relativePath, newLinks);
+          }
+        }
+      }
+      if (!dry_run && stateDb2 && notesModified > 0) {
+        const newTotal = previousTotal + notesModified;
+        stateDb2.setMetadataValue.run("vault_init_last_run_at", (/* @__PURE__ */ new Date()).toISOString());
+        stateDb2.setMetadataValue.run("vault_init_total_enriched", String(newTotal));
+      }
+      const currentLastRun = !dry_run && notesModified > 0 ? (/* @__PURE__ */ new Date()).toISOString() : lastRunRow?.value ?? null;
+      const currentTotal = !dry_run ? previousTotal + notesModified : previousTotal;
+      const output = {
+        success: true,
+        mode: dry_run ? "dry_run" : "apply",
+        notes_scanned: allFiles.length,
+        notes_with_matches: preview.length,
+        notes_skipped: notesSkipped,
+        total_matches: totalMatches,
+        ...dry_run ? {} : { notes_modified: notesModified },
+        preview: preview.slice(0, 20),
+        // Cap preview to 20 items in output
+        duration_ms: Date.now() - startTime,
+        last_run_at: currentLastRun,
+        total_enriched: currentTotal
+      };
+      return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+    }
+  );
+}
+
+// src/tools/read/metrics.ts
+import { z as z24 } from "zod";
 
 // src/core/shared/metrics.ts
 var ALL_METRICS = [
@@ -16207,10 +16359,10 @@ function registerMetricsTools(server2, getIndex, getStateDb) {
       title: "Vault Growth",
       description: 'Track vault growth over time. Modes: "current" (live snapshot), "history" (time series), "trends" (deltas vs N days ago), "index_activity" (rebuild history). Tracks 11 metrics: note_count, link_count, orphan_count, tag_count, entity_count, avg_links_per_note, link_density, connected_ratio, wikilink_accuracy, wikilink_feedback_volume, wikilink_suppressed_count.',
       inputSchema: {
-        mode: z23.enum(["current", "history", "trends", "index_activity"]).describe("Query mode: current snapshot, historical time series, trend analysis, or index rebuild activity"),
-        metric: z23.string().optional().describe('Filter to specific metric (e.g., "note_count"). Omit for all metrics.'),
-        days_back: z23.number().optional().describe("Number of days to look back for history/trends (default: 30)"),
-        limit: z23.number().optional().describe("Number of recent events to return for index_activity mode (default: 20)")
+        mode: z24.enum(["current", "history", "trends", "index_activity"]).describe("Query mode: current snapshot, historical time series, trend analysis, or index rebuild activity"),
+        metric: z24.string().optional().describe('Filter to specific metric (e.g., "note_count"). Omit for all metrics.'),
+        days_back: z24.number().optional().describe("Number of days to look back for history/trends (default: 30)"),
+        limit: z24.number().optional().describe("Number of recent events to return for index_activity mode (default: 20)")
       }
     },
     async ({ mode, metric, days_back, limit: eventLimit }) => {
@@ -16283,7 +16435,7 @@ function registerMetricsTools(server2, getIndex, getStateDb) {
 }
 
 // src/tools/read/activity.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // src/core/shared/toolTracking.ts
 function recordToolInvocation(stateDb2, event) {
@@ -16363,8 +16515,8 @@ function getNoteAccessFrequency(stateDb2, daysBack = 30) {
       }
     }
   }
-  return Array.from(noteMap.entries()).map(([path32, stats]) => ({
-    path: path32,
+  return Array.from(noteMap.entries()).map(([path33, stats]) => ({
+    path: path33,
     access_count: stats.access_count,
     last_accessed: stats.last_accessed,
     tools_used: Array.from(stats.tools)
@@ -16443,10 +16595,10 @@ function registerActivityTools(server2, getStateDb, getSessionId2) {
       title: "Vault Activity",
       description: 'Track tool usage patterns and session activity. Modes:\n- "session": Current session summary (tools called, notes accessed)\n- "sessions": List of recent sessions\n- "note_access": Notes ranked by query frequency\n- "tool_usage": Tool usage patterns (most-used tools, avg duration)',
       inputSchema: {
-        mode: z24.enum(["session", "sessions", "note_access", "tool_usage"]).describe("Activity query mode"),
-        session_id: z24.string().optional().describe("Specific session ID (for session mode, defaults to current)"),
-        days_back: z24.number().optional().describe("Number of days to look back (default: 30)"),
-        limit: z24.number().optional().describe("Maximum results to return (default: 20)")
+        mode: z25.enum(["session", "sessions", "note_access", "tool_usage"]).describe("Activity query mode"),
+        session_id: z25.string().optional().describe("Specific session ID (for session mode, defaults to current)"),
+        days_back: z25.number().optional().describe("Number of days to look back (default: 30)"),
+        limit: z25.number().optional().describe("Maximum results to return (default: 20)")
       }
     },
     async ({ mode, session_id, days_back, limit: resultLimit }) => {
@@ -16513,11 +16665,11 @@ function registerActivityTools(server2, getStateDb, getSessionId2) {
 }
 
 // src/tools/read/similarity.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // src/core/read/similarity.ts
-import * as fs29 from "fs";
-import * as path30 from "path";
+import * as fs30 from "fs";
+import * as path31 from "path";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
   "be",
@@ -16654,10 +16806,10 @@ function extractKeyTerms(content, maxTerms = 15) {
 }
 function findSimilarNotes(db4, vaultPath2, index, sourcePath, options = {}) {
   const limit = options.limit ?? 10;
-  const absPath = path30.join(vaultPath2, sourcePath);
+  const absPath = path31.join(vaultPath2, sourcePath);
   let content;
   try {
-    content = fs29.readFileSync(absPath, "utf-8");
+    content = fs30.readFileSync(absPath, "utf-8");
   } catch {
     return [];
   }
@@ -16777,12 +16929,12 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
       title: "Find Similar Notes",
       description: "Find notes similar to a given note using FTS5 keyword matching. When embeddings have been built (via init_semantic), automatically uses hybrid ranking (BM25 + embedding similarity via Reciprocal Rank Fusion). Use exclude_linked to filter out notes already connected via wikilinks.",
       inputSchema: {
-        path: z25.string().describe('Path to the source note (relative to vault root, e.g. "projects/alpha.md")'),
-        limit: z25.number().optional().describe("Maximum number of similar notes to return (default: 10)"),
-        exclude_linked: z25.boolean().optional().describe("Exclude notes already linked to/from the source note (default: true)")
+        path: z26.string().describe('Path to the source note (relative to vault root, e.g. "projects/alpha.md")'),
+        limit: z26.number().optional().describe("Maximum number of similar notes to return (default: 10)"),
+        exclude_linked: z26.boolean().optional().describe("Exclude notes already linked to/from the source note (default: true)")
       }
     },
-    async ({ path: path32, limit, exclude_linked }) => {
+    async ({ path: path33, limit, exclude_linked }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const stateDb2 = getStateDb();
@@ -16791,10 +16943,10 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
           content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
         };
       }
-      if (!index.notes.has(path32)) {
+      if (!index.notes.has(path33)) {
         return {
           content: [{ type: "text", text: JSON.stringify({
-            error: `Note not found: ${path32}`,
+            error: `Note not found: ${path33}`,
             hint: "Use the full relative path including .md extension"
           }, null, 2) }]
         };
@@ -16805,12 +16957,12 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
       };
       const useHybrid = hasEmbeddingsIndex();
       const method = useHybrid ? "hybrid" : "bm25";
-      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path32, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path32, opts);
+      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path33, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path33, opts);
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
-            source: path32,
+            source: path33,
             method,
             exclude_linked: exclude_linked ?? true,
             count: results.length,
@@ -16823,7 +16975,7 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
 }
 
 // src/tools/read/semantic.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 import { getAllEntitiesFromDb } from "@velvetmonkey/vault-core";
 function registerSemanticTools(server2, getVaultPath, getStateDb) {
   server2.registerTool(
@@ -16832,7 +16984,7 @@ function registerSemanticTools(server2, getVaultPath, getStateDb) {
       title: "Initialize Semantic Search",
       description: "Download the embedding model and build semantic search index for this vault. After running, search and find_similar automatically use hybrid ranking (BM25 + semantic). Run once per vault \u2014 subsequent calls skip already-embedded notes unless force=true.",
       inputSchema: {
-        force: z26.boolean().optional().describe(
+        force: z27.boolean().optional().describe(
           "Rebuild all embeddings even if they already exist (default: false)"
         )
       }
@@ -16912,7 +17064,7 @@ function registerSemanticTools(server2, getVaultPath, getStateDb) {
 
 // src/tools/read/merges.ts
 init_levenshtein();
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 import { getAllEntitiesFromDb as getAllEntitiesFromDb2, getDismissedMergePairs, recordMergeDismissal } from "@velvetmonkey/vault-core";
 function normalizeName(name) {
   return name.toLowerCase().replace(/[.\-_]/g, "").replace(/js$/, "").replace(/ts$/, "");
@@ -16922,7 +17074,7 @@ function registerMergeTools2(server2, getStateDb) {
     "suggest_entity_merges",
     "Find potential duplicate entities that could be merged based on name similarity",
     {
-      limit: z27.number().optional().default(50).describe("Maximum number of suggestions to return")
+      limit: z28.number().optional().default(50).describe("Maximum number of suggestions to return")
     },
     async ({ limit }) => {
       const stateDb2 = getStateDb();
@@ -17024,11 +17176,11 @@ function registerMergeTools2(server2, getStateDb) {
     "dismiss_merge_suggestion",
     "Permanently dismiss a merge suggestion so it never reappears",
     {
-      source_path: z27.string().describe("Path of the source entity"),
-      target_path: z27.string().describe("Path of the target entity"),
-      source_name: z27.string().describe("Name of the source entity"),
-      target_name: z27.string().describe("Name of the target entity"),
-      reason: z27.string().describe("Original suggestion reason")
+      source_path: z28.string().describe("Path of the source entity"),
+      target_path: z28.string().describe("Path of the target entity"),
+      source_name: z28.string().describe("Name of the source entity"),
+      target_name: z28.string().describe("Name of the target entity"),
+      reason: z28.string().describe("Original suggestion reason")
     },
     async ({ source_path, target_path, source_name, target_name, reason }) => {
       const stateDb2 = getStateDb();
@@ -17047,7 +17199,7 @@ function registerMergeTools2(server2, getStateDb) {
 }
 
 // src/index.ts
-import * as fs30 from "node:fs/promises";
+import * as fs31 from "node:fs/promises";
 import { createHash as createHash2 } from "node:crypto";
 
 // src/resources/vault.ts
@@ -17156,7 +17308,7 @@ function registerVaultResources(server2, getIndex) {
 // src/index.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname4(__filename);
-var pkg = JSON.parse(readFileSync4(join16(__dirname, "../package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync4(join17(__dirname, "../package.json"), "utf-8"));
 var vaultPath = process.env.PROJECT_PATH || process.env.VAULT_PATH || findVaultRoot();
 var resolvedVaultPath;
 try {
@@ -17423,6 +17575,7 @@ registerSystemTools2(server, vaultPath);
 registerPolicyTools(server, vaultPath);
 registerTagTools(server, () => vaultIndex, () => vaultPath);
 registerWikilinkFeedbackTools(server, () => stateDb);
+registerInitTools(server, vaultPath, () => stateDb);
 registerConfigTools(
   server,
   () => flywheelConfig,
@@ -17460,6 +17613,10 @@ async function main() {
     setWriteStateDb(stateDb);
     setRecencyStateDb(stateDb);
     setEdgeWeightStateDb(stateDb);
+    const vaultInitRow = stateDb.getMetadataValue.get("vault_init_last_run_at");
+    if (!vaultInitRow) {
+      serverLog("server", "Vault not initialized \u2014 call vault_init to enrich legacy notes");
+    }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     serverLog("statedb", `StateDb initialization failed: ${msg}`, "error");
@@ -17577,22 +17734,22 @@ async function buildStartupCatchupBatch(vaultPath2, sinceMs) {
   async function scanDir(dir) {
     let entries;
     try {
-      entries = await fs30.readdir(dir, { withFileTypes: true });
+      entries = await fs31.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path31.join(dir, entry.name);
+      const fullPath = path32.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
         await scanDir(fullPath);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
         try {
-          const stat4 = await fs30.stat(fullPath);
+          const stat4 = await fs31.stat(fullPath);
           if (stat4.mtimeMs > sinceMs) {
             events.push({
               type: "upsert",
-              path: path31.relative(vaultPath2, fullPath),
+              path: path32.relative(vaultPath2, fullPath),
               originalEvents: []
             });
           }
@@ -17717,8 +17874,8 @@ async function runPostIndexWork(index) {
           }
         } catch {
           try {
-            const dir = path31.dirname(rawPath);
-            const base = path31.basename(rawPath);
+            const dir = path32.dirname(rawPath);
+            const base = path32.basename(rawPath);
             const resolvedDir = realpathSync(dir).replace(/\\/g, "/");
             for (const prefix of vaultPrefixes) {
               if (resolvedDir.startsWith(prefix + "/") || resolvedDir === prefix) {
@@ -17747,7 +17904,7 @@ async function runPostIndexWork(index) {
           continue;
         }
         try {
-          const content = await fs30.readFile(path31.join(vaultPath, event.path), "utf-8");
+          const content = await fs31.readFile(path32.join(vaultPath, event.path), "utf-8");
           const hash = createHash2("md5").update(content).digest("hex");
           if (lastContentHashes.get(event.path) === hash) {
             serverLog("watcher", `Hash unchanged, skipping: ${event.path}`);
@@ -17818,7 +17975,7 @@ async function runPostIndexWork(index) {
             ...batch,
             events: filteredEvents.map((e) => ({
               ...e,
-              path: path31.join(vaultPath, e.path)
+              path: path32.join(vaultPath, e.path)
             }))
           };
           const batchResult = await processBatch(vaultIndex, vaultPath, absoluteBatch);
@@ -17952,7 +18109,7 @@ async function runPostIndexWork(index) {
                 removeEmbedding(event.path);
                 embRemoved++;
               } else if (event.path.endsWith(".md")) {
-                const absPath = path31.join(vaultPath, event.path);
+                const absPath = path32.join(vaultPath, event.path);
                 await updateEmbedding(event.path, absPath);
                 embUpdated++;
               }
@@ -18159,7 +18316,7 @@ async function runPostIndexWork(index) {
         for (const event of filteredEvents) {
           if (event.type === "delete" || !event.path.endsWith(".md")) continue;
           try {
-            const content = await fs30.readFile(path31.join(vaultPath, event.path), "utf-8");
+            const content = await fs31.readFile(path32.join(vaultPath, event.path), "utf-8");
             const zones = getProtectedZones2(content);
             const linked = new Set(
               (forwardLinkResults.find((r) => r.file === event.path)?.resolved ?? []).map((n) => n.toLowerCase())
@@ -18195,7 +18352,7 @@ async function runPostIndexWork(index) {
           for (const event of filteredEvents) {
             if (event.type === "delete" || !event.path.endsWith(".md")) continue;
             try {
-              const content = await fs30.readFile(path31.join(vaultPath, event.path), "utf-8");
+              const content = await fs31.readFile(path32.join(vaultPath, event.path), "utf-8");
               const removed = processImplicitFeedback(stateDb, event.path, content);
               for (const entity of removed) feedbackResults.push({ entity, file: event.path });
             } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.44",
+  "version": "2.0.45",
   "description": "MCP server that gives Claude full read/write access to your Obsidian vault. Select from 42 tools for search, backlinks, graph queries, mutations, and hybrid semantic search.",
   "type": "module",
   "main": "dist/index.js",