@velvetmonkey/flywheel-memory 2.0.9 → 2.0.11

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,105 @@ import {
   searchEntities as searchEntitiesDb
 } from "@velvetmonkey/vault-core";
 
+// src/core/write/wikilinkFeedback.ts
+var MIN_FEEDBACK_COUNT = 10;
+var SUPPRESSION_THRESHOLD = 0.3;
+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) {
+  const row = stateDb2.db.prepare(
+    "SELECT entity FROM wikilink_suppressions WHERE entity = ?"
+  ).get(entity);
+  return !!row;
+}
+function getSuppressedCount(stateDb2) {
+  const row = stateDb2.db.prepare(
+    "SELECT COUNT(*) as count FROM wikilink_suppressions"
+  ).get();
+  return row.count;
+}
+
 // src/core/write/git.ts
 import { simpleGit, CheckRepoActions } from "simple-git";
 import path5 from "path";
@@ -4218,8 +4317,14 @@ 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) {
+    entities = entities.filter((e) => {
+      const name = getEntityName2(e);
+      return !isSuppressed(moduleStateDb4, name);
+    });
+  }
   const sortedEntities = sortEntitiesByPriority(entities, notePath);
   const resolved = resolveAliasWikilinks(content, sortedEntities, {
     caseInsensitive: true
@@ -5023,6 +5128,82 @@ function getLinkPath(index, fromPath, toPath, maxDepth = 10) {
   }
   return { exists: false, path: [], length: -1 };
 }
+function getWeightedLinkPath(index, fromPath, toPath, maxDepth = 10) {
+  const from = index.notes.has(fromPath) ? fromPath : resolveTarget(index, fromPath);
+  const to = index.notes.has(toPath) ? toPath : resolveTarget(index, toPath);
+  if (!from || !to) {
+    return { exists: false, path: [], length: -1, total_weight: 0, weights: [] };
+  }
+  if (from === to) {
+    return { exists: true, path: [from], length: 0, total_weight: 0, weights: [] };
+  }
+  const hubNotes = findHubNotes(index, 0);
+  const connectionCounts = /* @__PURE__ */ new Map();
+  for (const hub of hubNotes) {
+    connectionCounts.set(hub.path, hub.total_connections);
+  }
+  const dist = /* @__PURE__ */ new Map();
+  const prev = /* @__PURE__ */ new Map();
+  const depthMap = /* @__PURE__ */ new Map();
+  dist.set(from, 0);
+  depthMap.set(from, 0);
+  const pq = [{ node: from, cost: 0 }];
+  const visited = /* @__PURE__ */ new Set();
+  while (pq.length > 0) {
+    const { node: current, cost: currentCost } = pq.shift();
+    if (current === to) break;
+    if (visited.has(current)) continue;
+    visited.add(current);
+    const currentDepth = depthMap.get(current) ?? 0;
+    if (currentDepth >= maxDepth) continue;
+    const note = index.notes.get(current);
+    if (!note) continue;
+    for (const link of note.outlinks) {
+      const targetPath = resolveTarget(index, link.target);
+      if (!targetPath || visited.has(targetPath)) continue;
+      const strength = getConnectionStrength(index, current, targetPath);
+      const baseWeight = 1 / (1 + strength.score);
+      const targetConnections = connectionCounts.get(targetPath) ?? 0;
+      const hubPenalty = targetConnections > 0 ? 1 + Math.log2(targetConnections) : 1;
+      const edgeWeight = baseWeight * hubPenalty;
+      const newDist = currentCost + edgeWeight;
+      const existingDist = dist.get(targetPath);
+      if (existingDist === void 0 || newDist < existingDist) {
+        dist.set(targetPath, newDist);
+        prev.set(targetPath, current);
+        depthMap.set(targetPath, currentDepth + 1);
+        const entry = { node: targetPath, cost: newDist };
+        const insertIdx = pq.findIndex((e) => e.cost > newDist);
+        if (insertIdx === -1) {
+          pq.push(entry);
+        } else {
+          pq.splice(insertIdx, 0, entry);
+        }
+      }
+    }
+  }
+  if (!dist.has(to)) {
+    return { exists: false, path: [], length: -1, total_weight: 0, weights: [] };
+  }
+  const resultPath = [];
+  let node = to;
+  while (node) {
+    resultPath.unshift(node);
+    node = prev.get(node);
+  }
+  const weights = [];
+  for (let i = 0; i < resultPath.length - 1; i++) {
+    const edgeDist = (dist.get(resultPath[i + 1]) ?? 0) - (dist.get(resultPath[i]) ?? 0);
+    weights.push(Math.round(edgeDist * 1e3) / 1e3);
+  }
+  return {
+    exists: true,
+    path: resultPath,
+    length: resultPath.length - 1,
+    total_weight: Math.round((dist.get(to) ?? 0) * 1e3) / 1e3,
+    weights
+  };
+}
 function getCommonNeighbors(index, noteAPath, noteBPath) {
   const noteA = index.notes.get(noteAPath);
   const noteB = index.notes.get(noteBPath);
@@ -5477,14 +5658,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;
@@ -5961,8 +6142,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}$/,
@@ -5977,7 +6158,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(
@@ -6103,15 +6284,20 @@ function matchesFrontmatter(note, where) {
   }
   return true;
 }
-function hasTag(note, tag) {
+function hasTag(note, tag, includeChildren = false) {
   const normalizedTag = tag.replace(/^#/, "").toLowerCase();
-  return note.tags.some((t) => t.toLowerCase() === normalizedTag);
+  return note.tags.some((t) => {
+    const normalizedNoteTag = t.toLowerCase();
+    if (normalizedNoteTag === normalizedTag) return true;
+    if (includeChildren && normalizedNoteTag.startsWith(normalizedTag + "/")) return true;
+    return false;
+  });
 }
-function hasAnyTag(note, tags) {
-  return tags.some((tag) => hasTag(note, tag));
+function hasAnyTag(note, tags, includeChildren = false) {
+  return tags.some((tag) => hasTag(note, tag, includeChildren));
 }
-function hasAllTags(note, tags) {
-  return tags.every((tag) => hasTag(note, tag));
+function hasAllTags(note, tags, includeChildren = false) {
+  return tags.every((tag) => hasTag(note, tag, includeChildren));
 }
 function inFolder(note, folder) {
   const normalizedFolder = folder.endsWith("/") ? folder : folder + "/";
@@ -6150,6 +6336,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
       has_tag: z4.string().optional().describe("Filter to notes with this tag"),
       has_any_tag: z4.array(z4.string()).optional().describe("Filter to notes with any of these tags"),
       has_all_tags: z4.array(z4.string()).optional().describe("Filter to notes with all of these tags"),
+      include_children: z4.boolean().default(false).describe('When true, tag filters also match child tags (e.g., has_tag: "project" also matches "project/active")'),
       folder: z4.string().optional().describe("Limit to notes in this folder"),
       title_contains: z4.string().optional().describe("Filter to notes whose title contains this text (case-insensitive)"),
       // Date filters (absorbs temporal tools)
@@ -6163,7 +6350,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
       // Pagination
       limit: z4.number().default(20).describe("Maximum number of results to return")
     },
-    async ({ query, scope, where, has_tag, has_any_tag, has_all_tags, folder, title_contains, modified_after, modified_before, sort_by, order, prefix, limit: requestedLimit }) => {
+    async ({ query, scope, where, has_tag, has_any_tag, has_all_tags, include_children, folder, title_contains, modified_after, modified_before, sort_by, order, prefix, limit: requestedLimit }) => {
       const limit = Math.min(requestedLimit ?? 20, MAX_LIMIT);
       const index = getIndex();
       const vaultPath2 = getVaultPath();
@@ -6189,13 +6376,13 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
           matchingNotes = matchingNotes.filter((note) => matchesFrontmatter(note, where));
         }
         if (has_tag) {
-          matchingNotes = matchingNotes.filter((note) => hasTag(note, has_tag));
+          matchingNotes = matchingNotes.filter((note) => hasTag(note, has_tag, include_children));
         }
         if (has_any_tag && has_any_tag.length > 0) {
-          matchingNotes = matchingNotes.filter((note) => hasAnyTag(note, has_any_tag));
+          matchingNotes = matchingNotes.filter((note) => hasAnyTag(note, has_any_tag, include_children));
         }
         if (has_all_tags && has_all_tags.length > 0) {
-          matchingNotes = matchingNotes.filter((note) => hasAllTags(note, has_all_tags));
+          matchingNotes = matchingNotes.filter((note) => hasAllTags(note, has_all_tags, include_children));
         }
         if (folder) {
           matchingNotes = matchingNotes.filter((note) => inFolder(note, folder));
@@ -6976,18 +7163,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;
           }
@@ -7009,15 +7196,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) }]
         };
@@ -7071,16 +7258,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;
@@ -7090,7 +7277,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,
@@ -7136,16 +7323,17 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
     "get_link_path",
     {
       title: "Get Link Path",
-      description: "Find the shortest path of links between two notes.",
+      description: "Find the shortest path of links between two notes. Use weighted=true to penalize hub nodes for more meaningful paths.",
       inputSchema: {
         from: z6.string().describe("Starting note path"),
         to: z6.string().describe("Target note path"),
-        max_depth: z6.coerce.number().default(10).describe("Maximum path length to search")
+        max_depth: z6.coerce.number().default(10).describe("Maximum path length to search"),
+        weighted: z6.boolean().default(false).describe("Use weighted path-finding that penalizes hub nodes for more meaningful paths")
       }
     },
-    async ({ from, to, max_depth }) => {
+    async ({ from, to, max_depth, weighted }) => {
       const index = getIndex();
-      const result = getLinkPath(index, from, to, max_depth);
+      const result = weighted ? getWeightedLinkPath(index, from, to, max_depth) : getLinkPath(index, from, to, max_depth);
       return {
         content: [{ type: "text", text: JSON.stringify({
           from,
@@ -9503,6 +9691,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
     {
       path: z14.string().describe('Vault-relative path for the new note (e.g., "daily-notes/2026-01-28.md")'),
       content: z14.string().default("").describe("Initial content for the note"),
+      template: z14.string().optional().describe('Vault-relative path to a template file (e.g., "templates/person.md"). Template variables {{date}} and {{title}} are substituted. Template frontmatter is merged with the frontmatter parameter (explicit values take precedence).'),
       frontmatter: z14.record(z14.any()).default({}).describe("Frontmatter fields (JSON object)"),
       overwrite: z14.boolean().default(false).describe("If true, overwrite existing file"),
       commit: z14.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
@@ -9512,7 +9701,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
       agent_id: z14.string().optional().describe("Agent identifier for multi-agent scoping"),
       session_id: z14.string().optional().describe("Session identifier for conversation scoping")
     },
-    async ({ path: notePath, content, frontmatter, overwrite, commit, skipWikilinks, suggestOutgoingLinks, maxSuggestions, agent_id, session_id }) => {
+    async ({ path: notePath, content, template, frontmatter, overwrite, commit, skipWikilinks, suggestOutgoingLinks, maxSuggestions, agent_id, session_id }) => {
       try {
         if (!validatePath(vaultPath2, notePath)) {
           return formatMcpResult(errorResult(notePath, "Invalid path: path traversal not allowed"));
@@ -9524,9 +9713,29 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
         }
         const dir = path18.dirname(fullPath);
         await fs18.mkdir(dir, { recursive: true });
+        let effectiveContent = content;
+        let effectiveFrontmatter = frontmatter;
+        if (template) {
+          const templatePath = path18.join(vaultPath2, template);
+          try {
+            const raw = await fs18.readFile(templatePath, "utf-8");
+            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);
+            if (content) {
+              templateContent = templateContent.trimEnd() + "\n\n" + content;
+            }
+            effectiveContent = templateContent;
+            effectiveFrontmatter = { ...parsed.data || {}, ...frontmatter };
+          } catch {
+            return formatMcpResult(errorResult(notePath, `Template not found: ${template}`));
+          }
+        }
         const warnings = [];
         const noteName = path18.basename(notePath, ".md");
-        const existingAliases = Array.isArray(frontmatter?.aliases) ? frontmatter.aliases.filter((a) => typeof a === "string") : [];
+        const existingAliases = Array.isArray(effectiveFrontmatter?.aliases) ? effectiveFrontmatter.aliases.filter((a) => typeof a === "string") : [];
         const preflight = checkPreflightSimilarity(noteName);
         if (preflight.existingEntity) {
           warnings.push({
@@ -9550,7 +9759,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
             suggestion: `This may cause ambiguous wikilink resolution`
           });
         }
-        let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(content, skipWikilinks, notePath);
+        let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(effectiveContent, skipWikilinks, notePath);
         let suggestInfo;
         if (suggestOutgoingLinks && !skipWikilinks) {
           const result = suggestRelatedLinks(processedContent, { maxSuggestions, notePath });
@@ -9559,21 +9768,21 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
             suggestInfo = `Suggested: ${result.suggestions.join(", ")}`;
           }
         }
-        let finalFrontmatter = frontmatter;
+        let finalFrontmatter = effectiveFrontmatter;
         if (agent_id || session_id) {
-          finalFrontmatter = injectMutationMetadata(frontmatter, { agent_id, session_id });
+          finalFrontmatter = injectMutationMetadata(effectiveFrontmatter, { agent_id, session_id });
         }
         await writeVaultFile(vaultPath2, notePath, processedContent, finalFrontmatter);
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Flywheel:Create]");
         const infoLines = [wikilinkInfo, suggestInfo].filter(Boolean);
         const previewLines = [
-          `Frontmatter fields: ${Object.keys(frontmatter).join(", ") || "none"}`,
+          `Frontmatter fields: ${Object.keys(effectiveFrontmatter).join(", ") || "none"}`,
           `Content length: ${processedContent.length} chars`
         ];
         if (infoLines.length > 0) {
           previewLines.push(`(${infoLines.join("; ")})`);
         }
-        const hasAliases = frontmatter && "aliases" in frontmatter;
+        const hasAliases = effectiveFrontmatter && "aliases" in effectiveFrontmatter;
         if (!hasAliases) {
           const aliasSuggestions = suggestAliases(noteName, existingAliases);
           if (aliasSuggestions.length > 0) {
@@ -11476,6 +11685,531 @@ 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"
+];
+function computeMetrics(index) {
+  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;
+  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
+  };
+}
+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 8 metrics: note_count, link_count, orphan_count, tag_count, entity_count, avg_links_per_note, link_density, connected_ratio.',
+      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);
+          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);
+          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(
@@ -11708,9 +12442,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",
@@ -11769,6 +12508,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() {
@@ -11874,6 +12616,23 @@ async function updateEntitiesInStateDb() {
 async function runPostIndexWork(index) {
   await updateEntitiesInStateDb();
   await exportHubScores(index, stateDb);
+  if (stateDb) {
+    try {
+      const metrics = computeMetrics(index);
+      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) {
@@ -11939,8 +12698,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.9",
+  "version": "2.0.11",
   "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.9",
+    "@velvetmonkey/vault-core": "^2.0.11",
     "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",