@velvetmonkey/flywheel-memory 2.0.129 → 2.0.131

package/dist/index.js

@@ -1239,15 +1239,22 @@ function getDashboardData(stateDb2) {
     }))
   };
 }
-function getEntityScoreTimeline(stateDb2, entityName, daysBack = 30, limit = 100) {
+function getEntityScoreTimeline(stateDb2, entityName, daysBack = 90, limit = 90) {
   const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
   const rows = stateDb2.db.prepare(`
-    SELECT timestamp, total_score, breakdown_json, note_path, passed, threshold
-    FROM suggestion_events
-    WHERE entity = ? AND timestamp >= ?
-    ORDER BY timestamp ASC
+    SELECT s.timestamp, s.total_score, s.breakdown_json, s.note_path, s.passed, s.threshold
+    FROM suggestion_events s
+    INNER JOIN (
+      SELECT date(timestamp/1000, 'unixepoch') as day, MAX(total_score) as max_score
+      FROM suggestion_events
+      WHERE entity = ? AND timestamp >= ?
+      GROUP BY day
+    ) agg ON date(s.timestamp/1000, 'unixepoch') = agg.day AND s.total_score = agg.max_score
+    WHERE s.entity = ? AND s.timestamp >= ?
+    GROUP BY agg.day
+    ORDER BY s.timestamp ASC
     LIMIT ?
-  `).all(entityName, cutoff, limit);
+  `).all(entityName, cutoff, entityName, cutoff, limit);
   return rows.map((r) => ({
     timestamp: r.timestamp,
     score: r.total_score,
@@ -15303,7 +15310,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
       format: z12.enum(["plain", "bullet", "task", "numbered", "timestamp-bullet"]).default("plain").describe("How to format the content"),
       commit: z12.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
       skipWikilinks: z12.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)"),
-      suggestOutgoingLinks: z12.boolean().default(true).describe("Suggest related outgoing wikilinks based on content. Set false to disable."),
+      suggestOutgoingLinks: z12.boolean().default(false).describe('Suggest related outgoing wikilinks based on content (e.g., "\u2192 [[AI]], [[Philosophy]]"). Off by default \u2014 set true for daily notes, journals, or capture-heavy contexts.'),
       maxSuggestions: z12.number().min(1).max(10).default(5).describe("Maximum number of suggested wikilinks (1-10, default: 5)"),
       linkedEntities: z12.array(z12.string()).optional().describe("Entity names already linked in the content. When skipWikilinks=true, these are tracked for feedback without re-processing the content."),
       dry_run: z12.boolean().optional().default(false).describe("Preview changes without writing to disk"),
@@ -15464,7 +15471,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
       useRegex: z12.boolean().default(false).describe("Treat search as regex"),
       commit: z12.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
       skipWikilinks: z12.boolean().default(false).describe("If true, skip auto-wikilink application on replacement text"),
-      suggestOutgoingLinks: z12.boolean().default(true).describe("Suggest related outgoing wikilinks based on content. Set false to disable."),
+      suggestOutgoingLinks: z12.boolean().default(false).describe('Suggest related outgoing wikilinks based on content (e.g., "\u2192 [[AI]], [[Philosophy]]"). Off by default \u2014 set true for daily notes, journals, or capture-heavy contexts.'),
       maxSuggestions: z12.number().min(1).max(10).default(5).describe("Maximum number of suggested wikilinks (1-10, default: 5)"),
       dry_run: z12.boolean().optional().default(false).describe("Preview changes without writing to disk"),
       agent_id: z12.string().optional().describe("Agent identifier for multi-agent scoping"),
@@ -15684,7 +15691,7 @@ function registerTaskTools(server2, getVaultPath) {
       completed: z13.boolean().default(false).describe("Whether the task should start as completed"),
       commit: z13.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
       skipWikilinks: z13.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)"),
-      suggestOutgoingLinks: z13.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]], [[Philosophy]]"). Set false to disable.'),
+      suggestOutgoingLinks: z13.boolean().default(false).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]], [[Philosophy]]"). Off by default \u2014 set true for daily notes, journals, or capture-heavy contexts.'),
       maxSuggestions: z13.number().min(1).max(10).default(5).describe("Maximum number of suggested wikilinks to append (1-10, default: 5)"),
       preserveListNesting: z13.boolean().default(true).describe("Preserve indentation when inserting into nested lists. Default: true"),
       validate: z13.boolean().default(true).describe("Check input for common issues"),
@@ -15832,7 +15839,7 @@ function registerNoteTools(server2, getVaultPath, getIndex) {
       overwrite: z15.boolean().default(false).describe("If true, overwrite existing file"),
       commit: z15.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
       skipWikilinks: z15.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)"),
-      suggestOutgoingLinks: z15.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]], [[Philosophy]]").'),
+      suggestOutgoingLinks: z15.boolean().default(false).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]], [[Philosophy]]"). Off by default \u2014 set true for daily notes, journals, or capture-heavy contexts.'),
       maxSuggestions: z15.number().min(1).max(10).default(5).describe("Maximum number of suggested wikilinks to append (1-10, default: 5)"),
       dry_run: z15.boolean().optional().default(false).describe("Preview changes without writing to disk"),
       agent_id: z15.string().optional().describe("Agent identifier for multi-agent scoping"),
@@ -19983,7 +19990,10 @@ var VALID_CONFIG_KEYS = {
   wikilink_strictness: z27.enum(["conservative", "balanced", "aggressive"]),
   implicit_detection: z27.boolean(),
   implicit_patterns: z27.array(z27.string()),
-  adaptive_strictness: z27.boolean()
+  adaptive_strictness: z27.boolean(),
+  proactive_linking: z27.boolean(),
+  proactive_min_score: z27.number(),
+  proactive_max_per_file: z27.number()
 };
 function registerConfigTools(server2, getConfig2, setConfig, getStateDb2) {
   server2.registerTool(
@@ -22083,6 +22093,15 @@ var stateDb = null;
 var watcherInstance = null;
 var vaultRegistry = null;
 function getWatcherStatus() {
+  if (vaultRegistry) {
+    const name = globalThis.__flywheel_active_vault;
+    if (name) {
+      try {
+        return vaultRegistry.getContext(name).watcher?.status ?? null;
+      } catch {
+      }
+    }
+  }
   return watcherInstance?.status ?? null;
 }
 var ALL_CATEGORIES = [
@@ -22573,12 +22592,11 @@ function registerAllTools(targetServer) {
     targetServer,
     gvi,
     (newIndex) => {
-      vaultIndex = newIndex;
+      updateVaultIndex(newIndex);
     },
     gvp,
     (newConfig) => {
-      flywheelConfig = newConfig;
-      setWikilinkConfig(newConfig);
+      updateFlywheelConfig(newConfig);
     },
     gsd
   );
@@ -22636,8 +22654,7 @@ function registerAllTools(targetServer) {
     targetServer,
     gcf,
     (newConfig) => {
-      flywheelConfig = newConfig;
-      setWikilinkConfig(newConfig);
+      updateFlywheelConfig(newConfig);
     },
     gsd
   );
@@ -22663,7 +22680,7 @@ function createConfiguredServer() {
     { name: "flywheel-memory", version: pkg.version },
     { instructions: generateInstructions(enabledCategories, vaultRegistry) }
   );
-  applyToolGating(s, enabledCategories, () => stateDb, vaultRegistry, () => vaultPath);
+  applyToolGating(s, enabledCategories, () => getActiveScopeOrNull()?.stateDb ?? stateDb, vaultRegistry, () => getActiveScopeOrNull()?.vaultPath ?? vaultPath);
   registerAllTools(s);
   return s;
 }
@@ -22671,7 +22688,7 @@ var server = new McpServer(
   { name: "flywheel-memory", version: pkg.version },
   { instructions: generateInstructions(enabledCategories, vaultRegistry) }
 );
-var _gatingResult = applyToolGating(server, enabledCategories, () => stateDb, vaultRegistry, () => vaultPath);
+var _gatingResult = applyToolGating(server, enabledCategories, () => getActiveScopeOrNull()?.stateDb ?? stateDb, vaultRegistry, () => getActiveScopeOrNull()?.vaultPath ?? vaultPath);
 registerAllTools(server);
 var categoryList = Array.from(enabledCategories).sort().join(", ");
 serverLog("server", `Tool categories: ${categoryList}`);
@@ -22756,6 +22773,108 @@ function updateIndexState(state2, error) {
     if (error !== void 0) ctx.indexError = error;
   }
 }
+function updateVaultIndex(index) {
+  vaultIndex = index;
+  const ctx = getActiveVaultContext();
+  if (ctx) ctx.vaultIndex = index;
+}
+function updateFlywheelConfig(config) {
+  flywheelConfig = config;
+  setWikilinkConfig(config);
+  const ctx = getActiveVaultContext();
+  if (ctx) ctx.flywheelConfig = config;
+}
+async function bootVault(ctx, startTime) {
+  const vp = ctx.vaultPath;
+  const sd = ctx.stateDb;
+  initializeLogger(vp).then(() => {
+    const logger3 = getLogger();
+    if (logger3?.enabled) {
+      serverLog("server", `[${ctx.name}] Unified logging enabled`);
+    }
+  }).catch(() => {
+  });
+  initializeLogger2(vp).catch((err) => {
+    serverLog("server", `[${ctx.name}] Write logger initialization failed: ${err}`, "error");
+  });
+  if (process.env.FLYWHEEL_SKIP_FTS5 !== "true") {
+    if (isIndexStale(vp)) {
+      buildFTS5Index(vp).then(() => {
+        serverLog("fts5", `[${ctx.name}] Search index ready`);
+      }).catch((err) => {
+        serverLog("fts5", `[${ctx.name}] Build failed: ${err instanceof Error ? err.message : err}`, "error");
+      });
+    } else {
+      serverLog("fts5", `[${ctx.name}] Search index already fresh, skipping rebuild`);
+    }
+  } else {
+    serverLog("fts5", "Skipping \u2014 FLYWHEEL_SKIP_FTS5");
+  }
+  let cachedIndex = null;
+  if (sd) {
+    try {
+      const files = await scanVault(vp);
+      const noteCount = files.length;
+      serverLog("index", `[${ctx.name}] Found ${noteCount} markdown files`);
+      const newestMtime = files.reduce((max, f) => f.modified > max ? f.modified : max, /* @__PURE__ */ new Date(0));
+      cachedIndex = loadVaultIndexFromCache(sd, noteCount, void 0, void 0, newestMtime);
+    } catch (err) {
+      serverLog("index", `[${ctx.name}] Cache check failed: ${err instanceof Error ? err.message : err}`, "warn");
+    }
+  }
+  if (cachedIndex) {
+    updateVaultIndex(cachedIndex);
+    updateIndexState("ready");
+    const duration = Date.now() - startTime;
+    const cacheAge = cachedIndex.builtAt ? Math.round((Date.now() - cachedIndex.builtAt.getTime()) / 1e3) : 0;
+    serverLog("index", `[${ctx.name}] Cache hit: ${cachedIndex.notes.size} notes, ${cacheAge}s old \u2014 loaded in ${duration}ms`);
+    if (sd) {
+      recordIndexEvent(sd, {
+        trigger: "startup_cache",
+        duration_ms: duration,
+        note_count: cachedIndex.notes.size
+      });
+    }
+    await runPostIndexWork(ctx);
+  } else {
+    serverLog("index", `[${ctx.name}] Cache miss: building from scratch`);
+    try {
+      const built = await buildVaultIndex(vp);
+      updateVaultIndex(built);
+      updateIndexState("ready");
+      const duration = Date.now() - startTime;
+      serverLog("index", `[${ctx.name}] Vault index ready in ${duration}ms \u2014 ${vaultIndex.notes.size} notes`);
+      if (sd) {
+        recordIndexEvent(sd, {
+          trigger: "startup_build",
+          duration_ms: duration,
+          note_count: vaultIndex.notes.size
+        });
+      }
+      if (sd) {
+        try {
+          saveVaultIndexToCache(sd, vaultIndex);
+          serverLog("index", `[${ctx.name}] Index cache saved`);
+        } catch (err) {
+          serverLog("index", `[${ctx.name}] Failed to save index cache: ${err instanceof Error ? err.message : err}`, "error");
+        }
+      }
+      await runPostIndexWork(ctx);
+    } catch (err) {
+      updateIndexState("error", err instanceof Error ? err : new Error(String(err)));
+      const duration = Date.now() - startTime;
+      if (sd) {
+        recordIndexEvent(sd, {
+          trigger: "startup_build",
+          duration_ms: duration,
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+      serverLog("index", `[${ctx.name}] Failed to build vault index: ${err instanceof Error ? err.message : err}`, "error");
+    }
+  }
+}
 async function main() {
   serverLog("server", `Starting Flywheel Memory v${pkg.version}...`);
   serverLog("server", `Vault: ${vaultPath}`);
@@ -22829,105 +22948,24 @@ async function main() {
       serverLog("server", `HTTP transport on ${httpHost}:${httpPort}`);
     });
   }
-  initializeLogger(vaultPath).then(() => {
-    const logger3 = getLogger();
-    if (logger3?.enabled) {
-      serverLog("server", "Unified logging enabled");
-    }
-  }).catch(() => {
-  });
-  initializeLogger2(vaultPath).catch((err) => {
-    serverLog("server", `Write logger initialization failed: ${err}`, "error");
-  });
-  if (process.env.FLYWHEEL_SKIP_FTS5 !== "true") {
-    if (isIndexStale(vaultPath)) {
-      buildFTS5Index(vaultPath).then(() => {
-        serverLog("fts5", "Search index ready");
-      }).catch((err) => {
-        serverLog("fts5", `Build failed: ${err instanceof Error ? err.message : err}`, "error");
-      });
-    } else {
-      serverLog("fts5", "Search index already fresh, skipping rebuild");
-    }
-  } else {
-    serverLog("fts5", "Skipping \u2014 FLYWHEEL_SKIP_FTS5");
-  }
-  let cachedIndex = null;
-  if (stateDb) {
-    try {
-      const files = await scanVault(vaultPath);
-      const noteCount = files.length;
-      serverLog("index", `Found ${noteCount} markdown files`);
-      const newestMtime = files.reduce((max, f) => f.modified > max ? f.modified : max, /* @__PURE__ */ new Date(0));
-      cachedIndex = loadVaultIndexFromCache(stateDb, noteCount, void 0, void 0, newestMtime);
-    } catch (err) {
-      serverLog("index", `Cache check failed: ${err instanceof Error ? err.message : err}`, "warn");
-    }
-  }
-  if (cachedIndex) {
-    vaultIndex = cachedIndex;
-    updateIndexState("ready");
-    const duration = Date.now() - startTime;
-    const cacheAge = cachedIndex.builtAt ? Math.round((Date.now() - cachedIndex.builtAt.getTime()) / 1e3) : 0;
-    serverLog("index", `Cache hit: ${cachedIndex.notes.size} notes, ${cacheAge}s old \u2014 loaded in ${duration}ms`);
-    if (stateDb) {
-      recordIndexEvent(stateDb, {
-        trigger: "startup_cache",
-        duration_ms: duration,
-        note_count: cachedIndex.notes.size
-      });
-    }
-    runPostIndexWork(vaultIndex);
-  } else {
-    serverLog("index", "Cache miss: building from scratch");
-    try {
-      vaultIndex = await buildVaultIndex(vaultPath);
-      updateIndexState("ready");
-      const duration = Date.now() - startTime;
-      serverLog("index", `Vault index ready in ${duration}ms \u2014 ${vaultIndex.notes.size} notes`);
-      if (stateDb) {
-        recordIndexEvent(stateDb, {
-          trigger: "startup_build",
-          duration_ms: duration,
-          note_count: vaultIndex.notes.size
-        });
-      }
-      if (stateDb) {
-        try {
-          saveVaultIndexToCache(stateDb, vaultIndex);
-          serverLog("index", "Index cache saved");
-        } catch (err) {
-          serverLog("index", `Failed to save index cache: ${err instanceof Error ? err.message : err}`, "error");
-        }
-      }
-      await runPostIndexWork(vaultIndex);
-    } catch (err) {
-      updateIndexState("error", err instanceof Error ? err : new Error(String(err)));
-      const duration = Date.now() - startTime;
-      if (stateDb) {
-        recordIndexEvent(stateDb, {
-          trigger: "startup_build",
-          duration_ms: duration,
-          success: false,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-      serverLog("index", `Failed to build vault index: ${err instanceof Error ? err.message : err}`, "error");
-    }
+  for (const vaultCtx of vaultRegistry.getAllContexts()) {
+    activateVault(vaultCtx);
+    stateDb = vaultCtx.stateDb;
+    await bootVault(vaultCtx, startTime);
   }
 }
 var DEFAULT_ENTITY_EXCLUDE_FOLDERS = ["node_modules", "templates", "attachments", "tmp"];
-var lastCooccurrenceRebuildAt = 0;
-var lastEdgeWeightRebuildAt = 0;
-async function updateEntitiesInStateDb() {
-  if (!stateDb) return;
+async function updateEntitiesInStateDb(vp, sd) {
+  const db4 = sd ?? stateDb;
+  const vault = vp ?? vaultPath;
+  if (!db4) return;
   try {
-    const config = loadConfig(stateDb);
+    const config = loadConfig(db4);
     const excludeFolders = config.exclude_entity_folders?.length ? config.exclude_entity_folders : DEFAULT_ENTITY_EXCLUDE_FOLDERS;
-    const entityIndex2 = await scanVaultEntities4(vaultPath, {
+    const entityIndex2 = await scanVaultEntities4(vault, {
       excludeFolders
     });
-    stateDb.replaceAllEntities(entityIndex2);
+    db4.replaceAllEntities(entityIndex2);
     serverLog("index", `Updated ${entityIndex2._metadata.total_entities} entities in StateDb`);
   } catch (e) {
     serverLog("index", `Failed to update entities in StateDb: ${e instanceof Error ? e.message : e}`, "error");
@@ -22983,61 +23021,69 @@ function runPeriodicMaintenance(db4) {
     serverLog("server", "Daily purge complete");
   }
 }
-async function runPostIndexWork(index) {
+async function runPostIndexWork(ctx) {
+  const index = ctx.vaultIndex;
+  const vp = ctx.vaultPath;
+  const sd = ctx.stateDb;
+  let rvp;
+  try {
+    rvp = realpathSync(vp).replace(/\\/g, "/");
+  } catch {
+    rvp = vp.replace(/\\/g, "/");
+  }
   const postStart = Date.now();
   serverLog("index", "Scanning entities...");
-  await updateEntitiesInStateDb();
-  await initializeEntityIndex(vaultPath);
+  await updateEntitiesInStateDb(vp, sd);
+  await initializeEntityIndex(vp);
   serverLog("index", "Entity index initialized");
-  await exportHubScores(index, stateDb);
+  await exportHubScores(index, sd);
   serverLog("index", "Hub scores exported");
-  if (stateDb) {
+  if (sd) {
     try {
-      const metrics = computeMetrics(index, stateDb);
-      recordMetrics(stateDb, metrics);
-      purgeOldMetrics(stateDb, 90);
-      purgeOldIndexEvents(stateDb, 90);
-      purgeOldInvocations(stateDb, 90);
-      purgeOldSuggestionEvents(stateDb, 30);
-      purgeOldNoteLinkHistory(stateDb, 90);
-      sweepExpiredMemories(stateDb);
-      decayMemoryConfidence(stateDb);
-      pruneSupersededMemories(stateDb, 90);
+      const metrics = computeMetrics(index, sd);
+      recordMetrics(sd, metrics);
+      purgeOldMetrics(sd, 90);
+      purgeOldIndexEvents(sd, 90);
+      purgeOldInvocations(sd, 90);
+      purgeOldSuggestionEvents(sd, 30);
+      purgeOldNoteLinkHistory(sd, 90);
+      sweepExpiredMemories(sd);
+      decayMemoryConfidence(sd);
+      pruneSupersededMemories(sd, 90);
       serverLog("server", "Growth metrics recorded");
     } catch (err) {
       serverLog("server", `Failed to record metrics: ${err instanceof Error ? err.message : err}`, "error");
     }
   }
-  if (stateDb) {
+  if (sd) {
     try {
       const graphMetrics = computeGraphMetrics(index);
-      recordGraphSnapshot(stateDb, graphMetrics);
-      purgeOldSnapshots(stateDb, 90);
+      recordGraphSnapshot(sd, graphMetrics);
+      purgeOldSnapshots(sd, 90);
     } catch (err) {
       serverLog("server", `Failed to record graph snapshot: ${err instanceof Error ? err.message : err}`, "error");
     }
   }
-  if (stateDb) {
+  if (sd) {
     try {
-      updateSuppressionList(stateDb);
+      updateSuppressionList(sd);
       serverLog("index", "Suppression list updated");
     } catch (err) {
       serverLog("server", `Failed to update suppression list: ${err instanceof Error ? err.message : err}`, "error");
     }
   }
-  const existing = loadConfig(stateDb);
-  const inferred = inferConfig(index, vaultPath);
-  if (stateDb) {
-    saveConfig(stateDb, inferred, existing);
+  const existing = loadConfig(sd);
+  const inferred = inferConfig(index, vp);
+  if (sd) {
+    saveConfig(sd, inferred, existing);
   }
-  flywheelConfig = loadConfig(stateDb);
-  setWikilinkConfig(flywheelConfig);
+  updateFlywheelConfig(loadConfig(sd));
   const configKeys = Object.keys(flywheelConfig).filter((k) => flywheelConfig[k] != null);
   serverLog("config", `Config inferred: ${configKeys.join(", ")}`);
-  if (stateDb) {
+  if (sd) {
     if (isTaskCacheStale()) {
       serverLog("tasks", "Task cache stale, rebuilding...");
-      refreshIfStale(vaultPath, index, flywheelConfig.exclude_task_tags);
+      refreshIfStale(vp, index, flywheelConfig.exclude_task_tags);
     } else {
       serverLog("tasks", "Task cache fresh, skipping rebuild");
     }
@@ -23050,9 +23096,9 @@ async function runPostIndexWork(index) {
     if (hasEmbeddingsIndex() && needsEmbeddingRebuild()) {
       const oldModel = getStoredEmbeddingModel();
       serverLog("semantic", `Embedding model changed from ${oldModel} to ${getActiveModelId()}, rebuilding`);
-      if (stateDb) {
-        stateDb.db.exec("DELETE FROM note_embeddings");
-        stateDb.db.exec("DELETE FROM entity_embeddings");
+      if (sd) {
+        sd.db.exec("DELETE FROM note_embeddings");
+        sd.db.exec("DELETE FROM entity_embeddings");
       }
       setEmbeddingsBuildState("none");
       modelChanged = true;
@@ -23062,19 +23108,17 @@ async function runPostIndexWork(index) {
     } else {
       const MAX_BUILD_RETRIES = 2;
       const attemptBuild = async (attempt) => {
+        activateVault(ctx);
         setEmbeddingsBuilding(true);
-        {
-          const ctx = getActiveVaultContext();
-          if (ctx) ctx.embeddingsBuilding = true;
-        }
+        ctx.embeddingsBuilding = true;
         try {
-          await buildEmbeddingsIndex(vaultPath, (p) => {
+          await buildEmbeddingsIndex(vp, (p) => {
             if (p.current % 100 === 0 || p.current === p.total) {
               serverLog("semantic", `Embedding ${p.current}/${p.total} notes...`);
             }
           });
-          if (stateDb) {
-            const entities = getAllEntitiesFromDb3(stateDb);
+          if (sd) {
+            const entities = getAllEntitiesFromDb3(sd);
             if (entities.length > 0) {
               const entityMap = new Map(entities.map((e) => [e.name, {
                 name: e.name,
@@ -23082,9 +23126,11 @@ async function runPostIndexWork(index) {
                 category: e.category,
                 aliases: e.aliases
               }]));
-              await buildEntityEmbeddingsIndex(vaultPath, entityMap);
+              activateVault(ctx);
+              await buildEntityEmbeddingsIndex(vp, entityMap);
             }
           }
+          activateVault(ctx);
           loadEntityEmbeddingsToMemory();
           setEmbeddingsBuildState("complete");
           serverLog("semantic", "Embeddings ready \u2014 searches now use hybrid ranking");
@@ -23099,11 +23145,9 @@ async function runPostIndexWork(index) {
           serverLog("semantic", `Embeddings build failed after ${MAX_BUILD_RETRIES} attempts: ${msg}`, "error");
           serverLog("semantic", "Keyword search (BM25) remains fully available", "error");
         } finally {
+          activateVault(ctx);
           setEmbeddingsBuilding(false);
-          {
-            const ctx = getActiveVaultContext();
-            if (ctx) ctx.embeddingsBuilding = false;
-          }
+          ctx.embeddingsBuilding = false;
         }
       };
       attemptBuild(1);
@@ -23114,8 +23158,8 @@ async function runPostIndexWork(index) {
   if (process.env.FLYWHEEL_WATCH !== "false") {
     const config = parseWatcherConfig();
     const lastContentHashes = /* @__PURE__ */ new Map();
-    if (stateDb) {
-      const persisted = loadContentHashes(stateDb);
+    if (sd) {
+      const persisted = loadContentHashes(sd);
       for (const [p, h] of persisted) lastContentHashes.set(p, h);
       if (persisted.size > 0) {
         serverLog("watcher", `Loaded ${persisted.size} persisted content hashes`);
@@ -23124,8 +23168,8 @@ async function runPostIndexWork(index) {
     serverLog("watcher", `File watcher enabled (debounce: ${config.debounceMs}ms)`);
     const handleBatch = async (batch) => {
       const vaultPrefixes = /* @__PURE__ */ new Set([
-        vaultPath.replace(/\\/g, "/"),
-        resolvedVaultPath
+        vp.replace(/\\/g, "/"),
+        rvp
       ]);
       const normalizeEventPath = (rawPath) => {
         const normalized = rawPath.replace(/\\/g, "/");
@@ -23176,7 +23220,7 @@ async function runPostIndexWork(index) {
           continue;
         }
         try {
-          const content = await fs33.readFile(path33.join(vaultPath, event.path), "utf-8");
+          const content = await fs33.readFile(path33.join(vp, event.path), "utf-8");
           const hash = createHash3("sha256").update(content).digest("hex").slice(0, 16);
           if (lastContentHashes.get(event.path) === hash) {
             serverLog("watcher", `Hash unchanged, skipping: ${event.path}`);
@@ -23189,25 +23233,25 @@ async function runPostIndexWork(index) {
           filteredEvents.push(event);
         }
       }
-      if (stateDb && (hashUpserts.length || hashDeletes.length)) {
-        saveContentHashBatch(stateDb, hashUpserts, hashDeletes);
+      if (sd && (hashUpserts.length || hashDeletes.length)) {
+        saveContentHashBatch(sd, hashUpserts, hashDeletes);
       }
-      if (batchRenames.length > 0 && stateDb) {
+      if (batchRenames.length > 0 && sd) {
         try {
-          const insertMove = stateDb.db.prepare(`
+          const insertMove = sd.db.prepare(`
               INSERT INTO note_moves (old_path, new_path, old_folder, new_folder)
               VALUES (?, ?, ?, ?)
             `);
-          const renameNoteLinks = stateDb.db.prepare(
+          const renameNoteLinks = sd.db.prepare(
             "UPDATE note_links SET note_path = ? WHERE note_path = ?"
           );
-          const renameNoteTags = stateDb.db.prepare(
+          const renameNoteTags = sd.db.prepare(
             "UPDATE note_tags SET note_path = ? WHERE note_path = ?"
           );
-          const renameNoteLinkHistory = stateDb.db.prepare(
+          const renameNoteLinkHistory = sd.db.prepare(
             "UPDATE note_link_history SET note_path = ? WHERE note_path = ?"
           );
-          const renameWikilinkApplications = stateDb.db.prepare(
+          const renameWikilinkApplications = sd.db.prepare(
             "UPDATE wikilink_applications SET note_path = ? WHERE note_path = ?"
           );
           for (const rename of batchRenames) {
@@ -23222,7 +23266,7 @@ async function runPostIndexWork(index) {
             if (oldHash !== void 0) {
               lastContentHashes.set(rename.newPath, oldHash);
               lastContentHashes.delete(rename.oldPath);
-              renameContentHash(stateDb, rename.oldPath, rename.newPath);
+              renameContentHash(sd, rename.oldPath, rename.newPath);
             }
           }
           serverLog("watcher", `Renames: recorded ${batchRenames.length} move(s) in note_moves`);
@@ -23250,17 +23294,18 @@ async function runPostIndexWork(index) {
       try {
         tracker.start("index_rebuild", { files_changed: filteredEvents.length, changed_paths: changedPaths });
         if (!vaultIndex) {
-          vaultIndex = await buildVaultIndex(vaultPath);
-          serverLog("watcher", `Index rebuilt (full): ${vaultIndex.notes.size} notes, ${vaultIndex.entities.size} entities`);
+          const rebuilt = await buildVaultIndex(vp);
+          updateVaultIndex(rebuilt);
+          serverLog("watcher", `Index rebuilt (full): ${rebuilt.notes.size} notes, ${rebuilt.entities.size} entities`);
         } else {
           const absoluteBatch = {
             ...batch,
             events: filteredEvents.map((e) => ({
               ...e,
-              path: path33.join(vaultPath, e.path)
+              path: path33.join(vp, e.path)
             }))
           };
-          const batchResult = await processBatch(vaultIndex, vaultPath, absoluteBatch);
+          const batchResult = await processBatch(vaultIndex, vp, absoluteBatch);
           serverLog("watcher", `Incremental: ${batchResult.successful}/${batchResult.total} files in ${batchResult.durationMs}ms`);
         }
         updateIndexState("ready");
@@ -23273,20 +23318,20 @@ async function runPostIndexWork(index) {
           serverLog("watcher", `Note moves: ${batchRenames.length} rename(s) recorded`);
         }
         const hubBefore = /* @__PURE__ */ new Map();
-        if (stateDb) {
-          const rows = stateDb.db.prepare("SELECT name, hub_score FROM entities").all();
+        if (sd) {
+          const rows = sd.db.prepare("SELECT name, hub_score FROM entities").all();
           for (const r of rows) hubBefore.set(r.name, r.hub_score);
         }
-        const entitiesBefore = stateDb ? getAllEntitiesFromDb3(stateDb) : [];
+        const entitiesBefore = sd ? getAllEntitiesFromDb3(sd) : [];
         tracker.start("entity_scan", { note_count: vaultIndex.notes.size });
-        await updateEntitiesInStateDb();
-        const entitiesAfter = stateDb ? getAllEntitiesFromDb3(stateDb) : [];
+        await updateEntitiesInStateDb(vp, sd);
+        const entitiesAfter = sd ? getAllEntitiesFromDb3(sd) : [];
         const entityDiff = computeEntityDiff(entitiesBefore, entitiesAfter);
         const categoryChanges = [];
         const descriptionChanges = [];
-        if (stateDb) {
+        if (sd) {
           const beforeMap = new Map(entitiesBefore.map((e) => [e.name, e]));
-          const insertChange = stateDb.db.prepare(
+          const insertChange = sd.db.prepare(
             "INSERT INTO entity_changes (entity, field, old_value, new_value) VALUES (?, ?, ?, ?)"
           );
           for (const after of entitiesAfter) {
@@ -23309,10 +23354,10 @@ async function runPostIndexWork(index) {
         serverLog("watcher", `Entity scan: ${entitiesAfter.length} entities`);
         tracker.start("hub_scores", { entity_count: entitiesAfter.length });
         try {
-          const hubUpdated = await exportHubScores(vaultIndex, stateDb);
+          const hubUpdated = await exportHubScores(vaultIndex, sd);
           const hubDiffs = [];
-          if (stateDb) {
-            const rows = stateDb.db.prepare("SELECT name, hub_score FROM entities").all();
+          if (sd) {
+            const rows = sd.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 });
@@ -23330,7 +23375,7 @@ async function runPostIndexWork(index) {
           const cacheAgeMs = cachedRecency ? Date.now() - (cachedRecency.lastUpdated ?? 0) : Infinity;
           if (cacheAgeMs >= 60 * 60 * 1e3) {
             const entities = entitiesAfter.map((e) => ({ name: e.name, path: e.path, aliases: e.aliases }));
-            const recencyIndex2 = await buildRecencyIndex(vaultPath, entities);
+            const recencyIndex2 = await buildRecencyIndex(vp, entities);
             saveRecencyToStateDb(recencyIndex2);
             tracker.end({ rebuilt: true, entities: recencyIndex2.lastMentioned.size });
             serverLog("watcher", `Recency: rebuilt ${recencyIndex2.lastMentioned.size} entities`);
@@ -23344,19 +23389,15 @@ async function runPostIndexWork(index) {
         }
         tracker.start("cooccurrence", { entity_count: entitiesAfter.length });
         try {
-          const cooccurrenceAgeMs = lastCooccurrenceRebuildAt > 0 ? Date.now() - lastCooccurrenceRebuildAt : Infinity;
+          const cooccurrenceAgeMs = ctx.lastCooccurrenceRebuildAt > 0 ? Date.now() - ctx.lastCooccurrenceRebuildAt : Infinity;
           if (cooccurrenceAgeMs >= 60 * 60 * 1e3) {
             const entityNames = entitiesAfter.map((e) => e.name);
-            const cooccurrenceIdx = await mineCooccurrences(vaultPath, entityNames);
+            const cooccurrenceIdx = await mineCooccurrences(vp, entityNames);
             setCooccurrenceIndex(cooccurrenceIdx);
-            lastCooccurrenceRebuildAt = Date.now();
-            const activeCtx = getActiveVaultContext();
-            if (activeCtx) {
-              activeCtx.cooccurrenceIndex = cooccurrenceIdx;
-              activeCtx.lastCooccurrenceRebuildAt = lastCooccurrenceRebuildAt;
-            }
-            if (stateDb) {
-              saveCooccurrenceToStateDb(stateDb, cooccurrenceIdx);
+            ctx.lastCooccurrenceRebuildAt = Date.now();
+            ctx.cooccurrenceIndex = cooccurrenceIdx;
+            if (sd) {
+              saveCooccurrenceToStateDb(sd, cooccurrenceIdx);
             }
             tracker.end({ rebuilt: true, associations: cooccurrenceIdx._metadata.total_associations });
             serverLog("watcher", `Co-occurrence: rebuilt ${cooccurrenceIdx._metadata.total_associations} associations`);
@@ -23368,17 +23409,13 @@ async function runPostIndexWork(index) {
           tracker.end({ error: String(e) });
           serverLog("watcher", `Co-occurrence: failed: ${e}`);
         }
-        if (stateDb) {
+        if (sd) {
           tracker.start("edge_weights", {});
           try {
-            const edgeWeightAgeMs = lastEdgeWeightRebuildAt > 0 ? Date.now() - lastEdgeWeightRebuildAt : Infinity;
+            const edgeWeightAgeMs = ctx.lastEdgeWeightRebuildAt > 0 ? Date.now() - ctx.lastEdgeWeightRebuildAt : Infinity;
             if (edgeWeightAgeMs >= 60 * 60 * 1e3) {
-              const result = recomputeEdgeWeights(stateDb);
-              lastEdgeWeightRebuildAt = Date.now();
-              {
-                const activeCtx = getActiveVaultContext();
-                if (activeCtx) activeCtx.lastEdgeWeightRebuildAt = lastEdgeWeightRebuildAt;
-              }
+              const result = recomputeEdgeWeights(sd);
+              ctx.lastEdgeWeightRebuildAt = Date.now();
               tracker.end({
                 rebuilt: true,
                 edges: result.edges_updated,
@@ -23408,7 +23445,7 @@ async function runPostIndexWork(index) {
                 removeEmbedding(event.path);
                 embRemoved++;
               } else if (event.path.endsWith(".md")) {
-                const absPath = path33.join(vaultPath, event.path);
+                const absPath = path33.join(vp, event.path);
                 await updateEmbedding(event.path, absPath);
                 embUpdated++;
               }
@@ -23420,12 +23457,12 @@ async function runPostIndexWork(index) {
         } else {
           tracker.skip("note_embeddings", "not built");
         }
-        if (hasEntityEmbeddingsIndex() && stateDb) {
+        if (hasEntityEmbeddingsIndex() && sd) {
           tracker.start("entity_embeddings", { files: filteredEvents.length });
           let entEmbUpdated = 0;
           const entEmbNames = [];
           try {
-            const allEntities = getAllEntitiesFromDb3(stateDb);
+            const allEntities = getAllEntitiesFromDb3(sd);
             for (const event of filteredEvents) {
               if (event.type === "delete" || !event.path.endsWith(".md")) continue;
               const matching = allEntities.filter((e) => e.path === event.path);
@@ -23435,7 +23472,7 @@ async function runPostIndexWork(index) {
                   path: entity.path,
                   category: entity.category,
                   aliases: entity.aliases
-                }, vaultPath);
+                }, vp);
                 entEmbUpdated++;
                 entEmbNames.push(entity.name);
               }
@@ -23445,12 +23482,12 @@ async function runPostIndexWork(index) {
           tracker.end({ updated: entEmbUpdated, updated_entities: entEmbNames.slice(0, 10) });
           serverLog("watcher", `Entity embeddings: ${entEmbUpdated} updated`);
         } else {
-          tracker.skip("entity_embeddings", !stateDb ? "no stateDb" : "not built");
+          tracker.skip("entity_embeddings", !sd ? "no sd" : "not built");
         }
-        if (stateDb) {
+        if (sd) {
           tracker.start("index_cache", { note_count: vaultIndex.notes.size });
           try {
-            saveVaultIndexToCache(stateDb, vaultIndex);
+            saveVaultIndexToCache(sd, vaultIndex);
             tracker.end({ saved: true });
             serverLog("watcher", "Index cache saved");
           } catch (err) {
@@ -23458,7 +23495,7 @@ async function runPostIndexWork(index) {
             serverLog("index", `Failed to update index cache: ${err instanceof Error ? err.message : err}`, "error");
           }
         } else {
-          tracker.skip("index_cache", "no stateDb");
+          tracker.skip("index_cache", "no sd");
         }
         tracker.start("task_cache", { files: filteredEvents.length });
         let taskUpdated = 0;
@@ -23469,7 +23506,7 @@ async function runPostIndexWork(index) {
               removeTaskCacheForFile(event.path);
               taskRemoved++;
             } else if (event.path.endsWith(".md")) {
-              await updateTaskCacheForFile(vaultPath, event.path);
+              await updateTaskCacheForFile(vp, event.path);
               taskUpdated++;
             }
           } catch {
@@ -23507,19 +23544,19 @@ async function runPostIndexWork(index) {
             } catch {
             }
           }
-          if (stateDb) {
-            const upsertHistory = stateDb.db.prepare(`
+          if (sd) {
+            const upsertHistory = sd.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 = sd.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 = sd.db.prepare(`
               UPDATE note_link_history SET last_positive_at = datetime('now') WHERE note_path = ? AND target = ?
             `);
-            const getEdgeCount = stateDb.db.prepare(
+            const getEdgeCount = sd.db.prepare(
               "SELECT edits_survived FROM note_link_history WHERE note_path=? AND target=?"
             );
             for (const entry of forwardLinkResults) {
@@ -23527,16 +23564,16 @@ async function runPostIndexWork(index) {
                 ...entry.resolved.map((n) => n.toLowerCase()),
                 ...entry.dead.map((n) => n.toLowerCase())
               ]);
-              const previousSet = getStoredNoteLinks(stateDb, entry.file);
+              const previousSet = getStoredNoteLinks(sd, entry.file);
               if (previousSet.size === 0) {
-                updateStoredNoteLinks(stateDb, entry.file, currentSet);
+                updateStoredNoteLinks(sd, 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);
+              updateStoredNoteLinks(sd, entry.file, currentSet);
               if (diff.removed.length === 0) continue;
               for (const link of currentSet) {
                 if (!previousSet.has(link)) continue;
@@ -23551,7 +23588,7 @@ async function runPostIndexWork(index) {
                     (e) => e.nameLower === link || (e.aliases ?? []).some((a) => a.toLowerCase() === link)
                   );
                   if (entity) {
-                    recordFeedback(stateDb, entity.name, "implicit:kept", entry.file, true, 0.8);
+                    recordFeedback(sd, entity.name, "implicit:kept", entry.file, true, 0.8);
                     markPositive.run(entry.file, link);
                   }
                 }
@@ -23559,10 +23596,10 @@ async function runPostIndexWork(index) {
             }
             for (const event of filteredEvents) {
               if (event.type === "delete") {
-                const previousSet = getStoredNoteLinks(stateDb, event.path);
+                const previousSet = getStoredNoteLinks(sd, event.path);
                 if (previousSet.size > 0) {
                   linkDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
-                  updateStoredNoteLinks(stateDb, event.path, /* @__PURE__ */ new Set());
+                  updateStoredNoteLinks(sd, event.path, /* @__PURE__ */ new Set());
                 }
               }
             }
@@ -23570,10 +23607,10 @@ async function runPostIndexWork(index) {
             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);
+              const previousSet = getStoredNoteLinks(sd, event.path);
               if (previousSet.size > 0) {
                 linkDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
-                updateStoredNoteLinks(stateDb, event.path, /* @__PURE__ */ new Set());
+                updateStoredNoteLinks(sd, event.path, /* @__PURE__ */ new Set());
               }
             }
           }
@@ -23599,11 +23636,11 @@ async function runPostIndexWork(index) {
         }
         tracker.start("wikilink_check", { files: filteredEvents.length });
         const trackedLinks = [];
-        if (stateDb) {
+        if (sd) {
           for (const event of filteredEvents) {
             if (event.type === "delete" || !event.path.endsWith(".md")) continue;
             try {
-              const apps = getTrackedApplications(stateDb, event.path);
+              const apps = getTrackedApplications(sd, event.path);
               if (apps.length > 0) trackedLinks.push({ file: event.path, entities: apps });
             } catch {
             }
@@ -23628,7 +23665,7 @@ async function runPostIndexWork(index) {
         for (const event of filteredEvents) {
           if (event.type === "delete" || !event.path.endsWith(".md")) continue;
           try {
-            const content = await fs33.readFile(path33.join(vaultPath, event.path), "utf-8");
+            const content = await fs33.readFile(path33.join(vp, event.path), "utf-8");
             const zones = getProtectedZones2(content);
             const linked = new Set(
               (forwardLinkResults.find((r) => r.file === event.path)?.resolved ?? []).map((n) => n.toLowerCase())
@@ -23636,7 +23673,7 @@ async function runPostIndexWork(index) {
             const mentions = [];
             for (const entity of entitiesAfter) {
               if (linked.has(entity.nameLower)) continue;
-              if (stateDb && isSuppressed(stateDb, entity.name)) continue;
+              if (sd && isSuppressed(sd, entity.name)) continue;
               const matches = findEntityMatches2(content, entity.name, true);
               const valid = matches.some((m) => !rangeOverlapsProtectedZone(m.start, m.end, zones));
               if (valid) {
@@ -23663,20 +23700,20 @@ async function runPostIndexWork(index) {
         const deletedFiles = new Set(
           filteredEvents.filter((e) => e.type === "delete").map((e) => e.path)
         );
-        const preSuppressed = stateDb ? new Set(getAllSuppressionPenalties(stateDb).keys()) : /* @__PURE__ */ new Set();
+        const preSuppressed = sd ? new Set(getAllSuppressionPenalties(sd).keys()) : /* @__PURE__ */ new Set();
         const feedbackResults = [];
-        if (stateDb) {
+        if (sd) {
           for (const event of filteredEvents) {
             if (event.type === "delete" || !event.path.endsWith(".md")) continue;
             try {
-              const content = await fs33.readFile(path33.join(vaultPath, event.path), "utf-8");
-              const removed = processImplicitFeedback(stateDb, event.path, content);
+              const content = await fs33.readFile(path33.join(vp, event.path), "utf-8");
+              const removed = processImplicitFeedback(sd, event.path, content);
               for (const entity of removed) feedbackResults.push({ entity, file: event.path });
             } catch {
             }
           }
         }
-        if (stateDb && linkDiffs.length > 0) {
+        if (sd && linkDiffs.length > 0) {
           for (const diff of linkDiffs) {
             if (deletedFiles.has(diff.file)) continue;
             for (const target of diff.removed) {
@@ -23685,15 +23722,15 @@ async function runPostIndexWork(index) {
                 (e) => e.nameLower === target || (e.aliases ?? []).some((a) => a.toLowerCase() === target)
               );
               if (entity) {
-                recordFeedback(stateDb, entity.name, "implicit:removed", diff.file, false);
+                recordFeedback(sd, entity.name, "implicit:removed", diff.file, false);
                 feedbackResults.push({ entity: entity.name, file: diff.file });
               }
             }
           }
         }
         const additionResults = [];
-        if (stateDb && linkDiffs.length > 0) {
-          const checkApplication = stateDb.db.prepare(
+        if (sd && linkDiffs.length > 0) {
+          const checkApplication = sd.db.prepare(
             `SELECT 1 FROM wikilink_applications WHERE LOWER(entity) = LOWER(?) AND note_path = ? AND status = 'applied'`
           );
           for (const diff of linkDiffs) {
@@ -23704,15 +23741,15 @@ async function runPostIndexWork(index) {
                 (e) => e.nameLower === target || (e.aliases ?? []).some((a) => a.toLowerCase() === target)
               );
               if (entity) {
-                recordFeedback(stateDb, entity.name, "implicit:manual_added", diff.file, true);
+                recordFeedback(sd, entity.name, "implicit:manual_added", diff.file, true);
                 additionResults.push({ entity: entity.name, file: diff.file });
               }
             }
           }
         }
         const newlySuppressed = [];
-        if (stateDb) {
-          const postSuppressed = getAllSuppressionPenalties(stateDb);
+        if (sd) {
+          const postSuppressed = getAllSuppressionPenalties(sd);
           for (const entity of postSuppressed.keys()) {
             if (!preSuppressed.has(entity)) {
               newlySuppressed.push(entity);
@@ -23728,10 +23765,10 @@ async function runPostIndexWork(index) {
         }
         tracker.start("corrections", {});
         try {
-          if (stateDb) {
-            const corrProcessed = processPendingCorrections(stateDb);
+          if (sd) {
+            const corrProcessed = processPendingCorrections(sd);
             if (corrProcessed > 0) {
-              updateSuppressionList(stateDb);
+              updateSuppressionList(sd);
             }
             tracker.end({ processed: corrProcessed });
             if (corrProcessed > 0) {
@@ -23749,7 +23786,7 @@ async function runPostIndexWork(index) {
         for (const event of filteredEvents) {
           if (event.type === "delete" || !event.path.endsWith(".md")) continue;
           try {
-            const content = await fs33.readFile(path33.join(vaultPath, event.path), "utf-8");
+            const content = await fs33.readFile(path33.join(vp, event.path), "utf-8");
             const zones = getProtectedZones2(content);
             const linkedSet = new Set(
               (forwardLinkResults.find((r) => r.file === event.path)?.resolved ?? []).concat(forwardLinkResults.find((r) => r.file === event.path)?.dead ?? []).map((n) => n.toLowerCase())
@@ -23782,7 +23819,7 @@ async function runPostIndexWork(index) {
         for (const event of filteredEvents) {
           if (event.type === "delete" || !event.path.endsWith(".md")) continue;
           try {
-            const rawContent = await fs33.readFile(path33.join(vaultPath, event.path), "utf-8");
+            const rawContent = await fs33.readFile(path33.join(vp, event.path), "utf-8");
             const content = rawContent.replace(/ → \[\[.*$/gm, "");
             const result = await suggestRelatedLinks(content, {
               maxSuggestions: 5,
@@ -23812,7 +23849,7 @@ async function runPostIndexWork(index) {
             const proactiveResults = [];
             for (const { file, top } of suggestionResults) {
               try {
-                const result = await applyProactiveSuggestions(file, vaultPath, top, {
+                const result = await applyProactiveSuggestions(file, vp, top, {
                   minScore: flywheelConfig?.proactive_min_score ?? 20,
                   maxPerFile: flywheelConfig?.proactive_max_per_file ?? 3
                 });
@@ -23835,7 +23872,7 @@ async function runPostIndexWork(index) {
         tracker.start("tag_scan", { files: filteredEvents.length });
         try {
           const tagDiffs = [];
-          if (stateDb) {
+          if (sd) {
             const noteTagsForward = /* @__PURE__ */ new Map();
             for (const [tag, paths] of vaultIndex.tags) {
               for (const notePath of paths) {
@@ -23846,9 +23883,9 @@ async function runPostIndexWork(index) {
             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);
+              const previousSet = getStoredNoteTags(sd, event.path);
               if (previousSet.size === 0 && currentSet.size > 0) {
-                updateStoredNoteTags(stateDb, event.path, currentSet);
+                updateStoredNoteTags(sd, event.path, currentSet);
                 continue;
               }
               const added = [...currentSet].filter((t) => !previousSet.has(t));
@@ -23856,14 +23893,14 @@ async function runPostIndexWork(index) {
               if (added.length > 0 || removed.length > 0) {
                 tagDiffs.push({ file: event.path, added, removed });
               }
-              updateStoredNoteTags(stateDb, event.path, currentSet);
+              updateStoredNoteTags(sd, event.path, currentSet);
             }
             for (const event of filteredEvents) {
               if (event.type === "delete") {
-                const previousSet = getStoredNoteTags(stateDb, event.path);
+                const previousSet = getStoredNoteTags(sd, event.path);
                 if (previousSet.size > 0) {
                   tagDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
-                  updateStoredNoteTags(stateDb, event.path, /* @__PURE__ */ new Set());
+                  updateStoredNoteTags(sd, event.path, /* @__PURE__ */ new Set());
                 }
               }
             }
@@ -23880,22 +23917,22 @@ async function runPostIndexWork(index) {
         }
         tracker.start("retrieval_cooccurrence", {});
         try {
-          if (stateDb) {
-            const inserted = mineRetrievalCooccurrence(stateDb);
+          if (sd) {
+            const inserted = mineRetrievalCooccurrence(sd);
             tracker.end({ pairs_inserted: inserted });
             if (inserted > 0) {
               serverLog("watcher", `Retrieval co-occurrence: ${inserted} new pairs`);
             }
           } else {
-            tracker.end({ skipped: "no stateDb" });
+            tracker.end({ skipped: "no sd" });
           }
         } catch (e) {
           tracker.end({ error: String(e) });
           serverLog("watcher", `Retrieval co-occurrence: failed: ${e}`, "error");
         }
         const duration = Date.now() - batchStart;
-        if (stateDb) {
-          recordIndexEvent(stateDb, {
+        if (sd) {
+          recordIndexEvent(sd, {
             trigger: "watcher",
             duration_ms: duration,
             note_count: vaultIndex.notes.size,
@@ -23908,8 +23945,8 @@ async function runPostIndexWork(index) {
       } catch (err) {
         updateIndexState("error", err instanceof Error ? err : new Error(String(err)));
         const duration = Date.now() - batchStart;
-        if (stateDb) {
-          recordIndexEvent(stateDb, {
+        if (sd) {
+          recordIndexEvent(sd, {
             trigger: "watcher",
             duration_ms: duration,
             success: false,
@@ -23923,7 +23960,7 @@ async function runPostIndexWork(index) {
       }
     };
     const watcher = createVaultWatcher({
-      vaultPath,
+      vaultPath: vp,
       config,
       onBatch: handleBatch,
       onStateChange: (status) => {
@@ -23935,11 +23972,12 @@ async function runPostIndexWork(index) {
         serverLog("watcher", `Watcher error: ${err.message}`, "error");
       }
     });
+    ctx.watcher = watcher;
     watcherInstance = watcher;
-    if (stateDb) {
-      const lastPipelineEvent = getRecentPipelineEvent(stateDb);
+    if (sd) {
+      const lastPipelineEvent = getRecentPipelineEvent(sd);
       if (lastPipelineEvent) {
-        const catchupEvents = await buildStartupCatchupBatch(vaultPath, lastPipelineEvent.timestamp);
+        const catchupEvents = await buildStartupCatchupBatch(vp, lastPipelineEvent.timestamp);
         if (catchupEvents.length > 0) {
           console.error(`[Flywheel] Startup catch-up: ${catchupEvents.length} file(s) modified while offline`);
           await handleBatch({ events: catchupEvents, renames: [], timestamp: Date.now() });
@@ -23950,8 +23988,8 @@ async function runPostIndexWork(index) {
     serverLog("watcher", "File watcher started");
   }
   if (process.env.FLYWHEEL_WATCH !== "false") {
-    startSweepTimer(() => vaultIndex, void 0, () => {
-      if (stateDb) runPeriodicMaintenance(stateDb);
+    startSweepTimer(() => ctx.vaultIndex, void 0, () => {
+      if (sd) runPeriodicMaintenance(sd);
     });
     serverLog("server", "Sweep timer started (5 min interval)");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.129",
+  "version": "2.0.131",
   "description": "MCP server that gives Claude full read/write access to your Obsidian vault. Select from 69 tools for search, backlinks, graph queries, mutations, agent memory, and hybrid semantic search.",
   "type": "module",
   "main": "dist/index.js",
@@ -53,7 +53,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@velvetmonkey/vault-core": "2.0.129",
+    "@velvetmonkey/vault-core": "2.0.131",
     "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",