@velvetmonkey/flywheel-memory 2.0.10 → 2.0.12

package/dist/index.js

@@ -711,8 +711,8 @@ function createContext(variables = {}) {
     }
   };
 }
-function resolvePath(obj, path24) {
-  const parts = path24.split(".");
+function resolvePath(obj, path25) {
+  const parts = path25.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === void 0 || current === null) {
@@ -1690,8 +1690,8 @@ function updateIndexProgress(parsed, total) {
 function normalizeTarget(target) {
   return target.toLowerCase().replace(/\.md$/, "");
 }
-function normalizeNotePath(path24) {
-  return path24.toLowerCase().replace(/\.md$/, "");
+function normalizeNotePath(path25) {
+  return path25.toLowerCase().replace(/\.md$/, "");
 }
 async function buildVaultIndex(vaultPath2, options = {}) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
@@ -1885,7 +1885,7 @@ function findSimilarEntity(index, target) {
   }
   const maxDist = normalizedLen <= 10 ? 1 : 2;
   let bestMatch;
-  for (const [entity, path24] of index.entities) {
+  for (const [entity, path25] of index.entities) {
     const lenDiff = Math.abs(entity.length - normalizedLen);
     if (lenDiff > maxDist) {
       continue;
@@ -1893,7 +1893,7 @@ function findSimilarEntity(index, target) {
     const dist = levenshteinDistance(normalized, entity);
     if (dist > 0 && dist <= maxDist) {
       if (!bestMatch || dist < bestMatch.distance) {
-        bestMatch = { path: path24, entity, distance: dist };
+        bestMatch = { path: path25, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -2355,30 +2355,30 @@ var EventQueue = class {
    * Add a new event to the queue
    */
   push(type, rawPath) {
-    const path24 = normalizePath(rawPath);
+    const path25 = normalizePath(rawPath);
     const now = Date.now();
     const event = {
       type,
-      path: path24,
+      path: path25,
       timestamp: now
     };
-    let pending = this.pending.get(path24);
+    let pending = this.pending.get(path25);
     if (!pending) {
       pending = {
         events: [],
         timer: null,
         lastEvent: now
       };
-      this.pending.set(path24, pending);
+      this.pending.set(path25, pending);
     }
     pending.events.push(event);
     pending.lastEvent = now;
-    console.error(`[flywheel] QUEUE: pushed ${type} for ${path24}, pending=${this.pending.size}`);
+    console.error(`[flywheel] QUEUE: pushed ${type} for ${path25}, pending=${this.pending.size}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
     }
     pending.timer = setTimeout(() => {
-      this.flushPath(path24);
+      this.flushPath(path25);
     }, this.config.debounceMs);
     if (this.pending.size >= this.config.batchSize) {
       this.flush();
@@ -2399,10 +2399,10 @@ var EventQueue = class {
   /**
    * Flush a single path's events
    */
-  flushPath(path24) {
-    const pending = this.pending.get(path24);
+  flushPath(path25) {
+    const pending = this.pending.get(path25);
     if (!pending || pending.events.length === 0) return;
-    console.error(`[flywheel] QUEUE: flushing ${path24}, events=${pending.events.length}`);
+    console.error(`[flywheel] QUEUE: flushing ${path25}, events=${pending.events.length}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -2411,7 +2411,7 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path24,
+        path: path25,
         originalEvents: [...pending.events]
       };
       this.onBatch({
@@ -2419,7 +2419,7 @@ var EventQueue = class {
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path24);
+    this.pending.delete(path25);
   }
   /**
    * Flush all pending events
@@ -2431,7 +2431,7 @@ var EventQueue = class {
     }
     if (this.pending.size === 0) return;
     const events = [];
-    for (const [path24, pending] of this.pending) {
+    for (const [path25, pending] of this.pending) {
       if (pending.timer) {
         clearTimeout(pending.timer);
       }
@@ -2439,7 +2439,7 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path24,
+          path: path25,
           originalEvents: [...pending.events]
         });
       }
@@ -2588,31 +2588,31 @@ function createVaultWatcher(options) {
         usePolling: config.usePolling,
         interval: config.usePolling ? config.pollInterval : void 0
       });
-      watcher.on("add", (path24) => {
-        console.error(`[flywheel] RAW EVENT: add ${path24}`);
-        if (shouldWatch(path24, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: add ${path24}`);
-          eventQueue.push("add", path24);
+      watcher.on("add", (path25) => {
+        console.error(`[flywheel] RAW EVENT: add ${path25}`);
+        if (shouldWatch(path25, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: add ${path25}`);
+          eventQueue.push("add", path25);
         } else {
-          console.error(`[flywheel] FILTERED: add ${path24}`);
+          console.error(`[flywheel] FILTERED: add ${path25}`);
         }
       });
-      watcher.on("change", (path24) => {
-        console.error(`[flywheel] RAW EVENT: change ${path24}`);
-        if (shouldWatch(path24, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: change ${path24}`);
-          eventQueue.push("change", path24);
+      watcher.on("change", (path25) => {
+        console.error(`[flywheel] RAW EVENT: change ${path25}`);
+        if (shouldWatch(path25, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: change ${path25}`);
+          eventQueue.push("change", path25);
         } else {
-          console.error(`[flywheel] FILTERED: change ${path24}`);
+          console.error(`[flywheel] FILTERED: change ${path25}`);
         }
       });
-      watcher.on("unlink", (path24) => {
-        console.error(`[flywheel] RAW EVENT: unlink ${path24}`);
-        if (shouldWatch(path24, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: unlink ${path24}`);
-          eventQueue.push("unlink", path24);
+      watcher.on("unlink", (path25) => {
+        console.error(`[flywheel] RAW EVENT: unlink ${path25}`);
+        if (shouldWatch(path25, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: unlink ${path25}`);
+          eventQueue.push("unlink", path25);
         } else {
-          console.error(`[flywheel] FILTERED: unlink ${path24}`);
+          console.error(`[flywheel] FILTERED: unlink ${path25}`);
         }
       });
       watcher.on("ready", () => {
@@ -2728,6 +2728,237 @@ import {
   searchEntities as searchEntitiesDb
 } from "@velvetmonkey/vault-core";
 
+// src/core/write/wikilinkFeedback.ts
+var MIN_FEEDBACK_COUNT = 10;
+var SUPPRESSION_THRESHOLD = 0.3;
+var FEEDBACK_BOOST_MIN_SAMPLES = 5;
+var FOLDER_SUPPRESSION_MIN_COUNT = 5;
+var FEEDBACK_BOOST_TIERS = [
+  { minAccuracy: 0.95, minSamples: 20, boost: 5 },
+  { minAccuracy: 0.8, minSamples: 5, boost: 2 },
+  { minAccuracy: 0.6, minSamples: 5, boost: 0 },
+  { minAccuracy: 0.4, minSamples: 5, boost: -2 },
+  { minAccuracy: 0, minSamples: 5, boost: -4 }
+];
+function recordFeedback(stateDb2, entity, context, notePath, correct) {
+  stateDb2.db.prepare(
+    "INSERT INTO wikilink_feedback (entity, context, note_path, correct) VALUES (?, ?, ?, ?)"
+  ).run(entity, context, notePath, correct ? 1 : 0);
+}
+function getFeedback(stateDb2, entity, limit = 20) {
+  let rows;
+  if (entity) {
+    rows = stateDb2.db.prepare(
+      "SELECT id, entity, context, note_path, correct, created_at FROM wikilink_feedback WHERE entity = ? ORDER BY created_at DESC LIMIT ?"
+    ).all(entity, limit);
+  } else {
+    rows = stateDb2.db.prepare(
+      "SELECT id, entity, context, note_path, correct, created_at FROM wikilink_feedback ORDER BY created_at DESC LIMIT ?"
+    ).all(limit);
+  }
+  return rows.map((r) => ({
+    id: r.id,
+    entity: r.entity,
+    context: r.context,
+    note_path: r.note_path,
+    correct: r.correct === 1,
+    created_at: r.created_at
+  }));
+}
+function getEntityStats(stateDb2) {
+  const rows = stateDb2.db.prepare(`
+    SELECT
+      entity,
+      COUNT(*) as total,
+      SUM(CASE WHEN correct = 1 THEN 1 ELSE 0 END) as correct_count,
+      SUM(CASE WHEN correct = 0 THEN 1 ELSE 0 END) as incorrect_count
+    FROM wikilink_feedback
+    GROUP BY entity
+    ORDER BY total DESC
+  `).all();
+  return rows.map((r) => {
+    const suppressed = isSuppressed(stateDb2, r.entity);
+    return {
+      entity: r.entity,
+      total: r.total,
+      correct: r.correct_count,
+      incorrect: r.incorrect_count,
+      accuracy: r.total > 0 ? Math.round(r.correct_count / r.total * 1e3) / 1e3 : 0,
+      suppressed
+    };
+  });
+}
+function updateSuppressionList(stateDb2) {
+  const stats = stateDb2.db.prepare(`
+    SELECT
+      entity,
+      COUNT(*) as total,
+      SUM(CASE WHEN correct = 0 THEN 1 ELSE 0 END) as false_positives
+    FROM wikilink_feedback
+    GROUP BY entity
+    HAVING total >= ?
+  `).all(MIN_FEEDBACK_COUNT);
+  let updated = 0;
+  const upsert = stateDb2.db.prepare(`
+    INSERT INTO wikilink_suppressions (entity, false_positive_rate, updated_at)
+    VALUES (?, ?, datetime('now'))
+    ON CONFLICT(entity) DO UPDATE SET
+      false_positive_rate = excluded.false_positive_rate,
+      updated_at = datetime('now')
+  `);
+  const remove = stateDb2.db.prepare(
+    "DELETE FROM wikilink_suppressions WHERE entity = ?"
+  );
+  const transaction = stateDb2.db.transaction(() => {
+    for (const stat3 of stats) {
+      const fpRate = stat3.false_positives / stat3.total;
+      if (fpRate >= SUPPRESSION_THRESHOLD) {
+        upsert.run(stat3.entity, fpRate);
+        updated++;
+      } else {
+        remove.run(stat3.entity);
+      }
+    }
+  });
+  transaction();
+  return updated;
+}
+function isSuppressed(stateDb2, entity, folder) {
+  const row = stateDb2.db.prepare(
+    "SELECT entity FROM wikilink_suppressions WHERE entity = ?"
+  ).get(entity);
+  if (row) return true;
+  if (folder !== void 0) {
+    const folderStats = stateDb2.db.prepare(`
+      SELECT
+        COUNT(*) as total,
+        SUM(CASE WHEN correct = 0 THEN 1 ELSE 0 END) as false_positives
+      FROM wikilink_feedback
+      WHERE entity = ? AND (
+        CASE WHEN ? = '' THEN note_path NOT LIKE '%/%'
+        ELSE note_path LIKE ? || '/%'
+        END
+      )
+    `).get(entity, folder, folder);
+    if (folderStats && folderStats.total >= FOLDER_SUPPRESSION_MIN_COUNT) {
+      const fpRate = folderStats.false_positives / folderStats.total;
+      if (fpRate >= SUPPRESSION_THRESHOLD) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function getSuppressedCount(stateDb2) {
+  const row = stateDb2.db.prepare(
+    "SELECT COUNT(*) as count FROM wikilink_suppressions"
+  ).get();
+  return row.count;
+}
+function computeBoostFromAccuracy(accuracy, sampleCount) {
+  if (sampleCount < FEEDBACK_BOOST_MIN_SAMPLES) return 0;
+  for (const tier of FEEDBACK_BOOST_TIERS) {
+    if (accuracy >= tier.minAccuracy && sampleCount >= tier.minSamples) {
+      return tier.boost;
+    }
+  }
+  return 0;
+}
+function getAllFeedbackBoosts(stateDb2, folder) {
+  const globalRows = stateDb2.db.prepare(`
+    SELECT
+      entity,
+      COUNT(*) as total,
+      SUM(CASE WHEN correct = 1 THEN 1 ELSE 0 END) as correct_count
+    FROM wikilink_feedback
+    GROUP BY entity
+    HAVING total >= ?
+  `).all(FEEDBACK_BOOST_MIN_SAMPLES);
+  let folderStats = null;
+  if (folder !== void 0) {
+    const folderRows = stateDb2.db.prepare(`
+      SELECT
+        entity,
+        COUNT(*) as total,
+        SUM(CASE WHEN correct = 1 THEN 1 ELSE 0 END) as correct_count
+      FROM wikilink_feedback
+      WHERE (
+        CASE WHEN ? = '' THEN note_path NOT LIKE '%/%'
+        ELSE note_path LIKE ? || '/%'
+        END
+      )
+      GROUP BY entity
+      HAVING total >= ?
+    `).all(folder, folder, FEEDBACK_BOOST_MIN_SAMPLES);
+    folderStats = /* @__PURE__ */ new Map();
+    for (const row of folderRows) {
+      folderStats.set(row.entity, {
+        accuracy: row.correct_count / row.total,
+        count: row.total
+      });
+    }
+  }
+  const boosts = /* @__PURE__ */ new Map();
+  for (const row of globalRows) {
+    let accuracy;
+    let sampleCount;
+    const fs25 = folderStats?.get(row.entity);
+    if (fs25 && fs25.count >= FEEDBACK_BOOST_MIN_SAMPLES) {
+      accuracy = fs25.accuracy;
+      sampleCount = fs25.count;
+    } else {
+      accuracy = row.correct_count / row.total;
+      sampleCount = row.total;
+    }
+    const boost = computeBoostFromAccuracy(accuracy, sampleCount);
+    if (boost !== 0) {
+      boosts.set(row.entity, boost);
+    }
+  }
+  return boosts;
+}
+function trackWikilinkApplications(stateDb2, notePath, entities) {
+  const upsert = stateDb2.db.prepare(`
+    INSERT INTO wikilink_applications (entity, note_path, applied_at, status)
+    VALUES (?, ?, datetime('now'), 'applied')
+    ON CONFLICT(entity, note_path) DO UPDATE SET
+      applied_at = datetime('now'),
+      status = 'applied'
+  `);
+  const transaction = stateDb2.db.transaction(() => {
+    for (const entity of entities) {
+      upsert.run(entity.toLowerCase(), notePath);
+    }
+  });
+  transaction();
+}
+function getTrackedApplications(stateDb2, notePath) {
+  const rows = stateDb2.db.prepare(
+    `SELECT entity FROM wikilink_applications WHERE note_path = ? AND status = 'applied'`
+  ).all(notePath);
+  return rows.map((r) => r.entity);
+}
+function processImplicitFeedback(stateDb2, notePath, currentContent) {
+  const tracked = getTrackedApplications(stateDb2, notePath);
+  if (tracked.length === 0) return [];
+  const currentLinks = extractLinkedEntities(currentContent);
+  const removed = [];
+  const markRemoved = stateDb2.db.prepare(
+    `UPDATE wikilink_applications SET status = 'removed' WHERE entity = ? AND note_path = ?`
+  );
+  const transaction = stateDb2.db.transaction(() => {
+    for (const entity of tracked) {
+      if (!currentLinks.has(entity)) {
+        recordFeedback(stateDb2, entity, "implicit:removed", notePath, false);
+        markRemoved.run(entity, notePath);
+        removed.push(entity);
+      }
+    }
+  });
+  transaction();
+  return removed;
+}
+
 // src/core/write/git.ts
 import { simpleGit, CheckRepoActions } from "simple-git";
 import path5 from "path";
@@ -4075,6 +4306,9 @@ function setWriteStateDb(stateDb2) {
   setHintsStateDb(stateDb2);
   setRecencyStateDb(stateDb2);
 }
+function getWriteStateDb() {
+  return moduleStateDb4;
+}
 var entityIndex = null;
 var indexReady = false;
 var indexError2 = null;
@@ -4218,8 +4452,15 @@ function processWikilinks(content, notePath) {
       linkedEntities: []
     };
   }
-  const entities = getAllEntities(entityIndex);
+  let entities = getAllEntities(entityIndex);
   console.error(`[Flywheel:DEBUG] Processing wikilinks with ${entities.length} entities`);
+  if (moduleStateDb4) {
+    const folder = notePath ? notePath.split("/")[0] : void 0;
+    entities = entities.filter((e) => {
+      const name = getEntityName2(e);
+      return !isSuppressed(moduleStateDb4, name, folder);
+    });
+  }
   const sortedEntities = sortEntitiesByPriority(entities, notePath);
   const resolved = resolveAliasWikilinks(content, sortedEntities, {
     caseInsensitive: true
@@ -4241,6 +4482,9 @@ function maybeApplyWikilinks(content, skipWikilinks, notePath) {
   checkAndRefreshIfStale();
   const result = processWikilinks(content, notePath);
   if (result.linksAdded > 0) {
+    if (moduleStateDb4 && notePath) {
+      trackWikilinkApplications(moduleStateDb4, notePath, result.linkedEntities);
+    }
     return {
       content: result.content,
       wikilinkInfo: `Applied ${result.linksAdded} wikilink(s): ${result.linkedEntities.join(", ")}`
@@ -4558,7 +4802,8 @@ function suggestRelatedLinks(content, options = {}) {
     maxSuggestions = 3,
     excludeLinked = true,
     strictness = DEFAULT_STRICTNESS,
-    notePath
+    notePath,
+    detail = false
   } = options;
   const config = STRICTNESS_CONFIGS[strictness];
   const adaptiveMinScore = getAdaptiveMinScore(content.length, config.minSuggestionScore);
@@ -4592,6 +4837,8 @@ function suggestRelatedLinks(content, options = {}) {
     return emptyResult;
   }
   const linkedEntities = excludeLinked ? extractLinkedEntities(content) : /* @__PURE__ */ new Set();
+  const noteFolder = notePath ? notePath.split("/")[0] : void 0;
+  const feedbackBoosts = moduleStateDb4 ? getAllFeedbackBoosts(moduleStateDb4, noteFolder) : /* @__PURE__ */ new Map();
   const scoredEntities = [];
   const directlyMatchedEntities = /* @__PURE__ */ new Set();
   const entitiesWithContentMatch = /* @__PURE__ */ new Set();
@@ -4612,20 +4859,38 @@ function suggestRelatedLinks(content, options = {}) {
     if (contentScore > 0) {
       entitiesWithContentMatch.add(entityName);
     }
-    score += TYPE_BOOST[category] || 0;
-    score += contextBoosts[category] || 0;
-    if (recencyIndex) {
-      score += getRecencyBoost(entityName, recencyIndex);
-    }
-    if (notePath && entity.path) {
-      score += getCrossFolderBoost(entity.path, notePath);
-    }
-    score += getHubBoost(entity);
+    const layerTypeBoost = TYPE_BOOST[category] || 0;
+    score += layerTypeBoost;
+    const layerContextBoost = contextBoosts[category] || 0;
+    score += layerContextBoost;
+    const layerRecencyBoost = recencyIndex ? getRecencyBoost(entityName, recencyIndex) : 0;
+    score += layerRecencyBoost;
+    const layerCrossFolderBoost = notePath && entity.path ? getCrossFolderBoost(entity.path, notePath) : 0;
+    score += layerCrossFolderBoost;
+    const layerHubBoost = getHubBoost(entity);
+    score += layerHubBoost;
+    const layerFeedbackAdj = feedbackBoosts.get(entityName) ?? 0;
+    score += layerFeedbackAdj;
     if (score > 0) {
       directlyMatchedEntities.add(entityName);
     }
     if (score >= adaptiveMinScore) {
-      scoredEntities.push({ name: entityName, score, category });
+      scoredEntities.push({
+        name: entityName,
+        path: entity.path || "",
+        score,
+        category,
+        breakdown: {
+          contentMatch: contentScore,
+          cooccurrenceBoost: 0,
+          typeBoost: layerTypeBoost,
+          contextBoost: layerContextBoost,
+          recencyBoost: layerRecencyBoost,
+          crossFolderBoost: layerCrossFolderBoost,
+          hubBoost: layerHubBoost,
+          feedbackAdjustment: layerFeedbackAdj
+        }
+      });
     }
   }
   if (cooccurrenceIndex && directlyMatchedEntities.size > 0) {
@@ -4640,6 +4905,7 @@ function suggestRelatedLinks(content, options = {}) {
         const existing = scoredEntities.find((e) => e.name === entityName);
         if (existing) {
           existing.score += boost;
+          existing.breakdown.cooccurrenceBoost += boost;
         } else {
           const entityTokens = tokenize(entityName);
           const hasContentOverlap = entityTokens.some(
@@ -4654,9 +4920,25 @@ function suggestRelatedLinks(content, options = {}) {
           const recencyBoostVal = recencyIndex ? getRecencyBoost(entityName, recencyIndex) : 0;
           const crossFolderBoost = notePath && entity.path ? getCrossFolderBoost(entity.path, notePath) : 0;
           const hubBoost = getHubBoost(entity);
-          const totalBoost = boost + typeBoost + contextBoost + recencyBoostVal + crossFolderBoost + hubBoost;
+          const feedbackAdj = feedbackBoosts.get(entityName) ?? 0;
+          const totalBoost = boost + typeBoost + contextBoost + recencyBoostVal + crossFolderBoost + hubBoost + feedbackAdj;
           if (totalBoost >= adaptiveMinScore) {
-            scoredEntities.push({ name: entityName, score: totalBoost, category });
+            scoredEntities.push({
+              name: entityName,
+              path: entity.path || "",
+              score: totalBoost,
+              category,
+              breakdown: {
+                contentMatch: 0,
+                cooccurrenceBoost: boost,
+                typeBoost,
+                contextBoost,
+                recencyBoost: recencyBoostVal,
+                crossFolderBoost,
+                hubBoost,
+                feedbackAdjustment: feedbackAdj
+              }
+            });
           }
         }
       }
@@ -4677,15 +4959,34 @@ function suggestRelatedLinks(content, options = {}) {
     }
     return 0;
   });
-  const topSuggestions = relevantEntities.slice(0, maxSuggestions).map((e) => e.name);
+  const topEntries = relevantEntities.slice(0, maxSuggestions);
+  const topSuggestions = topEntries.map((e) => e.name);
   if (topSuggestions.length === 0) {
     return emptyResult;
   }
   const suffix = "\u2192 " + topSuggestions.map((name) => `[[${name}]]`).join(", ");
-  return {
+  const result = {
     suggestions: topSuggestions,
     suffix
   };
+  if (detail) {
+    const feedbackStats = moduleStateDb4 ? getEntityStats(moduleStateDb4) : [];
+    const feedbackMap = new Map(feedbackStats.map((s) => [s.entity, s]));
+    result.detailed = topEntries.map((e) => {
+      const fb = feedbackMap.get(e.name);
+      const confidence = e.score >= 20 ? "high" : e.score >= 12 ? "medium" : "low";
+      return {
+        entity: e.name,
+        path: e.path,
+        totalScore: e.score,
+        breakdown: e.breakdown,
+        confidence,
+        feedbackCount: fb?.total ?? 0,
+        accuracy: fb ? fb.accuracy : void 0
+      };
+    });
+  }
+  return result;
 }
 function detectAliasCollisions(noteName, aliases = []) {
   if (!moduleStateDb4) return [];
@@ -5511,11 +5812,12 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
       inputSchema: {
         text: z2.string().describe("The text to analyze for potential wikilinks"),
         limit: z2.coerce.number().default(50).describe("Maximum number of suggestions to return"),
-        offset: z2.coerce.number().default(0).describe("Number of suggestions to skip (for pagination)")
+        offset: z2.coerce.number().default(0).describe("Number of suggestions to skip (for pagination)"),
+        detail: z2.boolean().default(false).describe("Include per-layer score breakdown for each suggestion")
       },
       outputSchema: SuggestWikilinksOutputSchema
     },
-    async ({ text, limit: requestedLimit, offset }) => {
+    async ({ text, limit: requestedLimit, offset, detail }) => {
       const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
       const index = getIndex();
       const allMatches = findEntityMatches(text, index.entities);
@@ -5526,6 +5828,16 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
         returned_count: matches.length,
         suggestions: matches
       };
+      if (detail) {
+        const scored = suggestRelatedLinks(text, {
+          detail: true,
+          maxSuggestions: limit,
+          strictness: "balanced"
+        });
+        if (scored.detailed) {
+          output.scored_suggestions = scored.detailed;
+        }
+      }
       return {
         content: [
           {
@@ -5553,14 +5865,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path24] of entities) {
+    for (const [name, path25] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path24;
+        return path25;
       }
     }
-    for (const [name, path24] of entities) {
+    for (const [name, path25] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path24;
+        return path25;
       }
     }
     return void 0;
@@ -6037,8 +6349,8 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       daily_counts: z3.record(z3.number())
     }).describe("Activity summary for the last 7 days")
   };
-  function isPeriodicNote(path24) {
-    const filename = path24.split("/").pop() || "";
+  function isPeriodicNote(path25) {
+    const filename = path25.split("/").pop() || "";
     const nameWithoutExt = filename.replace(/\.md$/, "");
     const patterns = [
       /^\d{4}-\d{2}-\d{2}$/,
@@ -6053,7 +6365,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       // YYYY (yearly)
     ];
     const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
-    const folder = path24.split("/")[0]?.toLowerCase() || "";
+    const folder = path25.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   server2.registerTool(
@@ -7058,18 +7370,18 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         include_content: z6.boolean().default(false).describe("Include the text content under each top-level section")
       }
     },
-    async ({ path: path24, include_content }) => {
+    async ({ path: path25, include_content }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path24, vaultPath2);
+      const result = await getNoteStructure(index, path25, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path24 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path25 }, null, 2) }]
         };
       }
       if (include_content) {
         for (const section of result.sections) {
-          const sectionResult = await getSectionContent(index, path24, section.heading.text, vaultPath2, true);
+          const sectionResult = await getSectionContent(index, path25, section.heading.text, vaultPath2, true);
           if (sectionResult) {
             section.content = sectionResult.content;
           }
@@ -7091,15 +7403,15 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         include_subheadings: z6.boolean().default(true).describe("Include content under subheadings")
       }
     },
-    async ({ path: path24, heading, include_subheadings }) => {
+    async ({ path: path25, heading, include_subheadings }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path24, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path25, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path24,
+            path: path25,
             heading
           }, null, 2) }]
         };
@@ -7153,16 +7465,16 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         offset: z6.coerce.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path24, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
+    async ({ path: path25, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
       const limit = Math.min(requestedLimit ?? 25, MAX_LIMIT);
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const config = getConfig();
-      if (path24) {
-        const result2 = await getTasksFromNote(index, path24, vaultPath2, config.exclude_task_tags || []);
+      if (path25) {
+        const result2 = await getTasksFromNote(index, path25, vaultPath2, config.exclude_task_tags || []);
         if (!result2) {
           return {
-            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path24 }, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path25 }, null, 2) }]
           };
         }
         let filtered = result2;
@@ -7172,7 +7484,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         const paged2 = filtered.slice(offset, offset + limit);
         return {
           content: [{ type: "text", text: JSON.stringify({
-            path: path24,
+            path: path25,
             total_count: filtered.length,
             returned_count: paged2.length,
             open: result2.filter((t) => t.status === "open").length,
@@ -8998,6 +9310,10 @@ async function withVaultFile(options, operation) {
       return formatMcpResult(existsError);
     }
     const { content, frontmatter, lineEnding } = await readVaultFile(vaultPath2, notePath);
+    const writeStateDb = getWriteStateDb();
+    if (writeStateDb) {
+      processImplicitFeedback(writeStateDb, notePath, content);
+    }
     let sectionBoundary;
     if (section) {
       const sectionResult = ensureSectionExists(content, section, notePath);
@@ -9614,8 +9930,8 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
           const templatePath = path18.join(vaultPath2, template);
           try {
             const raw = await fs18.readFile(templatePath, "utf-8");
-            const matter8 = (await import("gray-matter")).default;
-            const parsed = matter8(raw);
+            const matter9 = (await import("gray-matter")).default;
+            const parsed = matter9(raw);
             const dateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
             const title = path18.basename(notePath, ".md");
             let templateContent = parsed.content.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, title);
@@ -11580,6 +11896,549 @@ function registerPolicyTools(server2, vaultPath2) {
   );
 }
 
+// src/tools/write/tags.ts
+import { z as z19 } from "zod";
+
+// src/core/write/tagRename.ts
+import * as fs24 from "fs/promises";
+import * as path24 from "path";
+import matter8 from "gray-matter";
+import { getProtectedZones } from "@velvetmonkey/vault-core";
+function getNotesInFolder3(index, folder) {
+  const notes = [];
+  for (const note of index.notes.values()) {
+    const noteFolder = note.path.includes("/") ? note.path.substring(0, note.path.lastIndexOf("/")) : "";
+    if (!folder || note.path.startsWith(folder + "/") || noteFolder === folder) {
+      notes.push(note);
+    }
+  }
+  return notes;
+}
+function tagMatches(tag, oldTag, renameChildren) {
+  const tagLower = tag.toLowerCase();
+  const oldLower = oldTag.toLowerCase();
+  if (tagLower === oldLower) return true;
+  if (renameChildren && tagLower.startsWith(oldLower + "/")) return true;
+  return false;
+}
+function transformTag(tag, oldTag, newTag) {
+  const tagLower = tag.toLowerCase();
+  const oldLower = oldTag.toLowerCase();
+  if (tagLower === oldLower) {
+    return newTag;
+  }
+  if (tagLower.startsWith(oldLower + "/")) {
+    const suffix = tag.substring(oldTag.length);
+    return newTag + suffix;
+  }
+  return tag;
+}
+function isProtected(start, end, zones) {
+  for (const zone of zones) {
+    if (zone.type === "hashtag") continue;
+    if (zone.type === "frontmatter") continue;
+    if (start >= zone.start && start < zone.end || end > zone.start && end <= zone.end || start <= zone.start && end >= zone.end) {
+      return true;
+    }
+  }
+  return false;
+}
+function replaceInlineTags(content, oldTag, newTag, renameChildren) {
+  const zones = getProtectedZones(content);
+  const changes = [];
+  const escapedOld = oldTag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = renameChildren ? new RegExp(`(^|\\s)#(${escapedOld}(?:/[a-zA-Z0-9_/-]*)?)(?=[\\s,;.!?)]|$)`, "gim") : new RegExp(`(^|\\s)#(${escapedOld})(?=[/\\s,;.!?)]|$)`, "gim");
+  const lineStarts = [0];
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "\n") lineStarts.push(i + 1);
+  }
+  function getLineNumber(pos) {
+    for (let i = lineStarts.length - 1; i >= 0; i--) {
+      if (pos >= lineStarts[i]) return i + 1;
+    }
+    return 1;
+  }
+  const matches = [];
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const prefix = match[1];
+    const matchedTag = match[2];
+    const tagStart = match.index + prefix.length + 1;
+    const tagEnd = tagStart + matchedTag.length;
+    if (isProtected(match.index, tagEnd, zones)) continue;
+    if (!tagMatches(matchedTag, oldTag, renameChildren)) continue;
+    matches.push({
+      index: match.index,
+      fullMatch: match[0],
+      prefix,
+      matchedTag
+    });
+  }
+  let result = content;
+  for (let i = matches.length - 1; i >= 0; i--) {
+    const m = matches[i];
+    const transformed = transformTag(m.matchedTag, oldTag, newTag);
+    const replacement = m.prefix + "#" + transformed;
+    const start = m.index;
+    const end = start + m.fullMatch.length;
+    result = result.substring(0, start) + replacement + result.substring(end);
+    changes.unshift({
+      old: "#" + m.matchedTag,
+      new: "#" + transformed,
+      line: getLineNumber(start)
+    });
+  }
+  return { content: result, changes };
+}
+async function renameTag(index, vaultPath2, oldTag, newTag, options) {
+  const renameChildren = options?.rename_children ?? true;
+  const dryRun = options?.dry_run ?? true;
+  const folder = options?.folder;
+  const cleanOld = oldTag.replace(/^#/, "");
+  const cleanNew = newTag.replace(/^#/, "");
+  const notes = getNotesInFolder3(index, folder);
+  const affectedNotes = [];
+  for (const note of notes) {
+    const hasTag2 = note.tags.some((t) => tagMatches(t, cleanOld, renameChildren));
+    if (hasTag2) {
+      affectedNotes.push(note);
+    }
+  }
+  const previews = [];
+  let totalChanges = 0;
+  for (const note of affectedNotes) {
+    const fullPath = path24.join(vaultPath2, note.path);
+    let fileContent;
+    try {
+      fileContent = await fs24.readFile(fullPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const preview = {
+      path: note.path,
+      frontmatter_changes: [],
+      content_changes: [],
+      total_changes: 0
+    };
+    let parsed;
+    try {
+      parsed = matter8(fileContent);
+    } catch {
+      continue;
+    }
+    const fm = parsed.data;
+    let fmChanged = false;
+    if (Array.isArray(fm.tags)) {
+      const newTags = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const tag of fm.tags) {
+        if (typeof tag !== "string") continue;
+        const stripped = tag.replace(/^#/, "");
+        if (!tagMatches(stripped, cleanOld, renameChildren)) {
+          seen.add(stripped.toLowerCase());
+        }
+      }
+      for (const tag of fm.tags) {
+        if (typeof tag !== "string") {
+          newTags.push(tag);
+          continue;
+        }
+        const stripped = tag.replace(/^#/, "");
+        if (tagMatches(stripped, cleanOld, renameChildren)) {
+          const transformed = transformTag(stripped, cleanOld, cleanNew);
+          const key = transformed.toLowerCase();
+          if (seen.has(key)) {
+            preview.frontmatter_changes.push({
+              old: stripped,
+              new: `${transformed} (merged)`
+            });
+            fmChanged = true;
+            continue;
+          }
+          seen.add(key);
+          preview.frontmatter_changes.push({
+            old: stripped,
+            new: transformed
+          });
+          newTags.push(transformed);
+          fmChanged = true;
+        } else {
+          newTags.push(tag);
+        }
+      }
+      if (fmChanged) {
+        fm.tags = newTags;
+      }
+    }
+    const { content: updatedContent, changes: contentChanges } = replaceInlineTags(
+      parsed.content,
+      cleanOld,
+      cleanNew,
+      renameChildren
+    );
+    preview.content_changes = contentChanges;
+    preview.total_changes = preview.frontmatter_changes.length + preview.content_changes.length;
+    totalChanges += preview.total_changes;
+    if (preview.total_changes > 0) {
+      previews.push(preview);
+      if (!dryRun) {
+        const newContent = matter8.stringify(updatedContent, fm);
+        await fs24.writeFile(fullPath, newContent, "utf-8");
+      }
+    }
+  }
+  return {
+    old_tag: cleanOld,
+    new_tag: cleanNew,
+    rename_children: renameChildren,
+    dry_run: dryRun,
+    affected_notes: previews.length,
+    total_changes: totalChanges,
+    previews
+  };
+}
+
+// src/tools/write/tags.ts
+function registerTagTools(server2, getIndex, getVaultPath) {
+  server2.registerTool(
+    "rename_tag",
+    {
+      title: "Rename Tag",
+      description: "Bulk rename a tag across all notes (frontmatter and inline). Supports hierarchical rename (#project \u2192 #work also transforms #project/active \u2192 #work/active). Dry-run by default (preview only). Handles deduplication when new tag already exists.",
+      inputSchema: {
+        old_tag: z19.string().describe('Tag to rename (without #, e.g., "project")'),
+        new_tag: z19.string().describe('New tag name (without #, e.g., "work")'),
+        rename_children: z19.boolean().optional().describe("Also rename child tags (e.g., #project/active \u2192 #work/active). Default: true"),
+        folder: z19.string().optional().describe('Limit to notes in this folder (e.g., "projects")'),
+        dry_run: z19.boolean().optional().describe("Preview only, no changes (default: true)"),
+        commit: z19.boolean().optional().describe("Commit changes to git (default: false)")
+      }
+    },
+    async ({ old_tag, new_tag, rename_children, folder, dry_run, commit }) => {
+      const index = getIndex();
+      const vaultPath2 = getVaultPath();
+      const result = await renameTag(index, vaultPath2, old_tag, new_tag, {
+        rename_children: rename_children ?? true,
+        folder,
+        dry_run: dry_run ?? true,
+        commit: commit ?? false
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/write/wikilinkFeedback.ts
+import { z as z20 } from "zod";
+function registerWikilinkFeedbackTools(server2, getStateDb) {
+  server2.registerTool(
+    "wikilink_feedback",
+    {
+      title: "Wikilink Feedback",
+      description: 'Report and query wikilink accuracy feedback. Modes: "report" (record feedback), "list" (view recent feedback), "stats" (entity accuracy statistics). Entities with >=30% false positive rate (and >=10 samples) are auto-suppressed from future wikilink application.',
+      inputSchema: {
+        mode: z20.enum(["report", "list", "stats"]).describe("Operation mode"),
+        entity: z20.string().optional().describe("Entity name (required for report mode, optional filter for list/stats)"),
+        note_path: z20.string().optional().describe("Note path where the wikilink appeared (for report mode)"),
+        context: z20.string().optional().describe("Surrounding text context (for report mode)"),
+        correct: z20.boolean().optional().describe("Whether the wikilink was correct (for report mode)"),
+        limit: z20.number().optional().describe("Max entries to return for list mode (default: 20)")
+      }
+    },
+    async ({ mode, entity, note_path, context, correct, limit }) => {
+      const stateDb2 = getStateDb();
+      if (!stateDb2) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
+        };
+      }
+      let result;
+      switch (mode) {
+        case "report": {
+          if (!entity || correct === void 0) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "entity and correct are required for report mode" }) }]
+            };
+          }
+          recordFeedback(stateDb2, entity, context || "", note_path || "", correct);
+          const suppressionUpdated = updateSuppressionList(stateDb2) > 0;
+          result = {
+            mode: "report",
+            reported: {
+              entity,
+              correct,
+              suppression_updated: suppressionUpdated
+            },
+            total_suppressed: getSuppressedCount(stateDb2)
+          };
+          break;
+        }
+        case "list": {
+          const entries = getFeedback(stateDb2, entity, limit ?? 20);
+          result = {
+            mode: "list",
+            entries,
+            total_feedback: entries.length
+          };
+          break;
+        }
+        case "stats": {
+          const stats = getEntityStats(stateDb2);
+          result = {
+            mode: "stats",
+            stats,
+            total_feedback: stats.reduce((sum, s) => sum + s.total, 0),
+            total_suppressed: getSuppressedCount(stateDb2)
+          };
+          break;
+        }
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/read/metrics.ts
+import { z as z21 } from "zod";
+
+// src/core/shared/metrics.ts
+var ALL_METRICS = [
+  "note_count",
+  "link_count",
+  "orphan_count",
+  "tag_count",
+  "entity_count",
+  "avg_links_per_note",
+  "link_density",
+  "connected_ratio",
+  "wikilink_accuracy",
+  "wikilink_feedback_volume",
+  "wikilink_suppressed_count"
+];
+function computeMetrics(index, stateDb2) {
+  const noteCount = index.notes.size;
+  let linkCount = 0;
+  for (const note of index.notes.values()) {
+    linkCount += note.outlinks.length;
+  }
+  const connectedNotes = /* @__PURE__ */ new Set();
+  for (const [notePath, note] of index.notes) {
+    if (note.outlinks.length > 0) {
+      connectedNotes.add(notePath);
+    }
+  }
+  for (const [target, backlinks] of index.backlinks) {
+    for (const bl of backlinks) {
+      connectedNotes.add(bl.source);
+    }
+    for (const note of index.notes.values()) {
+      const normalizedTitle = note.title.toLowerCase();
+      if (normalizedTitle === target.toLowerCase() || note.path.toLowerCase() === target.toLowerCase()) {
+        connectedNotes.add(note.path);
+      }
+    }
+  }
+  let orphanCount = 0;
+  for (const [notePath, note] of index.notes) {
+    if (!connectedNotes.has(notePath)) {
+      orphanCount++;
+    }
+  }
+  const tagCount = index.tags.size;
+  const entityCount = index.entities.size;
+  const avgLinksPerNote = noteCount > 0 ? linkCount / noteCount : 0;
+  const possibleLinks = noteCount * (noteCount - 1);
+  const linkDensity = possibleLinks > 0 ? linkCount / possibleLinks : 0;
+  const connectedRatio = noteCount > 0 ? connectedNotes.size / noteCount : 0;
+  let wikilinkAccuracy = 0;
+  let wikilinkFeedbackVolume = 0;
+  let wikilinkSuppressedCount = 0;
+  if (stateDb2) {
+    const entityStatsList = getEntityStats(stateDb2);
+    wikilinkFeedbackVolume = entityStatsList.reduce((sum, s) => sum + s.total, 0);
+    if (wikilinkFeedbackVolume > 0) {
+      const totalCorrect = entityStatsList.reduce((sum, s) => sum + s.correct, 0);
+      wikilinkAccuracy = Math.round(totalCorrect / wikilinkFeedbackVolume * 1e3) / 1e3;
+    }
+    wikilinkSuppressedCount = getSuppressedCount(stateDb2);
+  }
+  return {
+    note_count: noteCount,
+    link_count: linkCount,
+    orphan_count: orphanCount,
+    tag_count: tagCount,
+    entity_count: entityCount,
+    avg_links_per_note: Math.round(avgLinksPerNote * 100) / 100,
+    link_density: Math.round(linkDensity * 1e4) / 1e4,
+    connected_ratio: Math.round(connectedRatio * 1e3) / 1e3,
+    wikilink_accuracy: wikilinkAccuracy,
+    wikilink_feedback_volume: wikilinkFeedbackVolume,
+    wikilink_suppressed_count: wikilinkSuppressedCount
+  };
+}
+function recordMetrics(stateDb2, metrics) {
+  const timestamp = Date.now();
+  const insert = stateDb2.db.prepare(
+    "INSERT INTO vault_metrics (timestamp, metric, value) VALUES (?, ?, ?)"
+  );
+  const transaction = stateDb2.db.transaction(() => {
+    for (const [metric, value] of Object.entries(metrics)) {
+      insert.run(timestamp, metric, value);
+    }
+  });
+  transaction();
+}
+function getMetricHistory(stateDb2, metric, daysBack = 30) {
+  const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
+  let rows;
+  if (metric) {
+    rows = stateDb2.db.prepare(
+      "SELECT timestamp, metric, value FROM vault_metrics WHERE metric = ? AND timestamp >= ? ORDER BY timestamp"
+    ).all(metric, cutoff);
+  } else {
+    rows = stateDb2.db.prepare(
+      "SELECT timestamp, metric, value FROM vault_metrics WHERE timestamp >= ? ORDER BY timestamp"
+    ).all(cutoff);
+  }
+  return rows.map((r) => ({
+    metric: r.metric,
+    value: r.value,
+    timestamp: r.timestamp
+  }));
+}
+function computeTrends(stateDb2, currentMetrics, daysBack = 30) {
+  const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
+  const rows = stateDb2.db.prepare(`
+    SELECT metric, value FROM vault_metrics
+    WHERE timestamp >= ? AND timestamp <= ?
+    GROUP BY metric
+    HAVING timestamp = MIN(timestamp)
+  `).all(cutoff, cutoff + 24 * 60 * 60 * 1e3);
+  const previousValues = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    previousValues.set(row.metric, row.value);
+  }
+  if (previousValues.size === 0) {
+    const fallbackRows = stateDb2.db.prepare(`
+      SELECT metric, MIN(value) as value FROM vault_metrics
+      WHERE timestamp >= ?
+      GROUP BY metric
+      HAVING timestamp = MIN(timestamp)
+    `).all(cutoff);
+    for (const row of fallbackRows) {
+      previousValues.set(row.metric, row.value);
+    }
+  }
+  const trends = [];
+  for (const metricName of ALL_METRICS) {
+    const current = currentMetrics[metricName] ?? 0;
+    const previous = previousValues.get(metricName) ?? current;
+    const delta = current - previous;
+    const deltaPct = previous !== 0 ? Math.round(delta / previous * 1e4) / 100 : delta !== 0 ? 100 : 0;
+    let direction = "stable";
+    if (delta > 0) direction = "up";
+    if (delta < 0) direction = "down";
+    trends.push({
+      metric: metricName,
+      current,
+      previous,
+      delta,
+      delta_percent: deltaPct,
+      direction
+    });
+  }
+  return trends;
+}
+function purgeOldMetrics(stateDb2, retentionDays = 90) {
+  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+  const result = stateDb2.db.prepare(
+    "DELETE FROM vault_metrics WHERE timestamp < ?"
+  ).run(cutoff);
+  return result.changes;
+}
+
+// src/tools/read/metrics.ts
+function registerMetricsTools(server2, getIndex, getStateDb) {
+  server2.registerTool(
+    "vault_growth",
+    {
+      title: "Vault Growth",
+      description: 'Track vault growth over time. Modes: "current" (live snapshot), "history" (time series), "trends" (deltas vs N days ago). Tracks 11 metrics: note_count, link_count, orphan_count, tag_count, entity_count, avg_links_per_note, link_density, connected_ratio, wikilink_accuracy, wikilink_feedback_volume, wikilink_suppressed_count.',
+      inputSchema: {
+        mode: z21.enum(["current", "history", "trends"]).describe("Query mode: current snapshot, historical time series, or trend analysis"),
+        metric: z21.string().optional().describe('Filter to specific metric (e.g., "note_count"). Omit for all metrics.'),
+        days_back: z21.number().optional().describe("Number of days to look back for history/trends (default: 30)")
+      }
+    },
+    async ({ mode, metric, days_back }) => {
+      const index = getIndex();
+      const stateDb2 = getStateDb();
+      const daysBack = days_back ?? 30;
+      let result;
+      switch (mode) {
+        case "current": {
+          const metrics = computeMetrics(index, stateDb2 ?? void 0);
+          result = {
+            mode: "current",
+            metrics,
+            recorded_at: Date.now()
+          };
+          break;
+        }
+        case "history": {
+          if (!stateDb2) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available for historical queries" }) }]
+            };
+          }
+          const history = getMetricHistory(stateDb2, metric, daysBack);
+          result = {
+            mode: "history",
+            history
+          };
+          break;
+        }
+        case "trends": {
+          if (!stateDb2) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available for trend analysis" }) }]
+            };
+          }
+          const currentMetrics = computeMetrics(index, stateDb2);
+          const trends = computeTrends(stateDb2, currentMetrics, daysBack);
+          result = {
+            mode: "trends",
+            trends
+          };
+          break;
+        }
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
 // src/resources/vault.ts
 function registerVaultResources(server2, getIndex) {
   server2.registerResource(
@@ -11812,9 +12671,14 @@ var TOOL_CATEGORY = {
   vault_undo_last_mutation: "git",
   // policy
   policy: "policy",
-  // schema (migrations)
+  // schema (migrations + tag rename)
   rename_field: "schema",
-  migrate_field_values: "schema"
+  migrate_field_values: "schema",
+  rename_tag: "schema",
+  // health (growth metrics)
+  vault_growth: "health",
+  // wikilinks (feedback)
+  wikilink_feedback: "wikilinks"
 };
 var server = new McpServer({
   name: "flywheel-memory",
@@ -11873,6 +12737,9 @@ registerNoteTools(server, vaultPath, () => vaultIndex);
 registerMoveNoteTools(server, vaultPath);
 registerSystemTools2(server, vaultPath);
 registerPolicyTools(server, vaultPath);
+registerTagTools(server, () => vaultIndex, () => vaultPath);
+registerWikilinkFeedbackTools(server, () => stateDb);
+registerMetricsTools(server, () => vaultIndex, () => stateDb);
 registerVaultResources(server, () => vaultIndex ?? null);
 console.error(`[Memory] Registered ${_registeredCount} tools, skipped ${_skippedCount}`);
 async function main() {
@@ -11978,6 +12845,23 @@ async function updateEntitiesInStateDb() {
 async function runPostIndexWork(index) {
   await updateEntitiesInStateDb();
   await exportHubScores(index, stateDb);
+  if (stateDb) {
+    try {
+      const metrics = computeMetrics(index, stateDb);
+      recordMetrics(stateDb, metrics);
+      purgeOldMetrics(stateDb, 90);
+      console.error("[Memory] Growth metrics recorded");
+    } catch (err) {
+      console.error("[Memory] Failed to record metrics:", err);
+    }
+  }
+  if (stateDb) {
+    try {
+      updateSuppressionList(stateDb);
+    } catch (err) {
+      console.error("[Memory] Failed to update suppression list:", err);
+    }
+  }
   const existing = loadConfig(stateDb);
   const inferred = inferConfig(index, vaultPath);
   if (stateDb) {
@@ -12043,8 +12927,8 @@ async function runPostIndexWork(index) {
         }
       });
       let rebuildTimer;
-      legacyWatcher.on("all", (event, path24) => {
-        if (!path24.endsWith(".md")) return;
+      legacyWatcher.on("all", (event, path25) => {
+        if (!path25.endsWith(".md")) return;
         clearTimeout(rebuildTimer);
         rebuildTimer = setTimeout(() => {
           console.error("[Memory] Rebuilding index (file changed)");

package/package.json

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