@velvetmonkey/flywheel-memory 2.5.9 → 2.5.10

package/dist/index.js

@@ -2672,10 +2672,10 @@ function isLockContentionError(error) {
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-function calculateDelay(attempt, config) {
-  let delay = config.baseDelayMs * Math.pow(2, attempt);
-  delay = Math.min(delay, config.maxDelayMs);
-  if (config.jitter) {
+function calculateDelay(attempt, config2) {
+  let delay = config2.baseDelayMs * Math.pow(2, attempt);
+  delay = Math.min(delay, config2.maxDelayMs);
+  if (config2.jitter) {
     delay = delay + Math.random() * delay * 0.5;
   }
   return Math.round(delay);
@@ -3569,8 +3569,8 @@ function setWriteStateDb(stateDb2) {
 function getWriteStateDb() {
   return getActiveScopeOrNull()?.stateDb ?? moduleStateDb5;
 }
-function setWikilinkConfig(config) {
-  moduleConfig = config;
+function setWikilinkConfig(config2) {
+  moduleConfig = config2;
 }
 function getConfig() {
   const scope = getActiveScopeOrNull();
@@ -3938,9 +3938,9 @@ function isCommonWordFalsePositive(entityName, rawContent, category) {
   if (!IMPLICIT_EXCLUDE_WORDS.has(lowerName) && !COMMON_ENGLISH_WORDS.has(lowerName)) return false;
   return !rawContent.includes(entityName);
 }
-function capScoreWithoutContentRelevance(score, contentRelevance, config) {
-  if (contentRelevance < config.contentRelevanceFloor) {
-    return Math.min(score, config.noRelevanceCap);
+function capScoreWithoutContentRelevance(score, contentRelevance, config2) {
+  if (contentRelevance < config2.contentRelevanceFloor) {
+    return Math.min(score, config2.noRelevanceCap);
   }
   return score;
 }
@@ -3988,7 +3988,7 @@ function getAdaptiveMinScore(contentLength, baseScore) {
   }
   return baseScore;
 }
-function scoreNameAgainstContent(name, contentTokens, contentStems, config, coocIndex, disableExact, disableStem) {
+function scoreNameAgainstContent(name, contentTokens, contentStems, config2, coocIndex, disableExact, disableStem) {
   const nameTokens = tokenize(name);
   if (nameTokens.length === 0) {
     return { exactScore: 0, stemScore: 0, lexicalScore: 0, matchedWords: 0, exactMatches: 0, totalTokens: 0, nameTokens: [], unmatchedTokenIndices: [] };
@@ -4004,11 +4004,11 @@ function scoreNameAgainstContent(name, contentTokens, contentStems, config, cooc
     const nameStem = nameStems[i];
     const idfWeight = coocIndex ? tokenIdf(token, coocIndex) : 1;
     if (!disableExact && contentTokens.has(token)) {
-      exactScore += config.exactMatchBonus * idfWeight;
+      exactScore += config2.exactMatchBonus * idfWeight;
       matchedWords++;
       exactMatches++;
     } else if (!disableStem && contentStems.has(nameStem)) {
-      stemScore += config.stemMatchBonus * idfWeight;
+      stemScore += config2.stemMatchBonus * idfWeight;
       matchedWords++;
     } else {
       unmatchedTokenIndices.push(i);
@@ -4017,7 +4017,7 @@ function scoreNameAgainstContent(name, contentTokens, contentStems, config, cooc
   const lexicalScore = Math.round((exactScore + stemScore) * 10) / 10;
   return { exactScore, stemScore, lexicalScore, matchedWords, exactMatches, totalTokens: nameTokens.length, nameTokens, unmatchedTokenIndices };
 }
-function scoreEntity(entity, contentTokens, contentStems, collapsedContentTerms, config, disabled, coocIndex, tokenFuzzyCache) {
+function scoreEntity(entity, contentTokens, contentStems, collapsedContentTerms, config2, disabled, coocIndex, tokenFuzzyCache) {
   const zero = { contentMatch: 0, fuzzyMatch: 0, totalLexical: 0, matchedWords: 0, exactMatches: 0, totalTokens: 0 };
   const entityName = getEntityName2(entity);
   const aliases = getEntityAliases(entity);
@@ -4026,10 +4026,10 @@ function scoreEntity(entity, contentTokens, contentStems, collapsedContentTerms,
   const disableFuzzy = disabled.has("fuzzy_match");
   const cache = tokenFuzzyCache ?? /* @__PURE__ */ new Map();
   const idfFn = (token) => coocIndex ? tokenIdf(token, coocIndex) : 1;
-  const nameResult = scoreNameAgainstContent(entityName, contentTokens, contentStems, config, coocIndex, disableExact, disableStem);
+  const nameResult = scoreNameAgainstContent(entityName, contentTokens, contentStems, config2, coocIndex, disableExact, disableStem);
   let bestAliasResult = { exactScore: 0, stemScore: 0, lexicalScore: 0, matchedWords: 0, exactMatches: 0, totalTokens: 0, nameTokens: [], unmatchedTokenIndices: [] };
   for (const alias of aliases) {
-    const aliasResult = scoreNameAgainstContent(alias, contentTokens, contentStems, config, coocIndex, disableExact, disableStem);
+    const aliasResult = scoreNameAgainstContent(alias, contentTokens, contentStems, config2, coocIndex, disableExact, disableStem);
     if (aliasResult.lexicalScore > bestAliasResult.lexicalScore) {
       bestAliasResult = aliasResult;
     }
@@ -4056,7 +4056,7 @@ function scoreEntity(entity, contentTokens, contentStems, collapsedContentTerms,
       contentTokens,
       collapsedContentTerms,
       fuzzyTargetName,
-      config.fuzzyMatchBonus,
+      config2.fuzzyMatchBonus,
       idfFn,
       cache
     );
@@ -4070,11 +4070,11 @@ function scoreEntity(entity, contentTokens, contentStems, collapsedContentTerms,
   }
   if (totalTokens > 1) {
     const matchRatio = matchedWords / totalTokens;
-    if (matchRatio < config.minMatchRatio) {
+    if (matchRatio < config2.minMatchRatio) {
       return zero;
     }
   }
-  if (config.requireMultipleMatches && totalTokens === 1) {
+  if (config2.requireMultipleMatches && totalTokens === 1) {
     if (exactMatches === 0 && fuzzyMatchedWords === 0) {
       return zero;
     }
@@ -4105,8 +4105,8 @@ async function suggestRelatedLinks(content, options = {}) {
     disabledLayers = []
   } = options;
   const disabled = new Set(disabledLayers);
-  const config = STRICTNESS_CONFIGS[strictness];
-  const adaptiveMinScore = getAdaptiveMinScore(content.length, config.minSuggestionScore);
+  const config2 = STRICTNESS_CONFIGS[strictness];
+  const adaptiveMinScore = getAdaptiveMinScore(content.length, config2.minSuggestionScore);
   const noteContext = notePath ? getNoteContext(notePath) : "general";
   const contextBoosts = CONTEXT_BOOST[noteContext];
   const emptyResult = { suggestions: [], suffix: "" };
@@ -4128,7 +4128,7 @@ async function suggestRelatedLinks(content, options = {}) {
   const contentTokens = /* @__PURE__ */ new Set();
   const contentStems = /* @__PURE__ */ new Set();
   for (const token of rawTokens) {
-    if (token.length >= config.minWordLength && !STOPWORDS_EN2.has(token)) {
+    if (token.length >= config2.minWordLength && !STOPWORDS_EN2.has(token)) {
       contentTokens.add(token);
       contentStems.add(stem(token));
     }
@@ -4136,7 +4136,7 @@ async function suggestRelatedLinks(content, options = {}) {
   if (contentTokens.size === 0) {
     return emptyResult;
   }
-  const orderedContentTokens = [...rawTokens].filter((token) => token.length >= config.minWordLength && !STOPWORDS_EN2.has(token)).map(normalizeFuzzyTerm).filter((token) => token.length > 0);
+  const orderedContentTokens = [...rawTokens].filter((token) => token.length >= config2.minWordLength && !STOPWORDS_EN2.has(token)).map(normalizeFuzzyTerm).filter((token) => token.length > 0);
   const collapsedContentTerms = disabled.has("fuzzy_match") ? /* @__PURE__ */ new Set() : buildCollapsedContentTerms(orderedContentTokens);
   const tokenFuzzyCache = /* @__PURE__ */ new Map();
   const linkedEntities = excludeLinked ? extractLinkedEntities(content) : /* @__PURE__ */ new Set();
@@ -4167,7 +4167,7 @@ async function suggestRelatedLinks(content, options = {}) {
       const paths = correctedPairs.get(entityName.toLowerCase());
       if (paths.has(notePath)) continue;
     }
-    const entityScore = disabled.has("exact_match") && disabled.has("stem_match") && disabled.has("fuzzy_match") ? { contentMatch: 0, fuzzyMatch: 0, totalLexical: 0, matchedWords: 0, exactMatches: 0, totalTokens: 0 } : scoreEntity(entity, contentTokens, contentStems, collapsedContentTerms, config, disabled, cooccurrenceIndex, tokenFuzzyCache);
+    const entityScore = disabled.has("exact_match") && disabled.has("stem_match") && disabled.has("fuzzy_match") ? { contentMatch: 0, fuzzyMatch: 0, totalLexical: 0, matchedWords: 0, exactMatches: 0, totalTokens: 0 } : scoreEntity(entity, contentTokens, contentStems, collapsedContentTerms, config2, disabled, cooccurrenceIndex, tokenFuzzyCache);
     const contentScore = entityScore.contentMatch;
     const fuzzyMatchScore = entityScore.fuzzyMatch;
     const hasLexicalEvidence = entityScore.totalLexical > 0;
@@ -4204,7 +4204,7 @@ async function suggestRelatedLinks(content, options = {}) {
     }
     const layerSuppressionPenalty = disabled.has("feedback") ? 0 : suppressionPenalties.get(entityName) ?? 0;
     score += layerSuppressionPenalty;
-    score = capScoreWithoutContentRelevance(score, contentScore + fuzzyMatchScore, config);
+    score = capScoreWithoutContentRelevance(score, contentScore + fuzzyMatchScore, config2);
     if (hasLexicalEvidence && score >= adaptiveMinScore) {
       scoredEntities.push({
         name: entityName,
@@ -4271,13 +4271,13 @@ async function suggestRelatedLinks(content, options = {}) {
           existing.score += boost;
           existing.breakdown.cooccurrenceBoost += boost;
           const existingContentRelevance = existing.breakdown.contentMatch + existing.breakdown.fuzzyMatch + (existing.breakdown.semanticBoost ?? 0);
-          existing.score = capScoreWithoutContentRelevance(existing.score, existingContentRelevance, config);
+          existing.score = capScoreWithoutContentRelevance(existing.score, existingContentRelevance, config2);
         } else {
           const entityTokens = tokenize(entityName);
           const hasContentOverlap = entityTokens.some(
             (token) => contentTokens.has(token) || contentStems.has(stem(token))
           );
-          const strongCooccurrence = boost >= config.minCooccurrenceGate;
+          const strongCooccurrence = boost >= config2.minCooccurrenceGate;
           if (!hasContentOverlap && !strongCooccurrence) {
             continue;
           }
@@ -4297,7 +4297,7 @@ async function suggestRelatedLinks(content, options = {}) {
           const suppPenalty = disabled.has("feedback") ? 0 : suppressionPenalties.get(entityName) ?? 0;
           let totalBoost = boost + typeBoost + contextBoost + recencyBoostVal + crossFolderBoost + hubBoost + feedbackAdj + edgeWeightBoost + prospectBoost + suppPenalty;
           const coocContentRelevance = hasContentOverlap ? 5 : 0;
-          totalBoost = capScoreWithoutContentRelevance(totalBoost, coocContentRelevance, config);
+          totalBoost = capScoreWithoutContentRelevance(totalBoost, coocContentRelevance, config2);
           const effectiveMinScore = !hasContentOverlap ? Math.max(adaptiveMinScore, 7) : adaptiveMinScore;
           if (totalBoost >= effectiveMinScore) {
             scoredEntities.push({
@@ -4393,11 +4393,11 @@ async function suggestRelatedLinks(content, options = {}) {
   }
   for (const entry of scoredEntities) {
     const contentRelevance = entry.breakdown.contentMatch + entry.breakdown.fuzzyMatch + (entry.breakdown.semanticBoost ?? 0);
-    entry.score = capScoreWithoutContentRelevance(entry.score, contentRelevance, config);
+    entry.score = capScoreWithoutContentRelevance(entry.score, contentRelevance, config2);
   }
   const relevantEntities = scoredEntities.filter((e) => {
     if (!entitiesWithAnyScoringPath.has(e.name)) return false;
-    if (config.minContentMatch > 0 && e.breakdown.contentMatch < config.minContentMatch) return false;
+    if (config2.minContentMatch > 0 && e.breakdown.contentMatch < config2.minContentMatch) return false;
     return true;
   });
   if (relevantEntities.length === 0) {
@@ -4664,9 +4664,9 @@ async function checkPreflightSimilarity(noteName) {
   }
   return result;
 }
-async function applyProactiveSuggestions(filePath, vaultPath2, suggestions, config) {
+async function applyProactiveSuggestions(filePath, vaultPath2, suggestions, config2) {
   const stateDb2 = getWriteStateDb();
-  const candidates = suggestions.filter((s) => s.score >= config.minScore && s.confidence === "high").slice(0, config.maxPerFile);
+  const candidates = suggestions.filter((s) => s.score >= config2.minScore && s.confidence === "high").slice(0, config2.maxPerFile);
   if (candidates.length === 0) {
     return { applied: [], skipped: [] };
   }
@@ -4973,7 +4973,7 @@ function enqueueProactiveSuggestions(stateDb2, entries) {
   }
   return enqueued;
 }
-async function drainProactiveQueue(stateDb2, vaultPath2, config, applyFn) {
+async function drainProactiveQueue(stateDb2, vaultPath2, config2, applyFn) {
   const result = {
     applied: [],
     expired: 0,
@@ -5017,7 +5017,7 @@ async function drainProactiveQueue(stateDb2, vaultPath2, config, applyFn) {
       continue;
     }
     const todayCount = countTodayApplied.get(filePath, todayStr).cnt;
-    if (todayCount >= config.maxPerDay) {
+    if (todayCount >= config2.maxPerDay) {
       result.skippedDailyCap += suggestions.length;
       for (const s of suggestions) {
         try {
@@ -5029,10 +5029,10 @@ async function drainProactiveQueue(stateDb2, vaultPath2, config, applyFn) {
       }
       continue;
     }
-    const remaining = config.maxPerDay - todayCount;
+    const remaining = config2.maxPerDay - todayCount;
     const capped = suggestions.slice(0, remaining);
     try {
-      const applyResult = await applyFn(filePath, vaultPath2, capped, config);
+      const applyResult = await applyFn(filePath, vaultPath2, capped, config2);
       if (applyResult.applied.length > 0) {
         result.applied.push({ file: filePath, entities: applyResult.applied });
         const appliedAt = Date.now();
@@ -7375,21 +7375,21 @@ var DEFAULT_CONFIG = {
   implicit_detection: true,
   adaptive_strictness: true
 };
-function migrateExcludeConfig(config) {
+function migrateExcludeConfig(config2) {
   const oldTags = [
-    ...config.exclude_task_tags ?? [],
-    ...config.exclude_analysis_tags ?? []
+    ...config2.exclude_task_tags ?? [],
+    ...config2.exclude_analysis_tags ?? []
   ];
-  const oldEntities = config.exclude_entities ?? [];
-  if (oldTags.length === 0 && oldEntities.length === 0) return config;
+  const oldEntities = config2.exclude_entities ?? [];
+  if (oldTags.length === 0 && oldEntities.length === 0) return config2;
   const normalizedTags = oldTags.map((t) => t.startsWith("#") ? t : `#${t}`);
   const merged = /* @__PURE__ */ new Set([
-    ...config.exclude ?? [],
+    ...config2.exclude ?? [],
     ...normalizedTags,
     ...oldEntities
   ]);
   return {
-    ...config,
+    ...config2,
     exclude: Array.from(merged),
     // Clear deprecated fields
     exclude_task_tags: void 0,
@@ -7488,11 +7488,11 @@ function inferConfig(index, vaultPath2) {
   }
   return inferred;
 }
-function getExcludeTags(config) {
-  return (config.exclude ?? []).filter((e) => e.startsWith("#")).map((e) => e.slice(1));
+function getExcludeTags(config2) {
+  return (config2.exclude ?? []).filter((e) => e.startsWith("#")).map((e) => e.slice(1));
 }
-function getExcludeEntities(config) {
-  return (config.exclude ?? []).filter((e) => !e.startsWith("#"));
+function getExcludeEntities(config2) {
+  return (config2.exclude ?? []).filter((e) => !e.startsWith("#"));
 }
 var TEMPLATE_PATTERNS = {
   daily: /^daily[\s._-]*(note|template)?\.md$/i,
@@ -7812,8 +7812,8 @@ var EventQueue = class {
   config;
   flushTimer = null;
   onBatch;
-  constructor(config, onBatch) {
-    this.config = config;
+  constructor(config2, onBatch) {
+    this.config = config2;
     this.onBatch = onBatch;
   }
   /**
@@ -8226,7 +8226,7 @@ init_serverLog();
 // src/core/read/watch/index.ts
 function createVaultWatcher(options) {
   const { vaultPath: vaultPath2, onBatch, onStateChange, onError } = options;
-  const config = {
+  const config2 = {
     ...DEFAULT_WATCHER_CONFIG,
     ...parseWatcherConfig(),
     ...options.config
@@ -8271,7 +8271,7 @@ function createVaultWatcher(options) {
       }
     }
   };
-  const eventQueue = new EventQueue(config, processBatch2);
+  const eventQueue = new EventQueue(config2, processBatch2);
   const instance = {
     get status() {
       return getStatus();
@@ -8284,8 +8284,8 @@ function createVaultWatcher(options) {
         console.error("[flywheel] Watcher already started");
         return;
       }
-      console.error(`[flywheel] Starting file watcher (debounce: ${config.debounceMs}ms, flush: ${config.flushMs}ms)`);
-      console.error(`[flywheel] Chokidar options: usePolling=${config.usePolling}, interval=${config.pollInterval}, vaultPath=${vaultPath2}`);
+      console.error(`[flywheel] Starting file watcher (debounce: ${config2.debounceMs}ms, flush: ${config2.flushMs}ms)`);
+      console.error(`[flywheel] Chokidar options: usePolling=${config2.usePolling}, interval=${config2.pollInterval}, vaultPath=${vaultPath2}`);
       watcher = chokidar.watch(vaultPath2, {
         ignored: createIgnoreFunction(vaultPath2),
         persistent: true,
@@ -8294,8 +8294,8 @@ function createVaultWatcher(options) {
           stabilityThreshold: 300,
           pollInterval: 100
         },
-        usePolling: config.usePolling,
-        interval: config.usePolling ? config.pollInterval : void 0
+        usePolling: config2.usePolling,
+        interval: config2.usePolling ? config2.pollInterval : void 0
       });
       watcher.on("add", (path39) => {
         console.error(`[flywheel] RAW EVENT: add ${path39}`);
@@ -9479,6 +9479,104 @@ function refreshIfStale(vaultPath2, index, excludeTags) {
 init_wikilinkFeedback();
 init_corrections();
 init_edgeWeights();
+var DeferredStepScheduler = class {
+  timers = /* @__PURE__ */ new Map();
+  executor = null;
+  /** Set the executor context (called once during watcher setup) */
+  setExecutor(exec) {
+    this.executor = exec;
+  }
+  /** Schedule a deferred step to run after delayMs. Cancels any existing timer for this step. */
+  schedule(step, delayMs) {
+    this.cancel(step);
+    const timer2 = setTimeout(() => {
+      this.timers.delete(step);
+      this.executeStep(step);
+    }, delayMs);
+    timer2.unref();
+    this.timers.set(step, timer2);
+    serverLog("deferred", `Scheduled ${step} in ${Math.round(delayMs / 1e3)}s`);
+  }
+  /** Cancel a pending deferred step */
+  cancel(step) {
+    const existing = this.timers.get(step);
+    if (existing) {
+      clearTimeout(existing);
+      this.timers.delete(step);
+    }
+  }
+  /** Cancel all pending deferred steps (called on shutdown) */
+  cancelAll() {
+    for (const timer2 of this.timers.values()) clearTimeout(timer2);
+    this.timers.clear();
+  }
+  /** Check if any steps are pending */
+  get pendingCount() {
+    return this.timers.size;
+  }
+  async executeStep(step) {
+    const exec = this.executor;
+    if (!exec) return;
+    if (exec.ctx.pipelineActivity.busy) {
+      serverLog("deferred", `Skipping ${step}: pipeline busy`);
+      return;
+    }
+    const start = Date.now();
+    try {
+      switch (step) {
+        case "entity_scan": {
+          await exec.updateEntitiesInStateDb(exec.vp, exec.sd);
+          exec.ctx.lastEntityScanAt = Date.now();
+          if (exec.sd) {
+            await exportHubScores(exec.getVaultIndex(), exec.sd);
+            exec.ctx.lastHubScoreRebuildAt = Date.now();
+          }
+          break;
+        }
+        case "hub_scores": {
+          await exportHubScores(exec.getVaultIndex(), exec.sd);
+          exec.ctx.lastHubScoreRebuildAt = Date.now();
+          break;
+        }
+        case "recency": {
+          const entities = exec.sd ? getAllEntitiesFromDb(exec.sd) : [];
+          const entityInput = entities.map((e) => ({ name: e.name, path: e.path, aliases: e.aliases }));
+          const recencyIndex2 = await buildRecencyIndex(exec.vp, entityInput);
+          saveRecencyToStateDb(recencyIndex2, exec.sd ?? void 0);
+          break;
+        }
+        case "cooccurrence": {
+          const entities = exec.sd ? getAllEntitiesFromDb(exec.sd) : [];
+          const entityNames = entities.map((e) => e.name);
+          const cooccurrenceIdx = await mineCooccurrences(exec.vp, entityNames);
+          setCooccurrenceIndex(cooccurrenceIdx);
+          exec.ctx.lastCooccurrenceRebuildAt = Date.now();
+          exec.ctx.cooccurrenceIndex = cooccurrenceIdx;
+          if (exec.sd) saveCooccurrenceToStateDb(exec.sd, cooccurrenceIdx);
+          break;
+        }
+        case "edge_weights": {
+          if (exec.sd) {
+            recomputeEdgeWeights(exec.sd);
+            exec.ctx.lastEdgeWeightRebuildAt = Date.now();
+          }
+          break;
+        }
+      }
+      const duration = Date.now() - start;
+      serverLog("deferred", `Completed ${step} in ${duration}ms`);
+      if (exec.sd) {
+        recordIndexEvent(exec.sd, {
+          trigger: "deferred",
+          duration_ms: duration,
+          note_count: exec.getVaultIndex().notes.size
+        });
+      }
+    } catch (err) {
+      serverLog("deferred", `Failed ${step}: ${err instanceof Error ? err.message : err}`, "error");
+    }
+  }
+};
 var PIPELINE_TOTAL_STEPS = 22;
 function createEmptyPipelineActivity() {
   return {
@@ -9706,6 +9804,7 @@ var PipelineRunner = class {
       tracker.skip("entity_scan", `cache valid (${Math.round(entityScanAgeMs / 1e3)}s old)`);
       this.entitiesBefore = p.sd ? getAllEntitiesFromDb(p.sd) : [];
       this.entitiesAfter = this.entitiesBefore;
+      p.deferredScheduler?.schedule("entity_scan", 5 * 60 * 1e3 - entityScanAgeMs);
       serverLog("watcher", `Entity scan: throttled (${Math.round(entityScanAgeMs / 1e3)}s old)`);
       return;
     }
@@ -9751,6 +9850,7 @@ var PipelineRunner = class {
     const { p } = this;
     const hubAgeMs = p.ctx.lastHubScoreRebuildAt > 0 ? Date.now() - p.ctx.lastHubScoreRebuildAt : Infinity;
     if (hubAgeMs < 5 * 60 * 1e3) {
+      p.deferredScheduler?.schedule("hub_scores", 5 * 60 * 1e3 - hubAgeMs);
       serverLog("watcher", `Hub scores: throttled (${Math.round(hubAgeMs / 1e3)}s old)`);
       return { skipped: true, age_ms: hubAgeMs };
     }
@@ -9780,6 +9880,7 @@ var PipelineRunner = class {
       serverLog("watcher", `Recency: rebuilt ${recencyIndex2.lastMentioned.size} entities`);
       return { rebuilt: true, entities: recencyIndex2.lastMentioned.size };
     }
+    p.deferredScheduler?.schedule("recency", 60 * 60 * 1e3 - cacheAgeMs);
     serverLog("watcher", `Recency: cache valid (${Math.round(cacheAgeMs / 1e3)}s old)`);
     return { rebuilt: false, cached_age_ms: cacheAgeMs };
   }
@@ -9799,6 +9900,7 @@ var PipelineRunner = class {
       serverLog("watcher", `Co-occurrence: rebuilt ${cooccurrenceIdx._metadata.total_associations} associations`);
       return { rebuilt: true, associations: cooccurrenceIdx._metadata.total_associations };
     }
+    p.deferredScheduler?.schedule("cooccurrence", 60 * 60 * 1e3 - cooccurrenceAgeMs);
     serverLog("watcher", `Co-occurrence: cache valid (${Math.round(cooccurrenceAgeMs / 1e3)}s old)`);
     return { rebuilt: false, age_ms: cooccurrenceAgeMs };
   }
@@ -9821,6 +9923,7 @@ var PipelineRunner = class {
         top_changes: result.top_changes
       };
     }
+    p.deferredScheduler?.schedule("edge_weights", 60 * 60 * 1e3 - edgeWeightAgeMs);
     serverLog("watcher", `Edge weights: cache valid (${Math.round(edgeWeightAgeMs / 1e3)}s old)`);
     return { rebuilt: false, age_ms: edgeWeightAgeMs };
   }
@@ -10810,7 +10913,7 @@ function getToolSelectionReport(stateDb2, daysBack = 7) {
 }
 
 // src/index.ts
-import { openStateDb, scanVaultEntities as scanVaultEntities4, getAllEntitiesFromDb as getAllEntitiesFromDb5, loadContentHashes, saveContentHashBatch, renameContentHash, checkDbIntegrity as checkDbIntegrity2, safeBackupAsync as safeBackupAsync2, preserveCorruptedDb, deleteStateDbFiles, attemptSalvage } from "@velvetmonkey/vault-core";
+import { openStateDb, scanVaultEntities as scanVaultEntities5, getAllEntitiesFromDb as getAllEntitiesFromDb6, loadContentHashes, saveContentHashBatch, renameContentHash, checkDbIntegrity as checkDbIntegrity2, safeBackupAsync as safeBackupAsync2, preserveCorruptedDb, deleteStateDbFiles, attemptSalvage } from "@velvetmonkey/vault-core";
 
 // src/core/write/memory.ts
 init_wikilinkFeedback();
@@ -11229,6 +11332,382 @@ function getSweepResults() {
   return cachedResults;
 }
 
+// src/core/read/watch/maintenance.ts
+init_serverLog();
+import { getAllEntitiesFromDb as getAllEntitiesFromDb2 } from "@velvetmonkey/vault-core";
+init_recency();
+init_cooccurrence();
+init_wikilinks();
+init_edgeWeights();
+
+// src/core/shared/graphSnapshots.ts
+function computeGraphMetrics(index) {
+  const noteCount = index.notes.size;
+  if (noteCount === 0) {
+    return {
+      avg_degree: 0,
+      max_degree: 0,
+      cluster_count: 0,
+      largest_cluster_size: 0,
+      hub_scores_top10: []
+    };
+  }
+  const degreeMap = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const [notePath, note] of index.notes) {
+    if (!adjacency.has(notePath)) adjacency.set(notePath, /* @__PURE__ */ new Set());
+    let degree = note.outlinks.length;
+    for (const link of note.outlinks) {
+      const targetLower = link.target.toLowerCase();
+      const resolvedPath = index.entities.get(targetLower);
+      if (resolvedPath && index.notes.has(resolvedPath)) {
+        adjacency.get(notePath).add(resolvedPath);
+        if (!adjacency.has(resolvedPath)) adjacency.set(resolvedPath, /* @__PURE__ */ new Set());
+        adjacency.get(resolvedPath).add(notePath);
+      }
+    }
+    degreeMap.set(notePath, degree);
+  }
+  for (const [target, backlinks] of index.backlinks) {
+    const targetLower = target.toLowerCase();
+    const resolvedPath = index.entities.get(targetLower);
+    if (resolvedPath && degreeMap.has(resolvedPath)) {
+      degreeMap.set(resolvedPath, degreeMap.get(resolvedPath) + backlinks.length);
+    }
+  }
+  let totalDegree = 0;
+  let maxDegree = 0;
+  let maxDegreeNote = "";
+  for (const [notePath, degree] of degreeMap) {
+    totalDegree += degree;
+    if (degree > maxDegree) {
+      maxDegree = degree;
+      maxDegreeNote = notePath;
+    }
+  }
+  const avgDegree = noteCount > 0 ? Math.round(totalDegree / noteCount * 100) / 100 : 0;
+  const visited = /* @__PURE__ */ new Set();
+  const clusters = [];
+  for (const notePath of index.notes.keys()) {
+    if (visited.has(notePath)) continue;
+    const queue = [notePath];
+    visited.add(notePath);
+    let clusterSize = 0;
+    while (queue.length > 0) {
+      const current = queue.shift();
+      clusterSize++;
+      const neighbors = adjacency.get(current);
+      if (neighbors) {
+        for (const neighbor of neighbors) {
+          if (!visited.has(neighbor)) {
+            visited.add(neighbor);
+            queue.push(neighbor);
+          }
+        }
+      }
+    }
+    clusters.push(clusterSize);
+  }
+  const clusterCount = clusters.length;
+  const largestClusterSize = clusters.length > 0 ? Math.max(...clusters) : 0;
+  const sorted = Array.from(degreeMap.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10);
+  const hubScoresTop10 = sorted.map(([notePath, degree]) => {
+    const note = index.notes.get(notePath);
+    return {
+      entity: note?.title ?? notePath,
+      degree
+    };
+  });
+  return {
+    avg_degree: avgDegree,
+    max_degree: maxDegree,
+    cluster_count: clusterCount,
+    largest_cluster_size: largestClusterSize,
+    hub_scores_top10: hubScoresTop10
+  };
+}
+function recordGraphSnapshot(stateDb2, metrics) {
+  const timestamp = Date.now();
+  const insert = stateDb2.db.prepare(
+    "INSERT INTO graph_snapshots (timestamp, metric, value, details) VALUES (?, ?, ?, ?)"
+  );
+  const transaction = stateDb2.db.transaction(() => {
+    insert.run(timestamp, "avg_degree", metrics.avg_degree, null);
+    insert.run(timestamp, "max_degree", metrics.max_degree, null);
+    insert.run(timestamp, "cluster_count", metrics.cluster_count, null);
+    insert.run(timestamp, "largest_cluster_size", metrics.largest_cluster_size, null);
+    insert.run(
+      timestamp,
+      "hub_scores_top10",
+      metrics.hub_scores_top10.length,
+      JSON.stringify(metrics.hub_scores_top10)
+    );
+  });
+  transaction();
+}
+function getEmergingHubs(stateDb2, daysBack = 30) {
+  const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
+  const latestRow = stateDb2.db.prepare(
+    `SELECT details FROM graph_snapshots
+     WHERE metric = 'hub_scores_top10'
+     ORDER BY timestamp DESC LIMIT 1`
+  ).get();
+  const previousRow = stateDb2.db.prepare(
+    `SELECT details FROM graph_snapshots
+     WHERE metric = 'hub_scores_top10' AND timestamp >= ?
+     ORDER BY timestamp ASC LIMIT 1`
+  ).get(cutoff);
+  if (!latestRow?.details) return [];
+  const currentHubs = JSON.parse(latestRow.details);
+  const previousHubs = previousRow?.details ? JSON.parse(previousRow.details) : [];
+  const previousMap = /* @__PURE__ */ new Map();
+  for (const hub of previousHubs) {
+    previousMap.set(hub.entity, hub.degree);
+  }
+  const emerging = currentHubs.map((hub) => {
+    const prevDegree = previousMap.get(hub.entity) ?? 0;
+    return {
+      entity: hub.entity,
+      current_degree: hub.degree,
+      previous_degree: prevDegree,
+      growth: hub.degree - prevDegree
+    };
+  });
+  emerging.sort((a, b) => b.growth - a.growth);
+  return emerging;
+}
+function compareGraphSnapshots(stateDb2, timestampBefore, timestampAfter) {
+  const SCALAR_METRICS = ["avg_degree", "max_degree", "cluster_count", "largest_cluster_size"];
+  function getSnapshotAt(ts) {
+    const row = stateDb2.db.prepare(
+      `SELECT DISTINCT timestamp FROM graph_snapshots WHERE timestamp <= ? ORDER BY timestamp DESC LIMIT 1`
+    ).get(ts);
+    if (!row) return null;
+    const rows = stateDb2.db.prepare(
+      `SELECT metric, value, details FROM graph_snapshots WHERE timestamp = ?`
+    ).all(row.timestamp);
+    return rows;
+  }
+  const beforeRows = getSnapshotAt(timestampBefore) ?? [];
+  const afterRows = getSnapshotAt(timestampAfter) ?? [];
+  const beforeMap = /* @__PURE__ */ new Map();
+  const afterMap = /* @__PURE__ */ new Map();
+  for (const r of beforeRows) beforeMap.set(r.metric, { value: r.value, details: r.details });
+  for (const r of afterRows) afterMap.set(r.metric, { value: r.value, details: r.details });
+  const metricChanges = SCALAR_METRICS.map((metric) => {
+    const before = beforeMap.get(metric)?.value ?? 0;
+    const after = afterMap.get(metric)?.value ?? 0;
+    const delta = after - before;
+    const deltaPercent = before !== 0 ? Math.round(delta / before * 1e4) / 100 : delta !== 0 ? 100 : 0;
+    return { metric, before, after, delta, deltaPercent };
+  });
+  const beforeHubs = beforeMap.get("hub_scores_top10")?.details ? JSON.parse(beforeMap.get("hub_scores_top10").details) : [];
+  const afterHubs = afterMap.get("hub_scores_top10")?.details ? JSON.parse(afterMap.get("hub_scores_top10").details) : [];
+  const beforeHubMap = /* @__PURE__ */ new Map();
+  for (const h of beforeHubs) beforeHubMap.set(h.entity, h.degree);
+  const afterHubMap = /* @__PURE__ */ new Map();
+  for (const h of afterHubs) afterHubMap.set(h.entity, h.degree);
+  const allHubEntities = /* @__PURE__ */ new Set([...beforeHubMap.keys(), ...afterHubMap.keys()]);
+  const hubScoreChanges = [];
+  for (const entity of allHubEntities) {
+    const before = beforeHubMap.get(entity) ?? 0;
+    const after = afterHubMap.get(entity) ?? 0;
+    if (before !== after) {
+      hubScoreChanges.push({ entity, before, after, delta: after - before });
+    }
+  }
+  hubScoreChanges.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
+  return { metricChanges, hubScoreChanges };
+}
+function purgeOldSnapshots(stateDb2, retentionDays = 90) {
+  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+  const result = stateDb2.db.prepare(
+    "DELETE FROM graph_snapshots WHERE timestamp < ?"
+  ).run(cutoff);
+  return result.changes;
+}
+
+// src/core/read/watch/maintenance.ts
+var DEFAULT_INTERVAL_MS = 2 * 60 * 60 * 1e3;
+var MIN_INTERVAL_MS = 10 * 60 * 1e3;
+var JITTER_FACTOR = 0.15;
+var RECENT_REBUILD_THRESHOLD_MS = 60 * 60 * 1e3;
+var IDLE_THRESHOLD_MS = 30 * 1e3;
+var STEP_TTLS = {
+  entity_scan: 5 * 60 * 1e3,
+  // 5 minutes
+  hub_scores: 5 * 60 * 1e3,
+  // 5 minutes
+  recency: 60 * 60 * 1e3,
+  // 1 hour
+  cooccurrence: 60 * 60 * 1e3,
+  // 1 hour
+  edge_weights: 60 * 60 * 1e3,
+  // 1 hour
+  config_inference: 2 * 60 * 60 * 1e3
+  // 2 hours (only runs during maintenance)
+};
+var timer = null;
+var config = null;
+var lastConfigInferenceAt = 0;
+function addJitter(interval) {
+  const jitter = interval * JITTER_FACTOR * (2 * Math.random() - 1);
+  return Math.max(MIN_INTERVAL_MS, interval + jitter);
+}
+function startMaintenanceTimer(cfg, intervalMs) {
+  config = cfg;
+  const baseInterval = Math.max(intervalMs ?? DEFAULT_INTERVAL_MS, MIN_INTERVAL_MS);
+  scheduleNext(baseInterval);
+  serverLog("maintenance", `Timer started (interval ~${Math.round(baseInterval / 6e4)}min)`);
+}
+function stopMaintenanceTimer() {
+  if (timer) {
+    clearTimeout(timer);
+    timer = null;
+  }
+  config = null;
+}
+function scheduleNext(baseInterval) {
+  timer = setTimeout(() => {
+    runMaintenance(baseInterval);
+  }, addJitter(baseInterval));
+  timer.unref();
+}
+async function runMaintenance(baseInterval) {
+  const cfg = config;
+  if (!cfg) return;
+  const { ctx, sd } = cfg;
+  if (ctx.pipelineActivity.busy) {
+    serverLog("maintenance", "Skipped: pipeline busy");
+    scheduleNext(baseInterval);
+    return;
+  }
+  const lastFullRebuild = cfg.getLastFullRebuildAt();
+  if (lastFullRebuild > 0 && Date.now() - lastFullRebuild < RECENT_REBUILD_THRESHOLD_MS) {
+    serverLog("maintenance", `Skipped: full rebuild ${Math.round((Date.now() - lastFullRebuild) / 6e4)}min ago`);
+    scheduleNext(baseInterval);
+    return;
+  }
+  const lastRequest = cfg.getLastMcpRequestAt();
+  if (lastRequest > 0 && Date.now() - lastRequest < IDLE_THRESHOLD_MS) {
+    serverLog("maintenance", "Skipped: server not idle, retrying in 1min");
+    timer = setTimeout(() => runMaintenance(baseInterval), 60 * 1e3);
+    timer.unref();
+    return;
+  }
+  const start = Date.now();
+  const stepsRun = [];
+  const tracker = createStepTracker();
+  try {
+    const now = Date.now();
+    const entityAge = ctx.lastEntityScanAt > 0 ? now - ctx.lastEntityScanAt : Infinity;
+    if (entityAge >= STEP_TTLS.entity_scan) {
+      tracker.start("entity_scan", {});
+      await cfg.updateEntitiesInStateDb(cfg.vp, sd);
+      ctx.lastEntityScanAt = Date.now();
+      const entities = sd ? getAllEntitiesFromDb2(sd) : [];
+      tracker.end({ entity_count: entities.length });
+      stepsRun.push("entity_scan");
+    }
+    const hubAge = ctx.lastHubScoreRebuildAt > 0 ? now - ctx.lastHubScoreRebuildAt : Infinity;
+    if (hubAge >= STEP_TTLS.hub_scores) {
+      tracker.start("hub_scores", {});
+      const updated = await exportHubScores(cfg.getVaultIndex(), sd);
+      ctx.lastHubScoreRebuildAt = Date.now();
+      tracker.end({ updated: updated ?? 0 });
+      stepsRun.push("hub_scores");
+    }
+    const cachedRecency = loadRecencyFromStateDb(sd ?? void 0);
+    const recencyAge = cachedRecency ? now - (cachedRecency.lastUpdated ?? 0) : Infinity;
+    if (recencyAge >= STEP_TTLS.recency) {
+      tracker.start("recency", {});
+      const entities = sd ? getAllEntitiesFromDb2(sd) : [];
+      const entityInput = entities.map((e) => ({ name: e.name, path: e.path, aliases: e.aliases }));
+      const recencyIndex2 = await buildRecencyIndex(cfg.vp, entityInput);
+      saveRecencyToStateDb(recencyIndex2, sd ?? void 0);
+      tracker.end({ entities: recencyIndex2.lastMentioned.size });
+      stepsRun.push("recency");
+    }
+    const cooccurrenceAge = ctx.lastCooccurrenceRebuildAt > 0 ? now - ctx.lastCooccurrenceRebuildAt : Infinity;
+    if (cooccurrenceAge >= STEP_TTLS.cooccurrence) {
+      tracker.start("cooccurrence", {});
+      const entities = sd ? getAllEntitiesFromDb2(sd) : [];
+      const entityNames = entities.map((e) => e.name);
+      const cooccurrenceIdx = await mineCooccurrences(cfg.vp, entityNames);
+      setCooccurrenceIndex(cooccurrenceIdx);
+      ctx.lastCooccurrenceRebuildAt = Date.now();
+      ctx.cooccurrenceIndex = cooccurrenceIdx;
+      if (sd) saveCooccurrenceToStateDb(sd, cooccurrenceIdx);
+      tracker.end({ associations: cooccurrenceIdx._metadata.total_associations });
+      stepsRun.push("cooccurrence");
+    }
+    const edgeWeightAge = ctx.lastEdgeWeightRebuildAt > 0 ? now - ctx.lastEdgeWeightRebuildAt : Infinity;
+    if (sd && edgeWeightAge >= STEP_TTLS.edge_weights) {
+      tracker.start("edge_weights", {});
+      const result = recomputeEdgeWeights(sd);
+      ctx.lastEdgeWeightRebuildAt = Date.now();
+      tracker.end({ edges: result.edges_updated });
+      stepsRun.push("edge_weights");
+    }
+    const configAge = lastConfigInferenceAt > 0 ? now - lastConfigInferenceAt : Infinity;
+    if (sd && configAge >= STEP_TTLS.config_inference) {
+      tracker.start("config_inference", {});
+      const existing = loadConfig(sd);
+      const inferred = inferConfig(cfg.getVaultIndex(), cfg.vp);
+      saveConfig(sd, inferred, existing);
+      cfg.updateFlywheelConfig(loadConfig(sd));
+      lastConfigInferenceAt = Date.now();
+      tracker.end({ inferred: true });
+      stepsRun.push("config_inference");
+    }
+    if (sd && stepsRun.length > 0) {
+      try {
+        tracker.start("graph_snapshot", {});
+        const graphMetrics = computeGraphMetrics(cfg.getVaultIndex());
+        recordGraphSnapshot(sd, graphMetrics);
+        tracker.end({ recorded: true });
+        stepsRun.push("graph_snapshot");
+      } catch (err) {
+        tracker.end({ error: String(err) });
+      }
+    }
+    if (sd && stepsRun.length > 0) {
+      try {
+        saveVaultIndexToCache(sd, cfg.getVaultIndex());
+        ctx.lastIndexCacheSaveAt = Date.now();
+      } catch {
+      }
+    }
+    const duration = Date.now() - start;
+    if (stepsRun.length > 0) {
+      serverLog("maintenance", `Completed ${stepsRun.length} steps in ${duration}ms: ${stepsRun.join(", ")}`);
+      if (sd) {
+        recordIndexEvent(sd, {
+          trigger: "maintenance",
+          duration_ms: duration,
+          note_count: cfg.getVaultIndex().notes.size,
+          steps: tracker.steps
+        });
+      }
+    } else {
+      serverLog("maintenance", `All steps fresh, nothing to do (${duration}ms)`);
+    }
+  } catch (err) {
+    const duration = Date.now() - start;
+    serverLog("maintenance", `Failed after ${duration}ms: ${err instanceof Error ? err.message : err}`, "error");
+    if (sd) {
+      recordIndexEvent(sd, {
+        trigger: "maintenance",
+        duration_ms: duration,
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+        steps: tracker.steps
+      });
+    }
+  }
+  scheduleNext(baseInterval);
+}
+
 // src/core/shared/metrics.ts
 init_wikilinkFeedback();
 var ALL_METRICS = [
@@ -11617,193 +12096,6 @@ function purgeOldInvocations(stateDb2, retentionDays = 90) {
   return result.changes;
 }
 
-// src/core/shared/graphSnapshots.ts
-function computeGraphMetrics(index) {
-  const noteCount = index.notes.size;
-  if (noteCount === 0) {
-    return {
-      avg_degree: 0,
-      max_degree: 0,
-      cluster_count: 0,
-      largest_cluster_size: 0,
-      hub_scores_top10: []
-    };
-  }
-  const degreeMap = /* @__PURE__ */ new Map();
-  const adjacency = /* @__PURE__ */ new Map();
-  for (const [notePath, note] of index.notes) {
-    if (!adjacency.has(notePath)) adjacency.set(notePath, /* @__PURE__ */ new Set());
-    let degree = note.outlinks.length;
-    for (const link of note.outlinks) {
-      const targetLower = link.target.toLowerCase();
-      const resolvedPath = index.entities.get(targetLower);
-      if (resolvedPath && index.notes.has(resolvedPath)) {
-        adjacency.get(notePath).add(resolvedPath);
-        if (!adjacency.has(resolvedPath)) adjacency.set(resolvedPath, /* @__PURE__ */ new Set());
-        adjacency.get(resolvedPath).add(notePath);
-      }
-    }
-    degreeMap.set(notePath, degree);
-  }
-  for (const [target, backlinks] of index.backlinks) {
-    const targetLower = target.toLowerCase();
-    const resolvedPath = index.entities.get(targetLower);
-    if (resolvedPath && degreeMap.has(resolvedPath)) {
-      degreeMap.set(resolvedPath, degreeMap.get(resolvedPath) + backlinks.length);
-    }
-  }
-  let totalDegree = 0;
-  let maxDegree = 0;
-  let maxDegreeNote = "";
-  for (const [notePath, degree] of degreeMap) {
-    totalDegree += degree;
-    if (degree > maxDegree) {
-      maxDegree = degree;
-      maxDegreeNote = notePath;
-    }
-  }
-  const avgDegree = noteCount > 0 ? Math.round(totalDegree / noteCount * 100) / 100 : 0;
-  const visited = /* @__PURE__ */ new Set();
-  const clusters = [];
-  for (const notePath of index.notes.keys()) {
-    if (visited.has(notePath)) continue;
-    const queue = [notePath];
-    visited.add(notePath);
-    let clusterSize = 0;
-    while (queue.length > 0) {
-      const current = queue.shift();
-      clusterSize++;
-      const neighbors = adjacency.get(current);
-      if (neighbors) {
-        for (const neighbor of neighbors) {
-          if (!visited.has(neighbor)) {
-            visited.add(neighbor);
-            queue.push(neighbor);
-          }
-        }
-      }
-    }
-    clusters.push(clusterSize);
-  }
-  const clusterCount = clusters.length;
-  const largestClusterSize = clusters.length > 0 ? Math.max(...clusters) : 0;
-  const sorted = Array.from(degreeMap.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10);
-  const hubScoresTop10 = sorted.map(([notePath, degree]) => {
-    const note = index.notes.get(notePath);
-    return {
-      entity: note?.title ?? notePath,
-      degree
-    };
-  });
-  return {
-    avg_degree: avgDegree,
-    max_degree: maxDegree,
-    cluster_count: clusterCount,
-    largest_cluster_size: largestClusterSize,
-    hub_scores_top10: hubScoresTop10
-  };
-}
-function recordGraphSnapshot(stateDb2, metrics) {
-  const timestamp = Date.now();
-  const insert = stateDb2.db.prepare(
-    "INSERT INTO graph_snapshots (timestamp, metric, value, details) VALUES (?, ?, ?, ?)"
-  );
-  const transaction = stateDb2.db.transaction(() => {
-    insert.run(timestamp, "avg_degree", metrics.avg_degree, null);
-    insert.run(timestamp, "max_degree", metrics.max_degree, null);
-    insert.run(timestamp, "cluster_count", metrics.cluster_count, null);
-    insert.run(timestamp, "largest_cluster_size", metrics.largest_cluster_size, null);
-    insert.run(
-      timestamp,
-      "hub_scores_top10",
-      metrics.hub_scores_top10.length,
-      JSON.stringify(metrics.hub_scores_top10)
-    );
-  });
-  transaction();
-}
-function getEmergingHubs(stateDb2, daysBack = 30) {
-  const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
-  const latestRow = stateDb2.db.prepare(
-    `SELECT details FROM graph_snapshots
-     WHERE metric = 'hub_scores_top10'
-     ORDER BY timestamp DESC LIMIT 1`
-  ).get();
-  const previousRow = stateDb2.db.prepare(
-    `SELECT details FROM graph_snapshots
-     WHERE metric = 'hub_scores_top10' AND timestamp >= ?
-     ORDER BY timestamp ASC LIMIT 1`
-  ).get(cutoff);
-  if (!latestRow?.details) return [];
-  const currentHubs = JSON.parse(latestRow.details);
-  const previousHubs = previousRow?.details ? JSON.parse(previousRow.details) : [];
-  const previousMap = /* @__PURE__ */ new Map();
-  for (const hub of previousHubs) {
-    previousMap.set(hub.entity, hub.degree);
-  }
-  const emerging = currentHubs.map((hub) => {
-    const prevDegree = previousMap.get(hub.entity) ?? 0;
-    return {
-      entity: hub.entity,
-      current_degree: hub.degree,
-      previous_degree: prevDegree,
-      growth: hub.degree - prevDegree
-    };
-  });
-  emerging.sort((a, b) => b.growth - a.growth);
-  return emerging;
-}
-function compareGraphSnapshots(stateDb2, timestampBefore, timestampAfter) {
-  const SCALAR_METRICS = ["avg_degree", "max_degree", "cluster_count", "largest_cluster_size"];
-  function getSnapshotAt(ts) {
-    const row = stateDb2.db.prepare(
-      `SELECT DISTINCT timestamp FROM graph_snapshots WHERE timestamp <= ? ORDER BY timestamp DESC LIMIT 1`
-    ).get(ts);
-    if (!row) return null;
-    const rows = stateDb2.db.prepare(
-      `SELECT metric, value, details FROM graph_snapshots WHERE timestamp = ?`
-    ).all(row.timestamp);
-    return rows;
-  }
-  const beforeRows = getSnapshotAt(timestampBefore) ?? [];
-  const afterRows = getSnapshotAt(timestampAfter) ?? [];
-  const beforeMap = /* @__PURE__ */ new Map();
-  const afterMap = /* @__PURE__ */ new Map();
-  for (const r of beforeRows) beforeMap.set(r.metric, { value: r.value, details: r.details });
-  for (const r of afterRows) afterMap.set(r.metric, { value: r.value, details: r.details });
-  const metricChanges = SCALAR_METRICS.map((metric) => {
-    const before = beforeMap.get(metric)?.value ?? 0;
-    const after = afterMap.get(metric)?.value ?? 0;
-    const delta = after - before;
-    const deltaPercent = before !== 0 ? Math.round(delta / before * 1e4) / 100 : delta !== 0 ? 100 : 0;
-    return { metric, before, after, delta, deltaPercent };
-  });
-  const beforeHubs = beforeMap.get("hub_scores_top10")?.details ? JSON.parse(beforeMap.get("hub_scores_top10").details) : [];
-  const afterHubs = afterMap.get("hub_scores_top10")?.details ? JSON.parse(afterMap.get("hub_scores_top10").details) : [];
-  const beforeHubMap = /* @__PURE__ */ new Map();
-  for (const h of beforeHubs) beforeHubMap.set(h.entity, h.degree);
-  const afterHubMap = /* @__PURE__ */ new Map();
-  for (const h of afterHubs) afterHubMap.set(h.entity, h.degree);
-  const allHubEntities = /* @__PURE__ */ new Set([...beforeHubMap.keys(), ...afterHubMap.keys()]);
-  const hubScoreChanges = [];
-  for (const entity of allHubEntities) {
-    const before = beforeHubMap.get(entity) ?? 0;
-    const after = afterHubMap.get(entity) ?? 0;
-    if (before !== after) {
-      hubScoreChanges.push({ entity, before, after, delta: after - before });
-    }
-  }
-  hubScoreChanges.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
-  return { metricChanges, hubScoreChanges };
-}
-function purgeOldSnapshots(stateDb2, retentionDays = 90) {
-  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
-  const result = stateDb2.db.prepare(
-    "DELETE FROM graph_snapshots WHERE timestamp < ?"
-  ).run(cutoff);
-  return result.changes;
-}
-
 // src/index.ts
 init_serverLog();
 init_wikilinkFeedback();
@@ -12684,8 +12976,8 @@ var DEFAULT_CONFIG2 = {
   maxOutlinksPerHop: 10,
   maxBackfill: 10
 };
-function multiHopBackfill(primaryResults, index, stateDb2, config = {}) {
-  const cfg = { ...DEFAULT_CONFIG2, ...config };
+function multiHopBackfill(primaryResults, index, stateDb2, config2 = {}) {
+  const cfg = { ...DEFAULT_CONFIG2, ...config2 };
   const seen = new Set(primaryResults.map((r) => r.path).filter(Boolean));
   const candidates = [];
   const hop1Results = [];
@@ -15501,7 +15793,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
     }
     const indexBuilt = indexState2 === "ready" && index !== void 0 && index.notes !== void 0;
     let lastIndexActivityAt;
-    let lastFullRebuildAt;
+    let lastFullRebuildAt2;
     let lastWatcherBatchAt;
     let lastBuild;
     let lastManual;
@@ -15511,13 +15803,13 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
         if (lastAny) lastIndexActivityAt = lastAny.timestamp;
         lastBuild = getLastEventByTrigger(stateDb2, "startup_build") ?? void 0;
         lastManual = getLastEventByTrigger(stateDb2, "manual_refresh") ?? void 0;
-        lastFullRebuildAt = Math.max(lastBuild?.timestamp ?? 0, lastManual?.timestamp ?? 0) || void 0;
+        lastFullRebuildAt2 = Math.max(lastBuild?.timestamp ?? 0, lastManual?.timestamp ?? 0) || void 0;
         const lastWatcher = getLastEventByTrigger(stateDb2, "watcher");
         if (lastWatcher) lastWatcherBatchAt = lastWatcher.timestamp;
       } catch {
       }
     }
-    const freshnessTimestamp = lastFullRebuildAt ?? (indexBuilt && index.builtAt ? index.builtAt.getTime() : void 0);
+    const freshnessTimestamp = lastFullRebuildAt2 ?? (indexBuilt && index.builtAt ? index.builtAt.getTime() : void 0);
     const indexAge = freshnessTimestamp ? Math.floor((Date.now() - freshnessTimestamp) / 1e3) : -1;
     const indexStale = indexBuilt && indexAge > STALE_THRESHOLD_SECONDS;
     if (indexState2 === "building") {
@@ -15564,8 +15856,8 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
     }
     let configInfo;
     if (isFull) {
-      const config = getConfig2();
-      configInfo = Object.keys(config).length > 0 ? config : void 0;
+      const config2 = getConfig2();
+      configInfo = Object.keys(config2).length > 0 ? config2 : void 0;
     }
     let lastRebuild;
     if (stateDb2) {
@@ -15694,15 +15986,15 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
       watcher_pending: getWatcherStatus2()?.pendingEvents,
       last_index_activity_at: lastIndexActivityAt,
       last_index_activity_ago_seconds: lastIndexActivityAt ? Math.floor((Date.now() - lastIndexActivityAt) / 1e3) : void 0,
-      last_full_rebuild_at: lastFullRebuildAt,
+      last_full_rebuild_at: lastFullRebuildAt2,
       last_watcher_batch_at: lastWatcherBatchAt,
       pipeline_activity: pipelineActivity,
       dead_link_count: isFull ? deadLinkCount : void 0,
       top_dead_link_targets: isFull ? topDeadLinkTargets : void 0,
       sweep: isFull ? getSweepResults() ?? void 0 : void 0,
       proactive_linking: isFull && stateDb2 ? (() => {
-        const config = getConfig2();
-        const enabled = config.proactive_linking !== false;
+        const config2 = getConfig2();
+        const enabled = config2.proactive_linking !== false;
         const queuePending = stateDb2.db.prepare(
           `SELECT COUNT(*) as cnt FROM proactive_queue WHERE status = 'pending'`
         ).get();
@@ -16348,7 +16640,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig2 = () =>
 
 // src/tools/read/system.ts
 import { z as z5 } from "zod";
-import { scanVaultEntities as scanVaultEntities2, getEntityIndexFromDb as getEntityIndexFromDb2, getAllEntitiesFromDb as getAllEntitiesFromDb2 } from "@velvetmonkey/vault-core";
+import { scanVaultEntities as scanVaultEntities3, getEntityIndexFromDb as getEntityIndexFromDb2, getAllEntitiesFromDb as getAllEntitiesFromDb3 } from "@velvetmonkey/vault-core";
 
 // src/core/read/aliasSuggestions.ts
 import { STOPWORDS_EN as STOPWORDS_EN3 } from "@velvetmonkey/vault-core";
@@ -16465,11 +16757,11 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
         if (stateDb2) {
           tracker.start("entity_sync", {});
           try {
-            const config = loadConfig(stateDb2);
-            const excludeFolders = config.exclude_entity_folders?.length ? config.exclude_entity_folders : DEFAULT_ENTITY_EXCLUDE_FOLDERS;
-            const entityIndex2 = await scanVaultEntities2(vaultPath2, {
+            const config2 = loadConfig(stateDb2);
+            const excludeFolders = config2.exclude_entity_folders?.length ? config2.exclude_entity_folders : DEFAULT_ENTITY_EXCLUDE_FOLDERS;
+            const entityIndex2 = await scanVaultEntities3(vaultPath2, {
               excludeFolders,
-              customCategories: config.custom_categories
+              customCategories: config2.custom_categories
             });
             stateDb2.replaceAllEntities(entityIndex2);
             tracker.end({ entities: entityIndex2._metadata.total_entities });
@@ -16591,7 +16883,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
         if (stateDb2) {
           tracker.start("recency", {});
           try {
-            const entities = getAllEntitiesFromDb2(stateDb2).map((e) => ({
+            const entities = getAllEntitiesFromDb3(stateDb2).map((e) => ({
               name: e.name,
               path: e.path,
               aliases: e.aliases
@@ -16610,7 +16902,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
         if (stateDb2) {
           tracker.start("cooccurrence", {});
           try {
-            const entityNames = getAllEntitiesFromDb2(stateDb2).map((e) => e.name);
+            const entityNames = getAllEntitiesFromDb3(stateDb2).map((e) => e.name);
             const cooccurrenceIdx = await mineCooccurrences(vaultPath2, entityNames);
             setCooccurrenceIndex(cooccurrenceIdx);
             saveCooccurrenceToStateDb(stateDb2, cooccurrenceIdx);
@@ -16655,7 +16947,7 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
         if (stateDb2 && hasEntityEmbeddingsIndex()) {
           tracker.start("entity_embeddings", {});
           try {
-            const entities = getAllEntitiesFromDb2(stateDb2);
+            const entities = getAllEntitiesFromDb3(stateDb2);
             if (entities.length > 0) {
               const entityMap = new Map(entities.map((e) => [e.name, {
                 name: e.name,
@@ -17082,9 +17374,9 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
       const limit = Math.min(requestedLimit ?? 25, MAX_LIMIT);
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const config = getConfig2();
+      const config2 = getConfig2();
       if (path39) {
-        const result2 = await getTasksFromNote(index, path39, vaultPath2, getExcludeTags(config));
+        const result2 = await getTasksFromNote(index, path39, vaultPath2, getExcludeTags(config2));
         if (!result2) {
           return {
             content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path39 }, null, 2) }]
@@ -17107,12 +17399,12 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         };
       }
       if (isTaskCacheReady()) {
-        refreshIfStale(vaultPath2, index, getExcludeTags(config));
+        refreshIfStale(vaultPath2, index, getExcludeTags(config2));
         if (has_due_date) {
           const result3 = queryTasksFromCache({
             status,
             folder,
-            excludeTags: getExcludeTags(config),
+            excludeTags: getExcludeTags(config2),
             has_due_date: true,
             limit,
             offset
@@ -17129,7 +17421,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
           status,
           folder,
           tag,
-          excludeTags: getExcludeTags(config),
+          excludeTags: getExcludeTags(config2),
           limit,
           offset
         });
@@ -17148,7 +17440,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         const allResults = await getTasksWithDueDates(index, vaultPath2, {
           status,
           folder,
-          excludeTags: getExcludeTags(config)
+          excludeTags: getExcludeTags(config2)
         });
         const paged2 = allResults.slice(offset, offset + limit);
         return {
@@ -17164,7 +17456,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = ()
         folder,
         tag,
         limit: limit + offset,
-        excludeTags: getExcludeTags(config)
+        excludeTags: getExcludeTags(config2)
       });
       const paged = result.tasks.slice(offset, offset + limit);
       return {
@@ -17831,10 +18123,10 @@ function isTemplatePath(notePath) {
   const folder = notePath.split("/")[0]?.toLowerCase() || "";
   return folder === "templates" || folder === "template";
 }
-function getExcludedPaths(index, config) {
+function getExcludedPaths(index, config2) {
   const excluded = /* @__PURE__ */ new Set();
-  const excludeTags = new Set(getExcludeTags(config).map((t) => t.toLowerCase()));
-  const excludeEntities = new Set(getExcludeEntities(config).map((e) => e.toLowerCase()));
+  const excludeTags = new Set(getExcludeTags(config2).map((t) => t.toLowerCase()));
+  const excludeEntities = new Set(getExcludeEntities(config2).map((e) => e.toLowerCase()));
   if (excludeTags.size === 0 && excludeEntities.size === 0) return excluded;
   for (const note of index.notes.values()) {
     if (excludeTags.size > 0) {
@@ -17881,8 +18173,8 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb4
       requireIndex();
       const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
       const index = getIndex();
-      const config = getConfig2?.() ?? {};
-      const excludedPaths = getExcludedPaths(index, config);
+      const config2 = getConfig2?.() ?? {};
+      const excludedPaths = getExcludedPaths(index, config2);
       switch (analysis) {
         case "orphans": {
           const allOrphans = findOrphanNotes(index, folder).filter((o) => !isPeriodicNote(o.path) && !excludedPaths.has(o.path));
@@ -18050,7 +18342,7 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb4
               return !note || !excludedPaths.has(note.path);
             });
           }
-          const excludeEntities = new Set(getExcludeEntities(config).map((e) => e.toLowerCase()));
+          const excludeEntities = new Set(getExcludeEntities(config2).map((e) => e.toLowerCase()));
           if (excludeEntities.size > 0) {
             hubs = hubs.filter((hub) => !excludeEntities.has(hub.entity.toLowerCase()));
           }
@@ -19689,14 +19981,14 @@ async function executeDeleteNote(options) {
 }
 
 // src/tools/write/mutations.ts
-async function createNoteFromTemplate(vaultPath2, notePath, config) {
+async function createNoteFromTemplate(vaultPath2, notePath, config2) {
   const validation = await validatePathSecure(vaultPath2, notePath);
   if (!validation.valid) {
     throw new Error(`Path blocked: ${validation.reason}`);
   }
   const fullPath = path25.join(vaultPath2, notePath);
   await fs23.mkdir(path25.dirname(fullPath), { recursive: true });
-  const templates = config.templates || {};
+  const templates = config2.templates || {};
   const filename = path25.basename(notePath, ".md").toLowerCase();
   let templatePath;
   let periodicType;
@@ -19809,8 +20101,8 @@ function registerMutationTools(server2, getVaultPath, getConfig2 = () => ({})) {
         try {
           await fs23.access(fullPath);
         } catch {
-          const config = getConfig2();
-          const result = await createNoteFromTemplate(vaultPath2, notePath, config);
+          const config2 = getConfig2();
+          const result = await createNoteFromTemplate(vaultPath2, notePath, config2);
           noteCreated = result.created;
           templateUsed = result.templateUsed;
         }
@@ -23916,9 +24208,9 @@ function registerConfigTools(server2, getConfig2, setConfig, getStateDb4) {
     async ({ mode, key, value }) => {
       switch (mode) {
         case "get": {
-          const config = getConfig2();
+          const config2 = getConfig2();
           return {
-            content: [{ type: "text", text: JSON.stringify(config, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify(config2, null, 2) }]
           };
         }
         case "set": {
@@ -23969,7 +24261,7 @@ init_wikilinkFeedback();
 import { z as z28 } from "zod";
 import * as fs32 from "fs/promises";
 import * as path35 from "path";
-import { scanVaultEntities as scanVaultEntities3, SCHEMA_VERSION as SCHEMA_VERSION2 } from "@velvetmonkey/vault-core";
+import { scanVaultEntities as scanVaultEntities4, SCHEMA_VERSION as SCHEMA_VERSION2 } from "@velvetmonkey/vault-core";
 init_embeddings();
 function hasSkipWikilinks(content) {
   if (!content.startsWith("---")) return false;
@@ -24087,8 +24379,8 @@ async function executeRun(stateDb2, vaultPath2) {
   if (entityCount === 0) {
     const start = Date.now();
     try {
-      const config = loadConfig(stateDb2);
-      const entityIndex2 = await scanVaultEntities3(vaultPath2, { excludeFolders: EXCLUDE_FOLDERS, customCategories: config.custom_categories });
+      const config2 = loadConfig(stateDb2);
+      const entityIndex2 = await scanVaultEntities4(vaultPath2, { excludeFolders: EXCLUDE_FOLDERS, customCategories: config2.custom_categories });
       stateDb2.replaceAllEntities(entityIndex2);
       const newCount = entityIndex2._metadata.total_entities;
       steps.push({
@@ -24669,7 +24961,7 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb4) {
 // src/tools/read/semantic.ts
 init_embeddings();
 import { z as z31 } from "zod";
-import { getAllEntitiesFromDb as getAllEntitiesFromDb3 } from "@velvetmonkey/vault-core";
+import { getAllEntitiesFromDb as getAllEntitiesFromDb4 } from "@velvetmonkey/vault-core";
 function registerSemanticTools(server2, getVaultPath, getStateDb4) {
   server2.registerTool(
     "init_semantic",
@@ -24734,7 +25026,7 @@ function registerSemanticTools(server2, getVaultPath, getStateDb4) {
       const embedded = progress.total - progress.skipped;
       let entityEmbedded = 0;
       try {
-        const allEntities = getAllEntitiesFromDb3(stateDb2);
+        const allEntities = getAllEntitiesFromDb4(stateDb2);
         const entityMap = /* @__PURE__ */ new Map();
         for (const e of allEntities) {
           entityMap.set(e.name, {
@@ -24796,7 +25088,7 @@ function registerSemanticTools(server2, getVaultPath, getStateDb4) {
 // src/tools/read/merges.ts
 init_levenshtein();
 import { z as z32 } from "zod";
-import { getAllEntitiesFromDb as getAllEntitiesFromDb4, getDismissedMergePairs, recordMergeDismissal } from "@velvetmonkey/vault-core";
+import { getAllEntitiesFromDb as getAllEntitiesFromDb5, getDismissedMergePairs, recordMergeDismissal } from "@velvetmonkey/vault-core";
 function normalizeName(name) {
   return name.toLowerCase().replace(/[.\-_]/g, "").replace(/js$/, "").replace(/ts$/, "");
 }
@@ -24814,7 +25106,7 @@ function registerMergeTools2(server2, getStateDb4) {
           content: [{ type: "text", text: JSON.stringify({ suggestions: [], error: "StateDb not available" }) }]
         };
       }
-      const entities = getAllEntitiesFromDb4(stateDb2);
+      const entities = getAllEntitiesFromDb5(stateDb2);
       if (entities.length === 0) {
         return {
           content: [{ type: "text", text: JSON.stringify({ suggestions: [] }) }]
@@ -26297,7 +26589,7 @@ function queryFlywheelAgeDays(stateDb2) {
   if (!row?.first_ts) return 0;
   return Math.floor((Date.now() - row.first_ts) / (24 * 60 * 60 * 1e3));
 }
-function getCalibrationExport(stateDb2, metrics, config, daysBack = 30, includeVaultId = true) {
+function getCalibrationExport(stateDb2, metrics, config2, daysBack = 30, includeVaultId = true) {
   const now = /* @__PURE__ */ new Date();
   const start = new Date(now);
   start.setDate(start.getDate() - daysBack + 1);
@@ -26320,8 +26612,8 @@ function getCalibrationExport(stateDb2, metrics, config, daysBack = 30, includeV
       connected_ratio: round(metrics.connected_ratio),
       semantic_enabled: hasEmbeddingsIndex(),
       flywheel_age_days: queryFlywheelAgeDays(stateDb2),
-      strictness_mode: config.wikilink_strictness ?? "balanced",
-      adaptive_strictness: config.adaptive_strictness ?? true
+      strictness_mode: config2.wikilink_strictness ?? "balanced",
+      adaptive_strictness: config2.adaptive_strictness ?? true
     },
     entity_distribution: queryEntityDistribution(stateDb2),
     funnel: queryFunnel2(stateDb2, startMs, startIso, endIso),
@@ -26355,11 +26647,11 @@ function registerCalibrationExportTools(server2, getIndex, getStateDb4, getConfi
       }
       const index = getIndex();
       const metrics = computeMetrics(index, stateDb2);
-      const config = getConfig2();
+      const config2 = getConfig2();
       const report = getCalibrationExport(
         stateDb2,
         metrics,
-        config,
+        config2,
         args.days_back ?? 30,
         args.include_vault_id ?? true
       );
@@ -26613,7 +26905,7 @@ function extractSearchMethod(result) {
   }
   return void 0;
 }
-function applyToolGating(targetServer, categories, getDb4, registry, getVaultPath, vaultCallbacks, tierMode = "off", onTierStateChange, isFullToolset = false) {
+function applyToolGating(targetServer, categories, getDb4, registry, getVaultPath, vaultCallbacks, tierMode = "off", onTierStateChange, isFullToolset = false, onToolCall) {
   let _registered = 0;
   let _skipped = 0;
   let tierOverride = "auto";
@@ -26706,6 +26998,7 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
   }
   function wrapWithTracking(toolName, handler) {
     return async (...args) => {
+      onToolCall?.();
       const start = Date.now();
       let success = true;
       let notePaths;
@@ -27125,6 +27418,9 @@ var httpListener = null;
 var watchdogTimer = null;
 var serverReady = false;
 var shutdownRequested = false;
+var lastMcpRequestAt = 0;
+var lastFullRebuildAt = 0;
+var deferredScheduler = null;
 function getWatcherStatus() {
   if (vaultRegistry) {
     const name = globalThis.__flywheel_active_vault;
@@ -27158,8 +27454,8 @@ function handleTierStateChange(controller) {
   syncRuntimeTierState(controller);
   invalidateHttpPool();
 }
-function getConfigToolTierOverride(config) {
-  return config.tool_tier_override ?? "auto";
+function getConfigToolTierOverride(config2) {
+  return config2.tool_tier_override ?? "auto";
 }
 function buildRegistryContext() {
   return {
@@ -27191,7 +27487,10 @@ function createConfiguredServer() {
     buildVaultCallbacks(),
     toolTierMode,
     handleTierStateChange,
-    toolConfig.isFullToolset
+    toolConfig.isFullToolset,
+    () => {
+      lastMcpRequestAt = Date.now();
+    }
   );
   registerAllTools(s, ctx, toolTierController);
   toolTierController.setOverride(runtimeToolTierOverride);
@@ -27245,7 +27544,10 @@ var _gatingResult = applyToolGating(
   buildVaultCallbacks(),
   toolTierMode,
   handleTierStateChange,
-  toolConfig.isFullToolset
+  toolConfig.isFullToolset,
+  () => {
+    lastMcpRequestAt = Date.now();
+  }
 );
 registerAllTools(server, _registryCtx, _gatingResult);
 _gatingResult.setOverride(runtimeToolTierOverride);
@@ -27368,17 +27670,17 @@ function updateVaultIndex(index) {
   const ctx = getActiveVaultContext();
   if (ctx) ctx.vaultIndex = index;
 }
-function updateFlywheelConfig(config) {
-  flywheelConfig = config;
-  setWikilinkConfig(config);
+function updateFlywheelConfig(config2) {
+  flywheelConfig = config2;
+  setWikilinkConfig(config2);
   if (toolTierMode === "tiered" && primaryToolTierController) {
-    primaryToolTierController.setOverride(getConfigToolTierOverride(config));
+    primaryToolTierController.setOverride(getConfigToolTierOverride(config2));
     syncRuntimeTierState(primaryToolTierController);
     invalidateHttpPool();
   }
   const ctx = getActiveVaultContext();
   if (ctx) {
-    ctx.flywheelConfig = config;
+    ctx.flywheelConfig = config2;
     setActiveScope(buildVaultScope(ctx));
   }
 }
@@ -27433,6 +27735,7 @@ async function bootVault(ctx, startTime) {
         note_count: cachedIndex.notes.size
       });
     }
+    lastFullRebuildAt = Date.now();
     await runPostIndexWork(ctx);
   } else {
     serverLog("index", `[${ctx.name}] Cache miss: building from scratch`);
@@ -27457,6 +27760,7 @@ async function bootVault(ctx, startTime) {
           serverLog("index", `[${ctx.name}] Failed to save index cache: ${err instanceof Error ? err.message : err}`, "error");
         }
       }
+      lastFullRebuildAt = Date.now();
       await runPostIndexWork(ctx);
     } catch (err) {
       updateIndexState("error", err instanceof Error ? err : new Error(String(err)));
@@ -27677,11 +27981,11 @@ async function updateEntitiesInStateDb(vp, sd) {
   const vault = vp ?? vaultPath;
   if (!db4) return;
   try {
-    const config = loadConfig(db4);
-    const excludeFolders = config.exclude_entity_folders?.length ? config.exclude_entity_folders : DEFAULT_ENTITY_EXCLUDE_FOLDERS;
-    const entityIndex2 = await scanVaultEntities4(vault, {
+    const config2 = loadConfig(db4);
+    const excludeFolders = config2.exclude_entity_folders?.length ? config2.exclude_entity_folders : DEFAULT_ENTITY_EXCLUDE_FOLDERS;
+    const entityIndex2 = await scanVaultEntities5(vault, {
       excludeFolders,
-      customCategories: config.custom_categories
+      customCategories: config2.custom_categories
     });
     db4.replaceAllEntities(entityIndex2);
     serverLog("index", `Updated ${entityIndex2._metadata.total_entities} entities in StateDb`);
@@ -27828,7 +28132,7 @@ async function runPostIndexWork(ctx) {
       serverLog("semantic", "Embeddings up-to-date, skipping build");
       loadEntityEmbeddingsToMemory();
       if (sd) {
-        const entities = getAllEntitiesFromDb5(sd);
+        const entities = getAllEntitiesFromDb6(sd);
         if (entities.length > 0) {
           saveInferredCategories(classifyUncategorizedEntities(
             entities.map((entity) => ({
@@ -27865,7 +28169,7 @@ async function runPostIndexWork(ctx) {
             }
           });
           if (sd) {
-            const entities = getAllEntitiesFromDb5(sd);
+            const entities = getAllEntitiesFromDb6(sd);
             if (entities.length > 0) {
               const entityMap = new Map(entities.map((e) => [e.name, {
                 name: e.name,
@@ -27880,7 +28184,7 @@ async function runPostIndexWork(ctx) {
           activateVault(ctx);
           loadEntityEmbeddingsToMemory();
           if (sd) {
-            const entities = getAllEntitiesFromDb5(sd);
+            const entities = getAllEntitiesFromDb6(sd);
             if (entities.length > 0) {
               saveInferredCategories(classifyUncategorizedEntities(
                 entities.map((entity) => ({
@@ -27918,7 +28222,7 @@ async function runPostIndexWork(ctx) {
     serverLog("semantic", "Skipping \u2014 FLYWHEEL_SKIP_EMBEDDINGS");
   }
   if (process.env.FLYWHEEL_WATCH !== "false") {
-    const config = parseWatcherConfig();
+    const config2 = parseWatcherConfig();
     const lastContentHashes = /* @__PURE__ */ new Map();
     if (sd) {
       const persisted = loadContentHashes(sd);
@@ -27927,7 +28231,15 @@ async function runPostIndexWork(ctx) {
         serverLog("watcher", `Loaded ${persisted.size} persisted content hashes`);
       }
     }
-    serverLog("watcher", `File watcher enabled (debounce: ${config.debounceMs}ms)`);
+    serverLog("watcher", `File watcher enabled (debounce: ${config2.debounceMs}ms)`);
+    deferredScheduler = new DeferredStepScheduler();
+    deferredScheduler.setExecutor({
+      ctx,
+      vp,
+      sd,
+      getVaultIndex: () => vaultIndex,
+      updateEntitiesInStateDb
+    });
     const handleBatch = async (batch) => {
       const vaultPrefixes = /* @__PURE__ */ new Set([
         normalizePath(vp),
@@ -28068,13 +28380,14 @@ async function runPostIndexWork(ctx) {
         updateVaultIndex,
         updateEntitiesInStateDb,
         getVaultIndex: () => vaultIndex,
-        buildVaultIndex
+        buildVaultIndex,
+        deferredScheduler: deferredScheduler ?? void 0
       });
       await runner.run();
     };
     const watcher = createVaultWatcher({
       vaultPath: vp,
-      config,
+      config: config2,
       onBatch: handleBatch,
       onStateChange: (status) => {
         if (status.state === "dirty") {
@@ -28115,6 +28428,18 @@ async function runPostIndexWork(ctx) {
       if (sd) runPeriodicMaintenance(sd);
     });
     serverLog("server", "Sweep timer started (5 min interval)");
+    const maintenanceIntervalMs = parseInt(process.env.FLYWHEEL_MAINTENANCE_INTERVAL_MINUTES ?? "120", 10) * 60 * 1e3;
+    startMaintenanceTimer({
+      ctx,
+      vp,
+      sd,
+      getVaultIndex: () => ctx.vaultIndex,
+      updateEntitiesInStateDb,
+      updateFlywheelConfig,
+      getLastMcpRequestAt: () => lastMcpRequestAt,
+      getLastFullRebuildAt: () => lastFullRebuildAt
+    }, maintenanceIntervalMs);
+    serverLog("server", `Maintenance timer started (~${Math.round(maintenanceIntervalMs / 6e4)}min interval)`);
   }
   const postDuration = Date.now() - postStart;
   serverLog("server", `Post-index work complete in ${postDuration}ms`);
@@ -28162,7 +28487,12 @@ function gracefulShutdown(signal) {
     watcherInstance?.stop();
   } catch {
   }
+  try {
+    deferredScheduler?.cancelAll();
+  } catch {
+  }
   stopSweepTimer();
+  stopMaintenanceTimer();
   flushLogs().catch(() => {
   }).finally(() => process.exit(0));
   setTimeout(() => process.exit(0), 2e3).unref();