@velvetmonkey/flywheel-memory 2.0.51 → 2.0.52

package/dist/index.js

@@ -1834,6 +1834,15 @@ var embeddingsBuilding = false;
 var embeddingCache = /* @__PURE__ */ new Map();
 var EMBEDDING_CACHE_MAX = 500;
 var entityEmbeddingsMap = /* @__PURE__ */ new Map();
+function getEmbeddingsBuildState() {
+  if (!db) return "none";
+  const row = db.prepare(`SELECT value FROM fts_metadata WHERE key = 'embeddings_state'`).get();
+  return row?.value || "none";
+}
+function setEmbeddingsBuildState(state2) {
+  if (!db) return;
+  db.prepare(`INSERT OR REPLACE INTO fts_metadata (key, value) VALUES ('embeddings_state', ?)`).run(state2);
+}
 function setEmbeddingsDatabase(database) {
   db = database;
 }
@@ -1887,6 +1896,7 @@ async function buildEmbeddingsIndex(vaultPath2, onProgress) {
     throw new Error("Embeddings database not initialized. Call setEmbeddingsDatabase() first.");
   }
   embeddingsBuilding = true;
+  setEmbeddingsBuildState("building_notes");
   await initEmbeddings();
   const files = await scanVault(vaultPath2);
   const indexable = files.filter((f) => shouldIndexFile(f.path));
@@ -2037,8 +2047,13 @@ function setEmbeddingsBuilding(value) {
 function hasEmbeddingsIndex() {
   if (!db) return false;
   try {
-    const row = db.prepare("SELECT COUNT(*) as count FROM note_embeddings").get();
-    return row.count > 0;
+    const state2 = getEmbeddingsBuildState();
+    if (state2 === "complete") return true;
+    if (state2 === "none") {
+      const row = db.prepare("SELECT COUNT(*) as count FROM note_embeddings").get();
+      return row.count > 0;
+    }
+    return false;
   } catch {
     return false;
   }
@@ -2090,6 +2105,7 @@ async function buildEntityEmbeddingsIndex(vaultPath2, entities, onProgress) {
     throw new Error("Embeddings database not initialized. Call setEmbeddingsDatabase() first.");
   }
   await initEmbeddings();
+  setEmbeddingsBuildState("building_entities");
   const existingHashes = /* @__PURE__ */ new Map();
   const rows = db.prepare("SELECT entity_name, source_hash FROM entity_embeddings").all();
   for (const row of rows) {
@@ -3915,6 +3931,20 @@ function processImplicitFeedback(stateDb2, notePath, currentContent) {
   if (removed.length > 0) {
     updateSuppressionList(stateDb2);
   }
+  const SURVIVAL_COOLDOWN_MS = 24 * 60 * 60 * 1e3;
+  const getLastSurvival = stateDb2.db.prepare(
+    `SELECT MAX(created_at) as last FROM wikilink_feedback
+     WHERE entity = ? COLLATE NOCASE AND context = 'implicit:survived' AND note_path = ?`
+  );
+  for (const { entity } of trackedWithTime) {
+    if (currentLinks.has(entity.toLowerCase())) {
+      const lastSurvival = getLastSurvival.get(entity, notePath);
+      const lastAt = lastSurvival?.last ? new Date(lastSurvival.last).getTime() : 0;
+      if (Date.now() - lastAt > SURVIVAL_COOLDOWN_MS) {
+        recordFeedback(stateDb2, entity, "implicit:survived", notePath, true, 0.8);
+      }
+    }
+  }
   return removed;
 }
 var TIER_LABELS = [
@@ -5534,6 +5564,68 @@ function tokenIdf(token, coocIndex) {
   const rawIdf = Math.log((N + 1) / (df + 1));
   return Math.max(0.5, Math.min(2.5, rawIdf));
 }
+function serializeCooccurrenceIndex(index) {
+  const serialized = {};
+  for (const [entity, assocs] of Object.entries(index.associations)) {
+    serialized[entity] = Object.fromEntries(assocs);
+  }
+  return {
+    associations: serialized,
+    minCount: index.minCount,
+    documentFrequency: Object.fromEntries(index.documentFrequency),
+    totalNotesScanned: index.totalNotesScanned,
+    _metadata: index._metadata
+  };
+}
+function deserializeCooccurrenceIndex(data) {
+  try {
+    const associations = {};
+    const assocData = data.associations;
+    if (!assocData) return null;
+    for (const [entity, assocs] of Object.entries(assocData)) {
+      associations[entity] = new Map(Object.entries(assocs));
+    }
+    const dfData = data.documentFrequency;
+    const documentFrequency = dfData ? new Map(Object.entries(dfData).map(([k, v]) => [k, v])) : /* @__PURE__ */ new Map();
+    const totalNotesScanned = data.totalNotesScanned || 0;
+    return {
+      associations,
+      minCount: data.minCount || DEFAULT_MIN_COOCCURRENCE,
+      documentFrequency,
+      totalNotesScanned,
+      _metadata: data._metadata
+    };
+  } catch {
+    return null;
+  }
+}
+var COOCCURRENCE_CACHE_MAX_AGE_MS = 60 * 60 * 1e3;
+function saveCooccurrenceToStateDb(stateDb2, index) {
+  const serialized = serializeCooccurrenceIndex(index);
+  const data = JSON.stringify(serialized);
+  const entityCount = Object.keys(index.associations).length;
+  const associationCount = index._metadata.total_associations;
+  stateDb2.db.prepare(`
+    INSERT OR REPLACE INTO cooccurrence_cache (id, data, built_at, entity_count, association_count)
+    VALUES (1, ?, ?, ?, ?)
+  `).run(data, Date.now(), entityCount, associationCount);
+}
+function loadCooccurrenceFromStateDb(stateDb2) {
+  const row = stateDb2.db.prepare(
+    "SELECT data, built_at FROM cooccurrence_cache WHERE id = 1"
+  ).get();
+  if (!row) return null;
+  const ageMs = Date.now() - row.built_at;
+  if (ageMs > COOCCURRENCE_CACHE_MAX_AGE_MS) return null;
+  try {
+    const parsed = JSON.parse(row.data);
+    const index = deserializeCooccurrenceIndex(parsed);
+    if (!index) return null;
+    return { index, builtAt: row.built_at };
+  } catch {
+    return null;
+  }
+}
 
 // src/core/write/edgeWeights.ts
 var moduleStateDb4 = null;
@@ -7909,7 +8001,7 @@ function registerGraphTools(server2, getIndex, getVaultPath, getStateDb) {
 
 // src/tools/read/wikilinks.ts
 import { z as z2 } from "zod";
-import { detectImplicitEntities as detectImplicitEntities2 } from "@velvetmonkey/vault-core";
+import { detectImplicitEntities as detectImplicitEntities2, IMPLICIT_EXCLUDE_WORDS } from "@velvetmonkey/vault-core";
 function findEntityMatches(text, entities) {
   const matches = [];
   const sortedEntities = Array.from(entities.entries()).filter(([name]) => name.length >= 2).sort((a, b) => b[0].length - a[0].length);
@@ -8031,6 +8123,8 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
         if (links.length < 2) continue;
         if (index.entities.has(target.toLowerCase())) continue;
         if (linkedSet.has(target.toLowerCase())) continue;
+        if (IMPLICIT_EXCLUDE_WORDS.has(target.toLowerCase())) continue;
+        if (target.length < 4) continue;
         const targetLower = target.toLowerCase();
         const textLower = text.toLowerCase();
         let searchPos = 0;
@@ -16294,6 +16388,24 @@ function resolveCorrection(stateDb2, id, newStatus) {
   `).run(newStatus, id);
   return result.changes > 0;
 }
+function processPendingCorrections(stateDb2) {
+  const pending = listCorrections(stateDb2, "pending");
+  let processed = 0;
+  for (const correction of pending) {
+    if (!correction.entity) {
+      resolveCorrection(stateDb2, correction.id, "dismissed");
+      continue;
+    }
+    if (correction.correction_type === "wrong_link") {
+      recordFeedback(stateDb2, correction.entity, "correction:wrong_link", correction.note_path || "", false, 1);
+    } else if (correction.correction_type === "wrong_category") {
+      recordFeedback(stateDb2, correction.entity, "correction:wrong_category", "", false, 0.5);
+    }
+    resolveCorrection(stateDb2, correction.id, "applied");
+    processed++;
+  }
+  return processed;
+}
 
 // src/tools/write/corrections.ts
 function registerCorrectionTools(server2, getStateDb) {
@@ -18926,6 +19038,12 @@ async function main() {
     setWriteStateDb(stateDb);
     setRecencyStateDb(stateDb);
     setEdgeWeightStateDb(stateDb);
+    const cachedCooc = loadCooccurrenceFromStateDb(stateDb);
+    if (cachedCooc) {
+      setCooccurrenceIndex(cachedCooc.index);
+      lastCooccurrenceRebuildAt = cachedCooc.builtAt;
+      serverLog("index", `Co-occurrence: loaded from cache (${Object.keys(cachedCooc.index.associations).length} entities, ${cachedCooc.index._metadata.total_associations} associations)`);
+    }
     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");
@@ -19154,6 +19272,7 @@ async function runPostIndexWork(index) {
           }
         }
         loadEntityEmbeddingsToMemory();
+        setEmbeddingsBuildState("complete");
         serverLog("semantic", "Embeddings ready");
       }).catch((err) => {
         serverLog("semantic", `Embeddings build failed: ${err instanceof Error ? err.message : err}`, "error");
@@ -19339,17 +19458,22 @@ async function runPostIndexWork(index) {
         tracker.end({ entity_count: entitiesAfter.length, ...entityDiff, category_changes: categoryChanges, description_changes: descriptionChanges });
         serverLog("watcher", `Entity scan: ${entitiesAfter.length} entities`);
         tracker.start("hub_scores", { entity_count: entitiesAfter.length });
-        const hubUpdated = await exportHubScores(vaultIndex, stateDb);
-        const hubDiffs = [];
-        if (stateDb) {
-          const rows = stateDb.db.prepare("SELECT name, hub_score FROM entities").all();
-          for (const r of rows) {
-            const prev = hubBefore.get(r.name) ?? 0;
-            if (prev !== r.hub_score) hubDiffs.push({ entity: r.name, before: prev, after: r.hub_score });
+        try {
+          const hubUpdated = await exportHubScores(vaultIndex, stateDb);
+          const hubDiffs = [];
+          if (stateDb) {
+            const rows = stateDb.db.prepare("SELECT name, hub_score FROM entities").all();
+            for (const r of rows) {
+              const prev = hubBefore.get(r.name) ?? 0;
+              if (prev !== r.hub_score) hubDiffs.push({ entity: r.name, before: prev, after: r.hub_score });
+            }
           }
+          tracker.end({ updated: hubUpdated ?? 0, diffs: hubDiffs.slice(0, 10) });
+          serverLog("watcher", `Hub scores: ${hubUpdated ?? 0} updated`);
+        } catch (e) {
+          tracker.end({ error: String(e) });
+          serverLog("watcher", `Hub scores: failed: ${e}`, "error");
         }
-        tracker.end({ updated: hubUpdated ?? 0, diffs: hubDiffs.slice(0, 10) });
-        serverLog("watcher", `Hub scores: ${hubUpdated ?? 0} updated`);
         tracker.start("recency", { entity_count: entitiesAfter.length });
         try {
           const cachedRecency = loadRecencyFromStateDb();
@@ -19376,6 +19500,9 @@ async function runPostIndexWork(index) {
             const cooccurrenceIdx = await mineCooccurrences(vaultPath, entityNames);
             setCooccurrenceIndex(cooccurrenceIdx);
             lastCooccurrenceRebuildAt = Date.now();
+            if (stateDb) {
+              saveCooccurrenceToStateDb(stateDb, cooccurrenceIdx);
+            }
             tracker.end({ rebuilt: true, associations: cooccurrenceIdx._metadata.total_associations });
             serverLog("watcher", `Co-occurrence: rebuilt ${cooccurrenceIdx._metadata.total_associations} associations`);
           } else {
@@ -19491,87 +19618,99 @@ async function runPostIndexWork(index) {
         }
         tracker.end({ updated: taskUpdated, removed: taskRemoved });
         serverLog("watcher", `Task cache: ${taskUpdated} updated, ${taskRemoved} removed`);
-        tracker.start("forward_links", { files: filteredEvents.length });
-        const eventTypeMap = new Map(filteredEvents.map((e) => [e.path, e.type]));
         const forwardLinkResults = [];
         let totalResolved = 0;
         let totalDead = 0;
-        for (const event of filteredEvents) {
-          if (event.type === "delete" || !event.path.endsWith(".md")) continue;
-          try {
-            const links = getForwardLinksForNote(vaultIndex, event.path);
-            const resolved = [];
-            const dead = [];
-            const seen = /* @__PURE__ */ new Set();
-            for (const link of links) {
-              const name = link.target;
-              if (seen.has(name.toLowerCase())) continue;
-              seen.add(name.toLowerCase());
-              if (link.exists) resolved.push(name);
-              else dead.push(name);
-            }
-            if (resolved.length > 0 || dead.length > 0) {
-              forwardLinkResults.push({ file: event.path, resolved, dead });
-            }
-            totalResolved += resolved.length;
-            totalDead += dead.length;
-          } catch {
-          }
-        }
         const linkDiffs = [];
         const survivedLinks = [];
-        if (stateDb) {
-          const upsertHistory = stateDb.db.prepare(`
+        tracker.start("forward_links", { files: filteredEvents.length });
+        try {
+          const eventTypeMap = new Map(filteredEvents.map((e) => [e.path, e.type]));
+          for (const event of filteredEvents) {
+            if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+            try {
+              const links = getForwardLinksForNote(vaultIndex, event.path);
+              const resolved = [];
+              const dead = [];
+              const seen = /* @__PURE__ */ new Set();
+              for (const link of links) {
+                const name = link.target;
+                if (seen.has(name.toLowerCase())) continue;
+                seen.add(name.toLowerCase());
+                if (link.exists) resolved.push(name);
+                else dead.push(name);
+              }
+              if (resolved.length > 0 || dead.length > 0) {
+                forwardLinkResults.push({ file: event.path, resolved, dead });
+              }
+              totalResolved += resolved.length;
+              totalDead += dead.length;
+            } catch {
+            }
+          }
+          if (stateDb) {
+            const upsertHistory = stateDb.db.prepare(`
               INSERT INTO note_link_history (note_path, target) VALUES (?, ?)
               ON CONFLICT(note_path, target) DO UPDATE SET edits_survived = edits_survived + 1
             `);
-          const checkThreshold = stateDb.db.prepare(`
+            const checkThreshold = stateDb.db.prepare(`
               SELECT target FROM note_link_history
               WHERE note_path = ? AND target = ? AND edits_survived >= 3 AND last_positive_at IS NULL
             `);
-          const markPositive = stateDb.db.prepare(`
+            const markPositive = stateDb.db.prepare(`
               UPDATE note_link_history SET last_positive_at = datetime('now') WHERE note_path = ? AND target = ?
             `);
-          const getEdgeCount = stateDb.db.prepare(
-            "SELECT edits_survived FROM note_link_history WHERE note_path=? AND target=?"
-          );
-          for (const entry of forwardLinkResults) {
-            const currentSet = /* @__PURE__ */ new Set([
-              ...entry.resolved.map((n) => n.toLowerCase()),
-              ...entry.dead.map((n) => n.toLowerCase())
-            ]);
-            const previousSet = getStoredNoteLinks(stateDb, entry.file);
-            if (previousSet.size === 0) {
+            const getEdgeCount = stateDb.db.prepare(
+              "SELECT edits_survived FROM note_link_history WHERE note_path=? AND target=?"
+            );
+            for (const entry of forwardLinkResults) {
+              const currentSet = /* @__PURE__ */ new Set([
+                ...entry.resolved.map((n) => n.toLowerCase()),
+                ...entry.dead.map((n) => n.toLowerCase())
+              ]);
+              const previousSet = getStoredNoteLinks(stateDb, entry.file);
+              if (previousSet.size === 0) {
+                updateStoredNoteLinks(stateDb, entry.file, currentSet);
+                continue;
+              }
+              const diff = diffNoteLinks(previousSet, currentSet);
+              if (diff.added.length > 0 || diff.removed.length > 0) {
+                linkDiffs.push({ file: entry.file, ...diff });
+              }
               updateStoredNoteLinks(stateDb, entry.file, currentSet);
-              continue;
-            }
-            const diff = diffNoteLinks(previousSet, currentSet);
-            if (diff.added.length > 0 || diff.removed.length > 0) {
-              linkDiffs.push({ file: entry.file, ...diff });
-            }
-            updateStoredNoteLinks(stateDb, entry.file, currentSet);
-            if (diff.removed.length === 0) continue;
-            for (const link of currentSet) {
-              if (!previousSet.has(link)) continue;
-              upsertHistory.run(entry.file, link);
-              const countRow = getEdgeCount.get(entry.file, link);
-              if (countRow) {
-                survivedLinks.push({ entity: link, file: entry.file, count: countRow.edits_survived });
+              if (diff.removed.length === 0) continue;
+              for (const link of currentSet) {
+                if (!previousSet.has(link)) continue;
+                upsertHistory.run(entry.file, link);
+                const countRow = getEdgeCount.get(entry.file, link);
+                if (countRow) {
+                  survivedLinks.push({ entity: link, file: entry.file, count: countRow.edits_survived });
+                }
+                const hit = checkThreshold.get(entry.file, link);
+                if (hit) {
+                  const entity = entitiesAfter.find(
+                    (e) => e.nameLower === link || (e.aliases ?? []).some((a) => a.toLowerCase() === link)
+                  );
+                  if (entity) {
+                    recordFeedback(stateDb, entity.name, "implicit:kept", entry.file, true, 0.8);
+                    markPositive.run(entry.file, link);
+                  }
+                }
               }
-              const hit = checkThreshold.get(entry.file, link);
-              if (hit) {
-                const entity = entitiesAfter.find(
-                  (e) => e.nameLower === link || (e.aliases ?? []).some((a) => a.toLowerCase() === link)
-                );
-                if (entity) {
-                  recordFeedback(stateDb, entity.name, "implicit:kept", entry.file, true, 0.8);
-                  markPositive.run(entry.file, link);
+            }
+            for (const event of filteredEvents) {
+              if (event.type === "delete") {
+                const previousSet = getStoredNoteLinks(stateDb, event.path);
+                if (previousSet.size > 0) {
+                  linkDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
+                  updateStoredNoteLinks(stateDb, event.path, /* @__PURE__ */ new Set());
                 }
               }
             }
-          }
-          for (const event of filteredEvents) {
-            if (event.type === "delete") {
+            const processedFiles = new Set(forwardLinkResults.map((r) => r.file));
+            for (const event of filteredEvents) {
+              if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+              if (processedFiles.has(event.path)) continue;
               const previousSet = getStoredNoteLinks(stateDb, event.path);
               if (previousSet.size > 0) {
                 linkDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
@@ -19579,33 +19718,26 @@ async function runPostIndexWork(index) {
               }
             }
           }
-          const processedFiles = new Set(forwardLinkResults.map((r) => r.file));
-          for (const event of filteredEvents) {
-            if (event.type === "delete" || !event.path.endsWith(".md")) continue;
-            if (processedFiles.has(event.path)) continue;
-            const previousSet = getStoredNoteLinks(stateDb, event.path);
-            if (previousSet.size > 0) {
-              linkDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
-              updateStoredNoteLinks(stateDb, event.path, /* @__PURE__ */ new Set());
+          const newDeadLinks = [];
+          for (const diff of linkDiffs) {
+            const newDead = diff.added.filter((target) => !vaultIndex.entities.has(target.toLowerCase()));
+            if (newDead.length > 0) {
+              newDeadLinks.push({ file: diff.file, targets: newDead });
             }
           }
+          tracker.end({
+            total_resolved: totalResolved,
+            total_dead: totalDead,
+            links: forwardLinkResults,
+            link_diffs: linkDiffs,
+            survived: survivedLinks,
+            new_dead_links: newDeadLinks
+          });
+          serverLog("watcher", `Forward links: ${totalResolved} resolved, ${totalDead} dead${newDeadLinks.length > 0 ? `, ${newDeadLinks.reduce((s, d) => s + d.targets.length, 0)} new dead` : ""}`);
+        } catch (e) {
+          tracker.end({ error: String(e) });
+          serverLog("watcher", `Forward links: failed: ${e}`, "error");
         }
-        const newDeadLinks = [];
-        for (const diff of linkDiffs) {
-          const newDead = diff.added.filter((target) => !vaultIndex.entities.has(target.toLowerCase()));
-          if (newDead.length > 0) {
-            newDeadLinks.push({ file: diff.file, targets: newDead });
-          }
-        }
-        tracker.end({
-          total_resolved: totalResolved,
-          total_dead: totalDead,
-          links: forwardLinkResults,
-          link_diffs: linkDiffs,
-          survived: survivedLinks,
-          new_dead_links: newDeadLinks
-        });
-        serverLog("watcher", `Forward links: ${totalResolved} resolved, ${totalDead} dead${newDeadLinks.length > 0 ? `, ${newDeadLinks.reduce((s, d) => s + d.targets.length, 0)} new dead` : ""}`);
         tracker.start("wikilink_check", { files: filteredEvents.length });
         const trackedLinks = [];
         if (stateDb) {
@@ -19730,6 +19862,24 @@ async function runPostIndexWork(index) {
         if (newlySuppressed.length > 0) {
           serverLog("watcher", `Suppression: ${newlySuppressed.length} entities newly suppressed: ${newlySuppressed.join(", ")}`);
         }
+        tracker.start("corrections", {});
+        try {
+          if (stateDb) {
+            const corrProcessed = processPendingCorrections(stateDb);
+            if (corrProcessed > 0) {
+              updateSuppressionList(stateDb);
+            }
+            tracker.end({ processed: corrProcessed });
+            if (corrProcessed > 0) {
+              serverLog("watcher", `Corrections: ${corrProcessed} processed`);
+            }
+          } else {
+            tracker.end({ skipped: true });
+          }
+        } catch (e) {
+          tracker.end({ error: String(e) });
+          serverLog("watcher", `Corrections: failed: ${e}`, "error");
+        }
         tracker.start("prospect_scan", { files: filteredEvents.length });
         const prospectResults = [];
         for (const event of filteredEvents) {
@@ -19793,45 +19943,50 @@ async function runPostIndexWork(index) {
           serverLog("watcher", `Suggestion scoring: ${suggestionResults.length} files scored`);
         }
         tracker.start("tag_scan", { files: filteredEvents.length });
-        const tagDiffs = [];
-        if (stateDb) {
-          const noteTagsForward = /* @__PURE__ */ new Map();
-          for (const [tag, paths] of vaultIndex.tags) {
-            for (const notePath of paths) {
-              if (!noteTagsForward.has(notePath)) noteTagsForward.set(notePath, /* @__PURE__ */ new Set());
-              noteTagsForward.get(notePath).add(tag);
+        try {
+          const tagDiffs = [];
+          if (stateDb) {
+            const noteTagsForward = /* @__PURE__ */ new Map();
+            for (const [tag, paths] of vaultIndex.tags) {
+              for (const notePath of paths) {
+                if (!noteTagsForward.has(notePath)) noteTagsForward.set(notePath, /* @__PURE__ */ new Set());
+                noteTagsForward.get(notePath).add(tag);
+              }
             }
-          }
-          for (const event of filteredEvents) {
-            if (event.type === "delete" || !event.path.endsWith(".md")) continue;
-            const currentSet = noteTagsForward.get(event.path) ?? /* @__PURE__ */ new Set();
-            const previousSet = getStoredNoteTags(stateDb, event.path);
-            if (previousSet.size === 0 && currentSet.size > 0) {
+            for (const event of filteredEvents) {
+              if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+              const currentSet = noteTagsForward.get(event.path) ?? /* @__PURE__ */ new Set();
+              const previousSet = getStoredNoteTags(stateDb, event.path);
+              if (previousSet.size === 0 && currentSet.size > 0) {
+                updateStoredNoteTags(stateDb, event.path, currentSet);
+                continue;
+              }
+              const added = [...currentSet].filter((t) => !previousSet.has(t));
+              const removed = [...previousSet].filter((t) => !currentSet.has(t));
+              if (added.length > 0 || removed.length > 0) {
+                tagDiffs.push({ file: event.path, added, removed });
+              }
               updateStoredNoteTags(stateDb, event.path, currentSet);
-              continue;
-            }
-            const added = [...currentSet].filter((t) => !previousSet.has(t));
-            const removed = [...previousSet].filter((t) => !currentSet.has(t));
-            if (added.length > 0 || removed.length > 0) {
-              tagDiffs.push({ file: event.path, added, removed });
             }
-            updateStoredNoteTags(stateDb, event.path, currentSet);
-          }
-          for (const event of filteredEvents) {
-            if (event.type === "delete") {
-              const previousSet = getStoredNoteTags(stateDb, event.path);
-              if (previousSet.size > 0) {
-                tagDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
-                updateStoredNoteTags(stateDb, event.path, /* @__PURE__ */ new Set());
+            for (const event of filteredEvents) {
+              if (event.type === "delete") {
+                const previousSet = getStoredNoteTags(stateDb, event.path);
+                if (previousSet.size > 0) {
+                  tagDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
+                  updateStoredNoteTags(stateDb, event.path, /* @__PURE__ */ new Set());
+                }
               }
             }
           }
-        }
-        const totalTagsAdded = tagDiffs.reduce((s, d) => s + d.added.length, 0);
-        const totalTagsRemoved = tagDiffs.reduce((s, d) => s + d.removed.length, 0);
-        tracker.end({ total_added: totalTagsAdded, total_removed: totalTagsRemoved, tag_diffs: tagDiffs });
-        if (tagDiffs.length > 0) {
-          serverLog("watcher", `Tag scan: ${totalTagsAdded} added, ${totalTagsRemoved} removed across ${tagDiffs.length} files`);
+          const totalTagsAdded = tagDiffs.reduce((s, d) => s + d.added.length, 0);
+          const totalTagsRemoved = tagDiffs.reduce((s, d) => s + d.removed.length, 0);
+          tracker.end({ total_added: totalTagsAdded, total_removed: totalTagsRemoved, tag_diffs: tagDiffs });
+          if (tagDiffs.length > 0) {
+            serverLog("watcher", `Tag scan: ${totalTagsAdded} added, ${totalTagsRemoved} removed across ${tagDiffs.length} files`);
+          }
+        } catch (e) {
+          tracker.end({ error: String(e) });
+          serverLog("watcher", `Tag scan: failed: ${e}`, "error");
         }
         const duration = Date.now() - batchStart;
         if (stateDb) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.51",
+  "version": "2.0.52",
   "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",
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@velvetmonkey/vault-core": "^2.0.50",
+    "@velvetmonkey/vault-core": "^2.0.52",
     "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",