@velvetmonkey/flywheel-memory 2.0.27 → 2.0.29

package/dist/index.js

@@ -59,7 +59,7 @@ var init_constants = __esm({
 
 // src/core/write/writer.ts
 import fs18 from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 import matter5 from "gray-matter";
 function isSensitivePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
@@ -386,8 +386,8 @@ function validatePath(vaultPath2, notePath) {
   if (notePath.startsWith("\\")) {
     return false;
   }
-  const resolvedVault = path17.resolve(vaultPath2);
-  const resolvedNote = path17.resolve(vaultPath2, notePath);
+  const resolvedVault = path18.resolve(vaultPath2);
+  const resolvedNote = path18.resolve(vaultPath2, notePath);
   return resolvedNote.startsWith(resolvedVault);
 }
 async function validatePathSecure(vaultPath2, notePath) {
@@ -415,8 +415,8 @@ async function validatePathSecure(vaultPath2, notePath) {
       reason: "Path traversal not allowed"
     };
   }
-  const resolvedVault = path17.resolve(vaultPath2);
-  const resolvedNote = path17.resolve(vaultPath2, notePath);
+  const resolvedVault = path18.resolve(vaultPath2);
+  const resolvedNote = path18.resolve(vaultPath2, notePath);
   if (!resolvedNote.startsWith(resolvedVault)) {
     return {
       valid: false,
@@ -430,7 +430,7 @@ async function validatePathSecure(vaultPath2, notePath) {
     };
   }
   try {
-    const fullPath = path17.join(vaultPath2, notePath);
+    const fullPath = path18.join(vaultPath2, notePath);
     try {
       await fs18.access(fullPath);
       const realPath = await fs18.realpath(fullPath);
@@ -441,7 +441,7 @@ async function validatePathSecure(vaultPath2, notePath) {
           reason: "Symlink target is outside vault"
         };
       }
-      const relativePath = path17.relative(realVaultPath, realPath);
+      const relativePath = path18.relative(realVaultPath, realPath);
       if (isSensitivePath(relativePath)) {
         return {
           valid: false,
@@ -449,7 +449,7 @@ async function validatePathSecure(vaultPath2, notePath) {
         };
       }
     } catch {
-      const parentDir = path17.dirname(fullPath);
+      const parentDir = path18.dirname(fullPath);
       try {
         await fs18.access(parentDir);
         const realParentPath = await fs18.realpath(parentDir);
@@ -475,8 +475,11 @@ async function readVaultFile(vaultPath2, notePath) {
   if (!validatePath(vaultPath2, notePath)) {
     throw new Error("Invalid path: path traversal not allowed");
   }
-  const fullPath = path17.join(vaultPath2, notePath);
-  const rawContent = await fs18.readFile(fullPath, "utf-8");
+  const fullPath = path18.join(vaultPath2, notePath);
+  const [rawContent, stat3] = await Promise.all([
+    fs18.readFile(fullPath, "utf-8"),
+    fs18.stat(fullPath)
+  ]);
   const lineEnding = detectLineEnding(rawContent);
   const normalizedContent = normalizeLineEndings(rawContent);
   const parsed = matter5(normalizedContent);
@@ -485,7 +488,8 @@ async function readVaultFile(vaultPath2, notePath) {
     content: parsed.content,
     frontmatter,
     rawContent,
-    lineEnding
+    lineEnding,
+    mtimeMs: stat3.mtimeMs
   };
 }
 function deepCloneFrontmatter(obj) {
@@ -524,7 +528,7 @@ async function writeVaultFile(vaultPath2, notePath, content, frontmatter, lineEn
   if (!validation.valid) {
     throw new Error(`Invalid path: ${validation.reason}`);
   }
-  const fullPath = path17.join(vaultPath2, notePath);
+  const fullPath = path18.join(vaultPath2, notePath);
   let output = matter5.stringify(content, frontmatter);
   output = normalizeTrailingNewline(output);
   output = convertLineEndings(output, lineEnding);
@@ -831,8 +835,8 @@ function createContext(variables = {}) {
     }
   };
 }
-function resolvePath(obj, path29) {
-  const parts = path29.split(".");
+function resolvePath(obj, path30) {
+  const parts = path30.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === void 0 || current === null) {
@@ -984,7 +988,7 @@ __export(schema_exports, {
   validatePolicySchema: () => validatePolicySchema,
   validateVariables: () => validateVariables
 });
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 function validatePolicySchema(policy) {
   const errors = [];
   const warnings = [];
@@ -1179,13 +1183,13 @@ var PolicyVariableTypeSchema, PolicyVariableSchema, ConditionCheckTypeSchema, Po
 var init_schema = __esm({
   "src/core/write/policy/schema.ts"() {
     "use strict";
-    PolicyVariableTypeSchema = z17.enum(["string", "number", "boolean", "array", "enum"]);
-    PolicyVariableSchema = z17.object({
+    PolicyVariableTypeSchema = z18.enum(["string", "number", "boolean", "array", "enum"]);
+    PolicyVariableSchema = z18.object({
       type: PolicyVariableTypeSchema,
-      required: z17.boolean().optional(),
-      default: z17.union([z17.string(), z17.number(), z17.boolean(), z17.array(z17.string())]).optional(),
-      enum: z17.array(z17.string()).optional(),
-      description: z17.string().optional()
+      required: z18.boolean().optional(),
+      default: z18.union([z18.string(), z18.number(), z18.boolean(), z18.array(z18.string())]).optional(),
+      enum: z18.array(z18.string()).optional(),
+      description: z18.string().optional()
     }).refine(
       (data) => {
         if (data.type === "enum" && (!data.enum || data.enum.length === 0)) {
@@ -1195,7 +1199,7 @@ var init_schema = __esm({
       },
       { message: "Enum type requires a non-empty enum array" }
     );
-    ConditionCheckTypeSchema = z17.enum([
+    ConditionCheckTypeSchema = z18.enum([
       "file_exists",
       "file_not_exists",
       "section_exists",
@@ -1204,13 +1208,13 @@ var init_schema = __esm({
       "frontmatter_exists",
       "frontmatter_not_exists"
     ]);
-    PolicyConditionSchema = z17.object({
-      id: z17.string().min(1, "Condition id is required"),
+    PolicyConditionSchema = z18.object({
+      id: z18.string().min(1, "Condition id is required"),
       check: ConditionCheckTypeSchema,
-      path: z17.string().optional(),
-      section: z17.string().optional(),
-      field: z17.string().optional(),
-      value: z17.union([z17.string(), z17.number(), z17.boolean()]).optional()
+      path: z18.string().optional(),
+      section: z18.string().optional(),
+      field: z18.string().optional(),
+      value: z18.union([z18.string(), z18.number(), z18.boolean()]).optional()
     }).refine(
       (data) => {
         if (["file_exists", "file_not_exists"].includes(data.check) && !data.path) {
@@ -1229,7 +1233,7 @@ var init_schema = __esm({
       },
       { message: "Condition is missing required fields for its check type" }
     );
-    PolicyToolNameSchema = z17.enum([
+    PolicyToolNameSchema = z18.enum([
       "vault_add_to_section",
       "vault_remove_from_section",
       "vault_replace_in_section",
@@ -1240,24 +1244,24 @@ var init_schema = __esm({
       "vault_update_frontmatter",
       "vault_add_frontmatter_field"
     ]);
-    PolicyStepSchema = z17.object({
-      id: z17.string().min(1, "Step id is required"),
+    PolicyStepSchema = z18.object({
+      id: z18.string().min(1, "Step id is required"),
       tool: PolicyToolNameSchema,
-      when: z17.string().optional(),
-      params: z17.record(z17.unknown()),
-      description: z17.string().optional()
+      when: z18.string().optional(),
+      params: z18.record(z18.unknown()),
+      description: z18.string().optional()
     });
-    PolicyOutputSchema = z17.object({
-      summary: z17.string().optional(),
-      files: z17.array(z17.string()).optional()
+    PolicyOutputSchema = z18.object({
+      summary: z18.string().optional(),
+      files: z18.array(z18.string()).optional()
     });
-    PolicyDefinitionSchema = z17.object({
-      version: z17.literal("1.0"),
-      name: z17.string().min(1, "Policy name is required"),
-      description: z17.string().min(1, "Policy description is required"),
-      variables: z17.record(PolicyVariableSchema).optional(),
-      conditions: z17.array(PolicyConditionSchema).optional(),
-      steps: z17.array(PolicyStepSchema).min(1, "At least one step is required"),
+    PolicyDefinitionSchema = z18.object({
+      version: z18.literal("1.0"),
+      name: z18.string().min(1, "Policy name is required"),
+      description: z18.string().min(1, "Policy description is required"),
+      variables: z18.record(PolicyVariableSchema).optional(),
+      conditions: z18.array(PolicyConditionSchema).optional(),
+      steps: z18.array(PolicyStepSchema).min(1, "At least one step is required"),
       output: PolicyOutputSchema.optional()
     });
   }
@@ -1270,8 +1274,8 @@ __export(conditions_exports, {
   evaluateCondition: () => evaluateCondition,
   shouldStepExecute: () => shouldStepExecute
 });
-import fs24 from "fs/promises";
-import path23 from "path";
+import fs25 from "fs/promises";
+import path24 from "path";
 async function evaluateCondition(condition, vaultPath2, context) {
   const interpolatedPath = condition.path ? interpolate(condition.path, context) : void 0;
   const interpolatedSection = condition.section ? interpolate(condition.section, context) : void 0;
@@ -1324,9 +1328,9 @@ async function evaluateCondition(condition, vaultPath2, context) {
   }
 }
 async function evaluateFileExists(vaultPath2, notePath, expectExists) {
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path24.join(vaultPath2, notePath);
   try {
-    await fs24.access(fullPath);
+    await fs25.access(fullPath);
     return {
       met: expectExists,
       reason: expectExists ? `File exists: ${notePath}` : `File exists (expected not to): ${notePath}`
@@ -1339,9 +1343,9 @@ async function evaluateFileExists(vaultPath2, notePath, expectExists) {
   }
 }
 async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectExists) {
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path24.join(vaultPath2, notePath);
   try {
-    await fs24.access(fullPath);
+    await fs25.access(fullPath);
   } catch {
     return {
       met: !expectExists,
@@ -1370,9 +1374,9 @@ async function evaluateSectionExists(vaultPath2, notePath, sectionName, expectEx
   }
 }
 async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expectExists) {
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path24.join(vaultPath2, notePath);
   try {
-    await fs24.access(fullPath);
+    await fs25.access(fullPath);
   } catch {
     return {
       met: !expectExists,
@@ -1401,9 +1405,9 @@ async function evaluateFrontmatterExists(vaultPath2, notePath, fieldName, expect
   }
 }
 async function evaluateFrontmatterEquals(vaultPath2, notePath, fieldName, expectedValue) {
-  const fullPath = path23.join(vaultPath2, notePath);
+  const fullPath = path24.join(vaultPath2, notePath);
   try {
-    await fs24.access(fullPath);
+    await fs25.access(fullPath);
   } catch {
     return {
       met: false,
@@ -1544,7 +1548,7 @@ var init_taskHelpers = __esm({
 });
 
 // src/index.ts
-import * as path28 from "path";
+import * as path29 from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -1633,6 +1637,21 @@ function isBinaryContent(content) {
   const nonPrintable = sample.replace(/[\x20-\x7E\t\n\r]/g, "").length;
   return nonPrintable / sample.length > 0.1;
 }
+function parseFrontmatterDate(value) {
+  if (value == null) return void 0;
+  let date;
+  if (value instanceof Date) {
+    date = value;
+  } else if (typeof value === "string" || typeof value === "number") {
+    date = new Date(value);
+  } else {
+    return void 0;
+  }
+  if (isNaN(date.getTime())) return void 0;
+  const year = date.getFullYear();
+  if (year < 2e3 || date.getTime() > Date.now() + 864e5) return void 0;
+  return date;
+}
 var WIKILINK_REGEX = /\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|([^\]]+))?\]\]/g;
 var TAG_REGEX = /(?:^|\s)#([a-zA-Z][a-zA-Z0-9_/-]*)/g;
 var CODE_BLOCK_REGEX = /```[\s\S]*?```|`[^`\n]+`/g;
@@ -1753,6 +1772,7 @@ async function parseNoteWithWarnings(file) {
     warnings.push(`Malformed frontmatter: ${err instanceof Error ? err.message : String(err)}`);
   }
   const title = file.path.replace(/\.md$/, "").split("/").pop() || file.path;
+  const created = parseFrontmatterDate(frontmatter.created) ?? file.created;
   return {
     note: {
       path: file.path,
@@ -1762,7 +1782,7 @@ async function parseNoteWithWarnings(file) {
       outlinks: extractWikilinks(markdown),
       tags: extractTags(markdown, frontmatter),
       modified: file.modified,
-      created: file.created
+      created
     },
     warnings,
     skipped: false
@@ -2189,8 +2209,8 @@ function updateIndexProgress(parsed, total) {
 function normalizeTarget(target) {
   return target.toLowerCase().replace(/\.md$/, "");
 }
-function normalizeNotePath(path29) {
-  return path29.toLowerCase().replace(/\.md$/, "");
+function normalizeNotePath(path30) {
+  return path30.toLowerCase().replace(/\.md$/, "");
 }
 async function buildVaultIndex(vaultPath2, options = {}) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, onProgress } = options;
@@ -2356,7 +2376,7 @@ function findSimilarEntity(index, target) {
   }
   const maxDist = normalizedLen <= 10 ? 1 : 2;
   let bestMatch;
-  for (const [entity, path29] of index.entities) {
+  for (const [entity, path30] of index.entities) {
     const lenDiff = Math.abs(entity.length - normalizedLen);
     if (lenDiff > maxDist) {
       continue;
@@ -2364,7 +2384,7 @@ function findSimilarEntity(index, target) {
     const dist = levenshteinDistance(normalized, entity);
     if (dist > 0 && dist <= maxDist) {
       if (!bestMatch || dist < bestMatch.distance) {
-        bestMatch = { path: path29, entity, distance: dist };
+        bestMatch = { path: path30, entity, distance: dist };
         if (dist === 1) {
           return bestMatch;
         }
@@ -2464,7 +2484,8 @@ import {
   saveFlywheelConfigToDb
 } from "@velvetmonkey/vault-core";
 var DEFAULT_CONFIG = {
-  exclude_task_tags: []
+  exclude_task_tags: [],
+  exclude_analysis_tags: []
 };
 function loadConfig(stateDb2) {
   if (stateDb2) {
@@ -2528,6 +2549,7 @@ function findMatchingFolder(folders, patterns) {
 function inferConfig(index, vaultPath2) {
   const inferred = {
     exclude_task_tags: [],
+    exclude_analysis_tags: [],
     paths: {}
   };
   if (vaultPath2) {
@@ -2553,6 +2575,7 @@ function inferConfig(index, vaultPath2) {
     const lowerTag = tag.toLowerCase();
     if (RECURRING_TAG_PATTERNS.some((pattern) => lowerTag.includes(pattern))) {
       inferred.exclude_task_tags.push(tag);
+      inferred.exclude_analysis_tags.push(tag);
     }
   }
   return inferred;
@@ -2826,30 +2849,30 @@ var EventQueue = class {
    * Add a new event to the queue
    */
   push(type, rawPath) {
-    const path29 = normalizePath(rawPath);
+    const path30 = normalizePath(rawPath);
     const now = Date.now();
     const event = {
       type,
-      path: path29,
+      path: path30,
       timestamp: now
     };
-    let pending = this.pending.get(path29);
+    let pending = this.pending.get(path30);
     if (!pending) {
       pending = {
         events: [],
         timer: null,
         lastEvent: now
       };
-      this.pending.set(path29, pending);
+      this.pending.set(path30, pending);
     }
     pending.events.push(event);
     pending.lastEvent = now;
-    console.error(`[flywheel] QUEUE: pushed ${type} for ${path29}, pending=${this.pending.size}`);
+    console.error(`[flywheel] QUEUE: pushed ${type} for ${path30}, pending=${this.pending.size}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
     }
     pending.timer = setTimeout(() => {
-      this.flushPath(path29);
+      this.flushPath(path30);
     }, this.config.debounceMs);
     if (this.pending.size >= this.config.batchSize) {
       this.flush();
@@ -2870,10 +2893,10 @@ var EventQueue = class {
   /**
    * Flush a single path's events
    */
-  flushPath(path29) {
-    const pending = this.pending.get(path29);
+  flushPath(path30) {
+    const pending = this.pending.get(path30);
     if (!pending || pending.events.length === 0) return;
-    console.error(`[flywheel] QUEUE: flushing ${path29}, events=${pending.events.length}`);
+    console.error(`[flywheel] QUEUE: flushing ${path30}, events=${pending.events.length}`);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -2882,7 +2905,7 @@ var EventQueue = class {
     if (coalescedType) {
       const coalesced = {
         type: coalescedType,
-        path: path29,
+        path: path30,
         originalEvents: [...pending.events]
       };
       this.onBatch({
@@ -2890,7 +2913,7 @@ var EventQueue = class {
         timestamp: Date.now()
       });
     }
-    this.pending.delete(path29);
+    this.pending.delete(path30);
   }
   /**
    * Flush all pending events
@@ -2902,7 +2925,7 @@ var EventQueue = class {
     }
     if (this.pending.size === 0) return;
     const events = [];
-    for (const [path29, pending] of this.pending) {
+    for (const [path30, pending] of this.pending) {
       if (pending.timer) {
         clearTimeout(pending.timer);
       }
@@ -2910,7 +2933,7 @@ var EventQueue = class {
       if (coalescedType) {
         events.push({
           type: coalescedType,
-          path: path29,
+          path: path30,
           originalEvents: [...pending.events]
         });
       }
@@ -3059,31 +3082,31 @@ function createVaultWatcher(options) {
         usePolling: config.usePolling,
         interval: config.usePolling ? config.pollInterval : void 0
       });
-      watcher.on("add", (path29) => {
-        console.error(`[flywheel] RAW EVENT: add ${path29}`);
-        if (shouldWatch(path29, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: add ${path29}`);
-          eventQueue.push("add", path29);
+      watcher.on("add", (path30) => {
+        console.error(`[flywheel] RAW EVENT: add ${path30}`);
+        if (shouldWatch(path30, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: add ${path30}`);
+          eventQueue.push("add", path30);
         } else {
-          console.error(`[flywheel] FILTERED: add ${path29}`);
+          console.error(`[flywheel] FILTERED: add ${path30}`);
         }
       });
-      watcher.on("change", (path29) => {
-        console.error(`[flywheel] RAW EVENT: change ${path29}`);
-        if (shouldWatch(path29, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: change ${path29}`);
-          eventQueue.push("change", path29);
+      watcher.on("change", (path30) => {
+        console.error(`[flywheel] RAW EVENT: change ${path30}`);
+        if (shouldWatch(path30, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: change ${path30}`);
+          eventQueue.push("change", path30);
         } else {
-          console.error(`[flywheel] FILTERED: change ${path29}`);
+          console.error(`[flywheel] FILTERED: change ${path30}`);
         }
       });
-      watcher.on("unlink", (path29) => {
-        console.error(`[flywheel] RAW EVENT: unlink ${path29}`);
-        if (shouldWatch(path29, vaultPath2)) {
-          console.error(`[flywheel] ACCEPTED: unlink ${path29}`);
-          eventQueue.push("unlink", path29);
+      watcher.on("unlink", (path30) => {
+        console.error(`[flywheel] RAW EVENT: unlink ${path30}`);
+        if (shouldWatch(path30, vaultPath2)) {
+          console.error(`[flywheel] ACCEPTED: unlink ${path30}`);
+          eventQueue.push("unlink", path30);
         } else {
-          console.error(`[flywheel] FILTERED: unlink ${path29}`);
+          console.error(`[flywheel] FILTERED: unlink ${path30}`);
         }
       });
       watcher.on("ready", () => {
@@ -3326,6 +3349,11 @@ function getSuppressedCount(stateDb2) {
   ).get();
   return row.count;
 }
+function getSuppressedEntities(stateDb2) {
+  return stateDb2.db.prepare(
+    "SELECT entity, false_positive_rate FROM wikilink_suppressions ORDER BY false_positive_rate DESC"
+  ).all();
+}
 function computeBoostFromAccuracy(accuracy, sampleCount) {
   if (sampleCount < FEEDBACK_BOOST_MIN_SAMPLES) return 0;
   for (const tier of FEEDBACK_BOOST_TIERS) {
@@ -3373,10 +3401,10 @@ function getAllFeedbackBoosts(stateDb2, folder) {
   for (const row of globalRows) {
     let accuracy;
     let sampleCount;
-    const fs29 = folderStats?.get(row.entity);
-    if (fs29 && fs29.count >= FEEDBACK_BOOST_MIN_SAMPLES) {
-      accuracy = fs29.accuracy;
-      sampleCount = fs29.count;
+    const fs30 = folderStats?.get(row.entity);
+    if (fs30 && fs30.count >= FEEDBACK_BOOST_MIN_SAMPLES) {
+      accuracy = fs30.accuracy;
+      sampleCount = fs30.count;
     } else {
       accuracy = row.correct_count / row.total;
       sampleCount = row.total;
@@ -3429,6 +3457,97 @@ function processImplicitFeedback(stateDb2, notePath, currentContent) {
   transaction();
   return removed;
 }
+var TIER_LABELS = [
+  { label: "Champion (+5)", boost: 5, minAccuracy: 0.95, minSamples: 20 },
+  { label: "Strong (+2)", boost: 2, minAccuracy: 0.8, minSamples: 5 },
+  { label: "Neutral (0)", boost: 0, minAccuracy: 0.6, minSamples: 5 },
+  { label: "Weak (-2)", boost: -2, minAccuracy: 0.4, minSamples: 5 },
+  { label: "Poor (-4)", boost: -4, minAccuracy: 0, minSamples: 5 }
+];
+function getDashboardData(stateDb2) {
+  const entityStats = getEntityStats(stateDb2);
+  const boostTiers = TIER_LABELS.map((t) => ({
+    label: t.label,
+    boost: t.boost,
+    min_accuracy: t.minAccuracy,
+    min_samples: t.minSamples,
+    entities: []
+  }));
+  const learning = [];
+  for (const es of entityStats) {
+    if (es.total < FEEDBACK_BOOST_MIN_SAMPLES) {
+      learning.push({ entity: es.entity, accuracy: es.accuracy, total: es.total });
+      continue;
+    }
+    const boost = computeBoostFromAccuracy(es.accuracy, es.total);
+    const tierIdx = boostTiers.findIndex((t) => t.boost === boost);
+    if (tierIdx >= 0) {
+      boostTiers[tierIdx].entities.push({ entity: es.entity, accuracy: es.accuracy, total: es.total });
+    }
+  }
+  const sourceRows = stateDb2.db.prepare(`
+    SELECT
+      CASE WHEN context LIKE 'implicit:%' THEN 'implicit' ELSE 'explicit' END as source,
+      COUNT(*) as count,
+      SUM(CASE WHEN correct = 1 THEN 1 ELSE 0 END) as correct_count
+    FROM wikilink_feedback
+    GROUP BY source
+  `).all();
+  const feedbackSources = {
+    explicit: { count: 0, correct: 0 },
+    implicit: { count: 0, correct: 0 }
+  };
+  for (const row of sourceRows) {
+    if (row.source === "implicit") {
+      feedbackSources.implicit = { count: row.count, correct: row.correct_count };
+    } else {
+      feedbackSources.explicit = { count: row.count, correct: row.correct_count };
+    }
+  }
+  const appRows = stateDb2.db.prepare(
+    `SELECT status, COUNT(*) as count FROM wikilink_applications GROUP BY status`
+  ).all();
+  const applications = { applied: 0, removed: 0 };
+  for (const row of appRows) {
+    if (row.status === "applied") applications.applied = row.count;
+    else if (row.status === "removed") applications.removed = row.count;
+  }
+  const recent = getFeedback(stateDb2, void 0, 50);
+  const suppressed = getSuppressedEntities(stateDb2);
+  const timeline = stateDb2.db.prepare(`
+    SELECT
+      date(created_at) as day,
+      COUNT(*) as count,
+      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
+    WHERE created_at >= datetime('now', '-30 days')
+    GROUP BY day
+    ORDER BY day
+  `).all();
+  const totalFeedback = feedbackSources.explicit.count + feedbackSources.implicit.count;
+  const totalCorrect = feedbackSources.explicit.correct + feedbackSources.implicit.correct;
+  const totalIncorrect = totalFeedback - totalCorrect;
+  return {
+    total_feedback: totalFeedback,
+    total_correct: totalCorrect,
+    total_incorrect: totalIncorrect,
+    overall_accuracy: totalFeedback > 0 ? Math.round(totalCorrect / totalFeedback * 1e3) / 1e3 : 0,
+    total_suppressed: suppressed.length,
+    feedback_sources: feedbackSources,
+    applications,
+    boost_tiers: boostTiers,
+    learning,
+    suppressed,
+    recent,
+    timeline: timeline.map((t) => ({
+      day: t.day,
+      count: t.count,
+      correct: t.correct_count,
+      incorrect: t.incorrect_count
+    }))
+  };
+}
 
 // src/core/write/git.ts
 import { simpleGit, CheckRepoActions } from "simple-git";
@@ -5875,12 +5994,402 @@ function getFTS5State() {
   return { ...state };
 }
 
-// src/index.ts
-import { openStateDb, scanVaultEntities as scanVaultEntities3, getSessionId, getAllEntitiesFromDb as getAllEntitiesFromDb2 } from "@velvetmonkey/vault-core";
+// src/core/read/taskCache.ts
+import * as path10 from "path";
 
-// src/tools/read/graph.ts
+// src/tools/read/tasks.ts
 import * as fs8 from "fs";
 import * as path9 from "path";
+var TASK_REGEX = /^(\s*)- \[([ xX\-])\]\s+(.+)$/;
+var TAG_REGEX2 = /#([a-zA-Z][a-zA-Z0-9_/-]*)/g;
+var DATE_REGEX = /\b(\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}\/\d{2,4})\b/;
+var HEADING_REGEX = /^(#{1,6})\s+(.+)$/;
+function parseStatus(char) {
+  if (char === " ") return "open";
+  if (char === "-") return "cancelled";
+  return "completed";
+}
+function extractTags2(text) {
+  const tags = [];
+  let match;
+  TAG_REGEX2.lastIndex = 0;
+  while ((match = TAG_REGEX2.exec(text)) !== null) {
+    tags.push(match[1]);
+  }
+  return tags;
+}
+function extractDueDate(text) {
+  const match = text.match(DATE_REGEX);
+  return match ? match[1] : void 0;
+}
+async function extractTasksFromNote(notePath, absolutePath) {
+  let content;
+  try {
+    content = await fs8.promises.readFile(absolutePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const lines = content.split("\n");
+  const tasks = [];
+  let currentHeading;
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+    const headingMatch = line.match(HEADING_REGEX);
+    if (headingMatch) {
+      currentHeading = headingMatch[2].trim();
+      continue;
+    }
+    const taskMatch = line.match(TASK_REGEX);
+    if (taskMatch) {
+      const statusChar = taskMatch[2];
+      const text = taskMatch[3].trim();
+      tasks.push({
+        path: notePath,
+        line: i + 1,
+        text,
+        status: parseStatus(statusChar),
+        raw: line,
+        context: currentHeading,
+        tags: extractTags2(text),
+        due_date: extractDueDate(text)
+      });
+    }
+  }
+  return tasks;
+}
+async function getAllTasks(index, vaultPath2, options = {}) {
+  const { status = "all", folder, tag, excludeTags = [], limit } = options;
+  const allTasks = [];
+  for (const note of index.notes.values()) {
+    if (folder && !note.path.startsWith(folder)) continue;
+    const absolutePath = path9.join(vaultPath2, note.path);
+    const tasks = await extractTasksFromNote(note.path, absolutePath);
+    allTasks.push(...tasks);
+  }
+  let filteredTasks = allTasks;
+  if (status !== "all") {
+    filteredTasks = allTasks.filter((t) => t.status === status);
+  }
+  if (tag) {
+    filteredTasks = filteredTasks.filter((t) => t.tags.includes(tag));
+  }
+  if (excludeTags.length > 0) {
+    filteredTasks = filteredTasks.filter(
+      (t) => !excludeTags.some((excludeTag) => t.tags.includes(excludeTag))
+    );
+  }
+  filteredTasks.sort((a, b) => {
+    if (a.due_date && !b.due_date) return -1;
+    if (!a.due_date && b.due_date) return 1;
+    if (a.due_date && b.due_date) {
+      const cmp = b.due_date.localeCompare(a.due_date);
+      if (cmp !== 0) return cmp;
+    }
+    const noteA = index.notes.get(a.path);
+    const noteB = index.notes.get(b.path);
+    const mtimeA = noteA?.modified?.getTime() ?? 0;
+    const mtimeB = noteB?.modified?.getTime() ?? 0;
+    return mtimeB - mtimeA;
+  });
+  const openCount = allTasks.filter((t) => t.status === "open").length;
+  const completedCount = allTasks.filter((t) => t.status === "completed").length;
+  const cancelledCount = allTasks.filter((t) => t.status === "cancelled").length;
+  const returnTasks = limit ? filteredTasks.slice(0, limit) : filteredTasks;
+  return {
+    total: allTasks.length,
+    open_count: openCount,
+    completed_count: completedCount,
+    cancelled_count: cancelledCount,
+    tasks: returnTasks
+  };
+}
+async function getTasksFromNote(index, notePath, vaultPath2, excludeTags = []) {
+  const note = index.notes.get(notePath);
+  if (!note) return null;
+  const absolutePath = path9.join(vaultPath2, notePath);
+  let tasks = await extractTasksFromNote(notePath, absolutePath);
+  if (excludeTags.length > 0) {
+    tasks = tasks.filter(
+      (t) => !excludeTags.some((excludeTag) => t.tags.includes(excludeTag))
+    );
+  }
+  return tasks;
+}
+async function getTasksWithDueDates(index, vaultPath2, options = {}) {
+  const { status = "open", folder, excludeTags } = options;
+  const result = await getAllTasks(index, vaultPath2, { status, folder, excludeTags });
+  return result.tasks.filter((t) => t.due_date).sort((a, b) => {
+    const dateA = a.due_date || "";
+    const dateB = b.due_date || "";
+    return dateA.localeCompare(dateB);
+  });
+}
+
+// src/core/shared/serverLog.ts
+var MAX_ENTRIES = 200;
+var buffer = [];
+var serverStartTs = Date.now();
+function serverLog(component, message, level = "info") {
+  const entry = {
+    ts: Date.now(),
+    component,
+    message,
+    level
+  };
+  buffer.push(entry);
+  if (buffer.length > MAX_ENTRIES) {
+    buffer.shift();
+  }
+  const prefix = level === "error" ? "[Memory] ERROR" : level === "warn" ? "[Memory] WARN" : "[Memory]";
+  console.error(`${prefix} [${component}] ${message}`);
+}
+function getServerLog(options = {}) {
+  const { since, component, limit = 100 } = options;
+  let entries = buffer;
+  if (since) {
+    entries = entries.filter((e) => e.ts > since);
+  }
+  if (component) {
+    entries = entries.filter((e) => e.component === component);
+  }
+  if (entries.length > limit) {
+    entries = entries.slice(-limit);
+  }
+  return {
+    entries,
+    server_uptime_ms: Date.now() - serverStartTs
+  };
+}
+
+// src/core/read/taskCache.ts
+var db3 = null;
+var TASK_CACHE_STALE_MS = 30 * 60 * 1e3;
+var cacheReady = false;
+var rebuildInProgress = false;
+function setTaskCacheDatabase(database) {
+  db3 = database;
+  try {
+    const row = db3.prepare(
+      "SELECT value FROM fts_metadata WHERE key = ?"
+    ).get("task_cache_built");
+    if (row) {
+      cacheReady = true;
+    }
+  } catch {
+  }
+}
+function isTaskCacheReady() {
+  return cacheReady && db3 !== null;
+}
+async function buildTaskCache(vaultPath2, index, excludeTags) {
+  if (!db3) {
+    throw new Error("Task cache database not initialized. Call setTaskCacheDatabase() first.");
+  }
+  if (rebuildInProgress) return;
+  rebuildInProgress = true;
+  const start = Date.now();
+  try {
+    const insertStmt = db3.prepare(`
+      INSERT OR REPLACE INTO tasks (path, line, text, status, raw, context, tags_json, due_date)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const insertAll = db3.transaction(() => {
+      db3.prepare("DELETE FROM tasks").run();
+      let count = 0;
+      const promises7 = [];
+      const notePaths2 = [];
+      for (const note of index.notes.values()) {
+        notePaths2.push(note.path);
+      }
+      return { notePaths: notePaths2, insertStmt };
+    });
+    const { notePaths, insertStmt: stmt } = insertAll();
+    let totalTasks = 0;
+    for (const notePath of notePaths) {
+      const absolutePath = path10.join(vaultPath2, notePath);
+      const tasks = await extractTasksFromNote(notePath, absolutePath);
+      if (tasks.length > 0) {
+        const insertBatch = db3.transaction(() => {
+          for (const task of tasks) {
+            if (excludeTags?.length && excludeTags.some((t) => task.tags.includes(t))) {
+              continue;
+            }
+            stmt.run(
+              task.path,
+              task.line,
+              task.text,
+              task.status,
+              task.raw,
+              task.context ?? null,
+              task.tags.length > 0 ? JSON.stringify(task.tags) : null,
+              task.due_date ?? null
+            );
+            totalTasks++;
+          }
+        });
+        insertBatch();
+      }
+    }
+    db3.prepare(
+      "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)"
+    ).run("task_cache_built", (/* @__PURE__ */ new Date()).toISOString());
+    cacheReady = true;
+    const duration = Date.now() - start;
+    serverLog("tasks", `Task cache built: ${totalTasks} tasks from ${notePaths.length} notes in ${duration}ms`);
+  } finally {
+    rebuildInProgress = false;
+  }
+}
+async function updateTaskCacheForFile(vaultPath2, relativePath) {
+  if (!db3) return;
+  db3.prepare("DELETE FROM tasks WHERE path = ?").run(relativePath);
+  const absolutePath = path10.join(vaultPath2, relativePath);
+  const tasks = await extractTasksFromNote(relativePath, absolutePath);
+  if (tasks.length > 0) {
+    const insertStmt = db3.prepare(`
+      INSERT OR REPLACE INTO tasks (path, line, text, status, raw, context, tags_json, due_date)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const insertBatch = db3.transaction(() => {
+      for (const task of tasks) {
+        insertStmt.run(
+          task.path,
+          task.line,
+          task.text,
+          task.status,
+          task.raw,
+          task.context ?? null,
+          task.tags.length > 0 ? JSON.stringify(task.tags) : null,
+          task.due_date ?? null
+        );
+      }
+    });
+    insertBatch();
+  }
+}
+function removeTaskCacheForFile(relativePath) {
+  if (!db3) return;
+  db3.prepare("DELETE FROM tasks WHERE path = ?").run(relativePath);
+}
+function queryTasksFromCache(options) {
+  if (!db3) {
+    throw new Error("Task cache database not initialized.");
+  }
+  const { status = "all", folder, tag, excludeTags = [], has_due_date, limit, offset = 0 } = options;
+  const conditions = [];
+  const params = [];
+  if (status !== "all") {
+    conditions.push("status = ?");
+    params.push(status);
+  }
+  if (folder) {
+    conditions.push("path LIKE ?");
+    params.push(folder + "%");
+  }
+  if (has_due_date) {
+    conditions.push("due_date IS NOT NULL");
+  }
+  if (tag) {
+    conditions.push("EXISTS (SELECT 1 FROM json_each(tags_json) WHERE value = ?)");
+    params.push(tag);
+  }
+  if (excludeTags.length > 0) {
+    const placeholders = excludeTags.map(() => "?").join(", ");
+    conditions.push(`NOT EXISTS (SELECT 1 FROM json_each(tags_json) WHERE value IN (${placeholders}))`);
+    params.push(...excludeTags);
+  }
+  const whereClause = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
+  const countConditions = [];
+  const countParams = [];
+  if (folder) {
+    countConditions.push("path LIKE ?");
+    countParams.push(folder + "%");
+  }
+  if (excludeTags.length > 0) {
+    const placeholders = excludeTags.map(() => "?").join(", ");
+    countConditions.push(`NOT EXISTS (SELECT 1 FROM json_each(tags_json) WHERE value IN (${placeholders}))`);
+    countParams.push(...excludeTags);
+  }
+  const countWhere = countConditions.length > 0 ? "WHERE " + countConditions.join(" AND ") : "";
+  const countRows = db3.prepare(
+    `SELECT status, COUNT(*) as cnt FROM tasks ${countWhere} GROUP BY status`
+  ).all(...countParams);
+  let openCount = 0;
+  let completedCount = 0;
+  let cancelledCount = 0;
+  let total = 0;
+  for (const row of countRows) {
+    total += row.cnt;
+    if (row.status === "open") openCount = row.cnt;
+    else if (row.status === "completed") completedCount = row.cnt;
+    else if (row.status === "cancelled") cancelledCount = row.cnt;
+  }
+  let orderBy;
+  if (has_due_date) {
+    orderBy = "ORDER BY due_date ASC, path";
+  } else {
+    orderBy = "ORDER BY CASE WHEN due_date IS NOT NULL THEN 0 ELSE 1 END, due_date DESC, path";
+  }
+  let limitClause = "";
+  const queryParams = [...params];
+  if (limit !== void 0) {
+    limitClause = " LIMIT ? OFFSET ?";
+    queryParams.push(limit, offset);
+  }
+  const rows = db3.prepare(
+    `SELECT path, line, text, status, raw, context, tags_json, due_date FROM tasks ${whereClause} ${orderBy}${limitClause}`
+  ).all(...queryParams);
+  const tasks = rows.map((row) => ({
+    path: row.path,
+    line: row.line,
+    text: row.text,
+    status: row.status,
+    raw: row.raw,
+    context: row.context ?? void 0,
+    tags: row.tags_json ? JSON.parse(row.tags_json) : [],
+    due_date: row.due_date ?? void 0
+  }));
+  return {
+    total,
+    open_count: openCount,
+    completed_count: completedCount,
+    cancelled_count: cancelledCount,
+    tasks
+  };
+}
+function isTaskCacheStale() {
+  if (!db3) return true;
+  try {
+    const row = db3.prepare(
+      "SELECT value FROM fts_metadata WHERE key = ?"
+    ).get("task_cache_built");
+    if (!row) return true;
+    const builtAt = new Date(row.value).getTime();
+    const age = Date.now() - builtAt;
+    return age > TASK_CACHE_STALE_MS;
+  } catch {
+    return true;
+  }
+}
+function refreshIfStale(vaultPath2, index, excludeTags) {
+  if (!isTaskCacheStale() || rebuildInProgress) return;
+  buildTaskCache(vaultPath2, index, excludeTags).catch((err) => {
+    serverLog("tasks", `Task cache background refresh failed: ${err instanceof Error ? err.message : err}`, "error");
+  });
+}
+
+// src/index.ts
+import { openStateDb, scanVaultEntities as scanVaultEntities3, getSessionId, getAllEntitiesFromDb as getAllEntitiesFromDb3 } from "@velvetmonkey/vault-core";
+
+// src/tools/read/graph.ts
+import * as fs9 from "fs";
+import * as path11 from "path";
 import { z } from "zod";
 
 // src/core/read/constants.ts
@@ -6164,8 +6673,8 @@ function requireIndex() {
 // src/tools/read/graph.ts
 async function getContext(vaultPath2, sourcePath, line, contextLines = 1) {
   try {
-    const fullPath = path9.join(vaultPath2, sourcePath);
-    const content = await fs8.promises.readFile(fullPath, "utf-8");
+    const fullPath = path11.join(vaultPath2, sourcePath);
+    const content = await fs9.promises.readFile(fullPath, "utf-8");
     const lines = content.split("\n");
     const startLine = Math.max(0, line - 1 - contextLines);
     const endLine = Math.min(lines.length, line + contextLines);
@@ -6468,14 +6977,14 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
   };
   function findSimilarEntity2(target, entities) {
     const targetLower = target.toLowerCase();
-    for (const [name, path29] of entities) {
+    for (const [name, path30] of entities) {
       if (name.startsWith(targetLower) || targetLower.startsWith(name)) {
-        return path29;
+        return path30;
       }
     }
-    for (const [name, path29] of entities) {
+    for (const [name, path30] of entities) {
       if (name.includes(targetLower) || targetLower.includes(name)) {
-        return path29;
+        return path30;
       }
     }
     return void 0;
@@ -6557,7 +7066,7 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
 }
 
 // src/tools/read/health.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import { z as z3 } from "zod";
 
 // src/tools/read/periodic.ts
@@ -6897,6 +7406,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
     note_count: z3.coerce.number().describe("Number of notes in the index"),
     entity_count: z3.coerce.number().describe("Number of linkable entities (titles + aliases)"),
     tag_count: z3.coerce.number().describe("Number of unique tags"),
+    link_count: z3.coerce.number().describe("Total number of outgoing wikilinks"),
     periodic_notes: z3.array(PeriodicNoteInfoSchema).optional().describe("Detected periodic note conventions"),
     config: z3.record(z3.unknown()).optional().describe("Current flywheel config (paths, templates, etc.)"),
     last_rebuild: z3.object({
@@ -6929,7 +7439,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       const indexErrorObj = getIndexError();
       let vaultAccessible = false;
       try {
-        fs9.accessSync(vaultPath2, fs9.constants.R_OK);
+        fs10.accessSync(vaultPath2, fs10.constants.R_OK);
         vaultAccessible = true;
       } catch {
         vaultAccessible = false;
@@ -6950,6 +7460,10 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       const noteCount = indexBuilt ? index.notes.size : 0;
       const entityCount = indexBuilt ? index.entities.size : 0;
       const tagCount = indexBuilt ? index.tags.size : 0;
+      let linkCount = 0;
+      if (indexBuilt) {
+        for (const note of index.notes.values()) linkCount += note.outlinks.length;
+      }
       if (indexBuilt && noteCount === 0 && vaultAccessible) {
         recommendations.push("No notes found in vault. Is PROJECT_PATH pointing to a markdown vault?");
       }
@@ -7010,6 +7524,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
         note_count: noteCount,
         entity_count: entityCount,
         tag_count: tagCount,
+        link_count: linkCount,
         periodic_notes: periodicNotes && periodicNotes.length > 0 ? periodicNotes : void 0,
         config: configInfo,
         last_rebuild: lastRebuild,
@@ -7067,8 +7582,8 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       daily_counts: z3.record(z3.number())
     }).describe("Activity summary for the last 7 days")
   };
-  function isPeriodicNote(path29) {
-    const filename = path29.split("/").pop() || "";
+  function isPeriodicNote2(path30) {
+    const filename = path30.split("/").pop() || "";
     const nameWithoutExt = filename.replace(/\.md$/, "");
     const patterns = [
       /^\d{4}-\d{2}-\d{2}$/,
@@ -7083,7 +7598,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       // YYYY (yearly)
     ];
     const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
-    const folder = path29.split("/")[0]?.toLowerCase() || "";
+    const folder = path30.split("/")[0]?.toLowerCase() || "";
     return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
   }
   server2.registerTool(
@@ -7117,7 +7632,7 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
         const backlinks = getBacklinksForNote(index, note.path);
         if (backlinks.length === 0) {
           orphanTotal++;
-          if (isPeriodicNote(note.path)) {
+          if (isPeriodicNote2(note.path)) {
             orphanPeriodic++;
           } else {
             orphanContent++;
@@ -7174,6 +7689,45 @@ function registerHealthTools(server2, getIndex, getVaultPath, getConfig = () =>
       };
     }
   );
+  const LogEntrySchema = z3.object({
+    ts: z3.number().describe("Unix timestamp (ms)"),
+    component: z3.string().describe("Source component"),
+    message: z3.string().describe("Log message"),
+    level: z3.enum(["info", "warn", "error"]).describe("Log level")
+  });
+  const ServerLogOutputSchema = {
+    entries: z3.array(LogEntrySchema).describe("Log entries (oldest first)"),
+    server_uptime_ms: z3.coerce.number().describe("Server uptime in milliseconds")
+  };
+  server2.registerTool(
+    "server_log",
+    {
+      title: "Server Activity Log",
+      description: "Query the server activity log. Returns timestamped entries for startup stages, indexing progress, errors, and runtime events. Useful for diagnosing startup issues or checking what the server has been doing.",
+      inputSchema: {
+        since: z3.coerce.number().optional().describe("Only return entries after this Unix timestamp (ms)"),
+        component: z3.string().optional().describe("Filter by component (server, index, fts5, semantic, tasks, watcher, statedb, config)"),
+        limit: z3.coerce.number().optional().describe("Max entries to return (default 100)")
+      },
+      outputSchema: ServerLogOutputSchema
+    },
+    async (params) => {
+      const result = getServerLog({
+        since: params.since,
+        component: params.component,
+        limit: params.limit
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ],
+        structuredContent: result
+      };
+    }
+  );
 }
 
 // src/tools/read/query.ts
@@ -7451,10 +8005,68 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
 }
 
 // src/tools/read/system.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs11 from "fs";
+import * as path12 from "path";
 import { z as z5 } from "zod";
 import { scanVaultEntities as scanVaultEntities2, getEntityIndexFromDb as getEntityIndexFromDb2 } from "@velvetmonkey/vault-core";
+
+// src/core/read/aliasSuggestions.ts
+function generateAliasCandidates(entityName, existingAliases) {
+  const existing = new Set(existingAliases.map((a) => a.toLowerCase()));
+  const candidates = [];
+  const words = entityName.split(/[\s-]+/).filter((w) => w.length > 0);
+  if (words.length >= 2) {
+    const acronym = words.map((w) => w[0]).join("").toUpperCase();
+    if (acronym.length >= 2 && acronym.length <= 6 && !existing.has(acronym.toLowerCase())) {
+      candidates.push({ candidate: acronym, type: "acronym" });
+    }
+    if (words.length >= 3) {
+      const short = words[0];
+      if (short.length >= 3 && !existing.has(short.toLowerCase())) {
+        candidates.push({ candidate: short, type: "short_form" });
+      }
+    }
+  }
+  return candidates;
+}
+function suggestEntityAliases(stateDb2, folder) {
+  const db4 = stateDb2.db;
+  const entities = folder ? db4.prepare(
+    "SELECT name, path, aliases_json FROM entities WHERE path LIKE ? || '/%'"
+  ).all(folder) : db4.prepare("SELECT name, path, aliases_json FROM entities").all();
+  const allEntityNames = new Set(
+    db4.prepare("SELECT name_lower FROM entities").all().map((r) => r.name_lower)
+  );
+  const suggestions = [];
+  const countStmt = db4.prepare(
+    "SELECT COUNT(*) as cnt FROM notes_fts WHERE content MATCH ?"
+  );
+  for (const row of entities) {
+    const aliases = row.aliases_json ? JSON.parse(row.aliases_json) : [];
+    const candidates = generateAliasCandidates(row.name, aliases);
+    for (const { candidate, type } of candidates) {
+      if (allEntityNames.has(candidate.toLowerCase())) continue;
+      let mentions = 0;
+      try {
+        const result = countStmt.get(`"${candidate}"`);
+        mentions = result?.cnt ?? 0;
+      } catch {
+      }
+      suggestions.push({
+        entity: row.name,
+        entity_path: row.path,
+        current_aliases: aliases,
+        candidate,
+        type,
+        mentions
+      });
+    }
+  }
+  suggestions.sort((a, b) => b.mentions - a.mentions || a.entity.localeCompare(b.entity));
+  return suggestions;
+}
+
+// src/tools/read/system.ts
 function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfig, getStateDb) {
   const RefreshIndexOutputSchema = {
     success: z5.boolean().describe("Whether the refresh succeeded"),
@@ -7685,8 +8297,8 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
           continue;
         }
         try {
-          const fullPath = path10.join(vaultPath2, note.path);
-          const content = await fs10.promises.readFile(fullPath, "utf-8");
+          const fullPath = path12.join(vaultPath2, note.path);
+          const content = await fs11.promises.readFile(fullPath, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
@@ -7801,8 +8413,8 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
       let wordCount;
       if (include_word_count) {
         try {
-          const fullPath = path10.join(vaultPath2, resolvedPath);
-          const content = await fs10.promises.readFile(fullPath, "utf-8");
+          const fullPath = path12.join(vaultPath2, resolvedPath);
+          const content = await fs11.promises.readFile(fullPath, "utf-8");
           wordCount = content.split(/\s+/).filter((w) => w.length > 0).length;
         } catch {
         }
@@ -7941,15 +8553,44 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
       };
     }
   );
+  server2.registerTool(
+    "suggest_entity_aliases",
+    {
+      title: "Suggest Entity Aliases",
+      description: "Generate alias suggestions for entities in a folder based on acronyms and short forms, validated against vault content.",
+      inputSchema: {
+        folder: z5.string().optional().describe("Folder path to scope suggestions to"),
+        limit: z5.number().default(20).describe("Max suggestions to return")
+      }
+    },
+    async ({
+      folder,
+      limit: requestedLimit
+    }) => {
+      const stateDb2 = getStateDb?.();
+      if (!stateDb2) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
+        };
+      }
+      const suggestions = suggestEntityAliases(stateDb2, folder || void 0);
+      const limit = Math.min(requestedLimit ?? 20, 50);
+      const limited = suggestions.slice(0, limit);
+      const output = { suggestion_count: limited.length, suggestions: limited };
+      return {
+        content: [{ type: "text", text: JSON.stringify(output, null, 2) }]
+      };
+    }
+  );
 }
 
 // src/tools/read/primitives.ts
 import { z as z6 } from "zod";
 
 // src/tools/read/structure.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
-var HEADING_REGEX = /^(#{1,6})\s+(.+)$/;
+import * as fs12 from "fs";
+import * as path13 from "path";
+var HEADING_REGEX2 = /^(#{1,6})\s+(.+)$/;
 function extractHeadings(content) {
   const lines = content.split("\n");
   const headings = [];
@@ -7961,7 +8602,7 @@ function extractHeadings(content) {
       continue;
     }
     if (inCodeBlock) continue;
-    const match = line.match(HEADING_REGEX);
+    const match = line.match(HEADING_REGEX2);
     if (match) {
       headings.push({
         level: match[1].length,
@@ -8002,10 +8643,10 @@ function buildSections(headings, totalLines) {
 async function getNoteStructure(index, notePath, vaultPath2) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path11.join(vaultPath2, notePath);
+  const absolutePath = path13.join(vaultPath2, notePath);
   let content;
   try {
-    content = await fs11.promises.readFile(absolutePath, "utf-8");
+    content = await fs12.promises.readFile(absolutePath, "utf-8");
   } catch {
     return null;
   }
@@ -8025,10 +8666,10 @@ async function getNoteStructure(index, notePath, vaultPath2) {
 async function getSectionContent(index, notePath, headingText, vaultPath2, includeSubheadings = true) {
   const note = index.notes.get(notePath);
   if (!note) return null;
-  const absolutePath = path11.join(vaultPath2, notePath);
+  const absolutePath = path13.join(vaultPath2, notePath);
   let content;
   try {
-    content = await fs11.promises.readFile(absolutePath, "utf-8");
+    content = await fs12.promises.readFile(absolutePath, "utf-8");
   } catch {
     return null;
   }
@@ -8067,10 +8708,10 @@ async function findSections(index, headingPattern, vaultPath2, folder) {
   const results = [];
   for (const note of index.notes.values()) {
     if (folder && !note.path.startsWith(folder)) continue;
-    const absolutePath = path11.join(vaultPath2, note.path);
+    const absolutePath = path13.join(vaultPath2, note.path);
     let content;
     try {
-      content = await fs11.promises.readFile(absolutePath, "utf-8");
+      content = await fs12.promises.readFile(absolutePath, "utf-8");
     } catch {
       continue;
     }
@@ -8089,140 +8730,6 @@ async function findSections(index, headingPattern, vaultPath2, folder) {
   return results;
 }
 
-// src/tools/read/tasks.ts
-import * as fs12 from "fs";
-import * as path12 from "path";
-var TASK_REGEX = /^(\s*)- \[([ xX\-])\]\s+(.+)$/;
-var TAG_REGEX2 = /#([a-zA-Z][a-zA-Z0-9_/-]*)/g;
-var DATE_REGEX = /\b(\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}\/\d{2,4})\b/;
-var HEADING_REGEX2 = /^(#{1,6})\s+(.+)$/;
-function parseStatus(char) {
-  if (char === " ") return "open";
-  if (char === "-") return "cancelled";
-  return "completed";
-}
-function extractTags2(text) {
-  const tags = [];
-  let match;
-  TAG_REGEX2.lastIndex = 0;
-  while ((match = TAG_REGEX2.exec(text)) !== null) {
-    tags.push(match[1]);
-  }
-  return tags;
-}
-function extractDueDate(text) {
-  const match = text.match(DATE_REGEX);
-  return match ? match[1] : void 0;
-}
-async function extractTasksFromNote(notePath, absolutePath) {
-  let content;
-  try {
-    content = await fs12.promises.readFile(absolutePath, "utf-8");
-  } catch {
-    return [];
-  }
-  const lines = content.split("\n");
-  const tasks = [];
-  let currentHeading;
-  let inCodeBlock = false;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.startsWith("```")) {
-      inCodeBlock = !inCodeBlock;
-      continue;
-    }
-    if (inCodeBlock) continue;
-    const headingMatch = line.match(HEADING_REGEX2);
-    if (headingMatch) {
-      currentHeading = headingMatch[2].trim();
-      continue;
-    }
-    const taskMatch = line.match(TASK_REGEX);
-    if (taskMatch) {
-      const statusChar = taskMatch[2];
-      const text = taskMatch[3].trim();
-      tasks.push({
-        path: notePath,
-        line: i + 1,
-        text,
-        status: parseStatus(statusChar),
-        raw: line,
-        context: currentHeading,
-        tags: extractTags2(text),
-        due_date: extractDueDate(text)
-      });
-    }
-  }
-  return tasks;
-}
-async function getAllTasks(index, vaultPath2, options = {}) {
-  const { status = "all", folder, tag, excludeTags = [], limit } = options;
-  const allTasks = [];
-  for (const note of index.notes.values()) {
-    if (folder && !note.path.startsWith(folder)) continue;
-    const absolutePath = path12.join(vaultPath2, note.path);
-    const tasks = await extractTasksFromNote(note.path, absolutePath);
-    allTasks.push(...tasks);
-  }
-  let filteredTasks = allTasks;
-  if (status !== "all") {
-    filteredTasks = allTasks.filter((t) => t.status === status);
-  }
-  if (tag) {
-    filteredTasks = filteredTasks.filter((t) => t.tags.includes(tag));
-  }
-  if (excludeTags.length > 0) {
-    filteredTasks = filteredTasks.filter(
-      (t) => !excludeTags.some((excludeTag) => t.tags.includes(excludeTag))
-    );
-  }
-  filteredTasks.sort((a, b) => {
-    if (a.due_date && !b.due_date) return -1;
-    if (!a.due_date && b.due_date) return 1;
-    if (a.due_date && b.due_date) {
-      const cmp = b.due_date.localeCompare(a.due_date);
-      if (cmp !== 0) return cmp;
-    }
-    const noteA = index.notes.get(a.path);
-    const noteB = index.notes.get(b.path);
-    const mtimeA = noteA?.modified?.getTime() ?? 0;
-    const mtimeB = noteB?.modified?.getTime() ?? 0;
-    return mtimeB - mtimeA;
-  });
-  const openCount = allTasks.filter((t) => t.status === "open").length;
-  const completedCount = allTasks.filter((t) => t.status === "completed").length;
-  const cancelledCount = allTasks.filter((t) => t.status === "cancelled").length;
-  const returnTasks = limit ? filteredTasks.slice(0, limit) : filteredTasks;
-  return {
-    total: allTasks.length,
-    open_count: openCount,
-    completed_count: completedCount,
-    cancelled_count: cancelledCount,
-    tasks: returnTasks
-  };
-}
-async function getTasksFromNote(index, notePath, vaultPath2, excludeTags = []) {
-  const note = index.notes.get(notePath);
-  if (!note) return null;
-  const absolutePath = path12.join(vaultPath2, notePath);
-  let tasks = await extractTasksFromNote(notePath, absolutePath);
-  if (excludeTags.length > 0) {
-    tasks = tasks.filter(
-      (t) => !excludeTags.some((excludeTag) => t.tags.includes(excludeTag))
-    );
-  }
-  return tasks;
-}
-async function getTasksWithDueDates(index, vaultPath2, options = {}) {
-  const { status = "open", folder, excludeTags } = options;
-  const result = await getAllTasks(index, vaultPath2, { status, folder, excludeTags });
-  return result.tasks.filter((t) => t.due_date).sort((a, b) => {
-    const dateA = a.due_date || "";
-    const dateB = b.due_date || "";
-    return dateA.localeCompare(dateB);
-  });
-}
-
 // src/tools/read/primitives.ts
 function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = () => ({})) {
   server2.registerTool(
@@ -8235,18 +8742,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: path29, include_content }) => {
+    async ({ path: path30, include_content }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getNoteStructure(index, path29, vaultPath2);
+      const result = await getNoteStructure(index, path30, vaultPath2);
       if (!result) {
         return {
-          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path29 }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path30 }, null, 2) }]
         };
       }
       if (include_content) {
         for (const section of result.sections) {
-          const sectionResult = await getSectionContent(index, path29, section.heading.text, vaultPath2, true);
+          const sectionResult = await getSectionContent(index, path30, section.heading.text, vaultPath2, true);
           if (sectionResult) {
             section.content = sectionResult.content;
           }
@@ -8268,15 +8775,15 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         include_subheadings: z6.boolean().default(true).describe("Include content under subheadings")
       }
     },
-    async ({ path: path29, heading, include_subheadings }) => {
+    async ({ path: path30, heading, include_subheadings }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
-      const result = await getSectionContent(index, path29, heading, vaultPath2, include_subheadings);
+      const result = await getSectionContent(index, path30, heading, vaultPath2, include_subheadings);
       if (!result) {
         return {
           content: [{ type: "text", text: JSON.stringify({
             error: "Section not found",
-            path: path29,
+            path: path30,
             heading
           }, null, 2) }]
         };
@@ -8330,16 +8837,16 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         offset: z6.coerce.number().default(0).describe("Number of results to skip (for pagination)")
       }
     },
-    async ({ path: path29, status, has_due_date, folder, tag, limit: requestedLimit, offset }) => {
+    async ({ path: path30, 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 (path29) {
-        const result2 = await getTasksFromNote(index, path29, vaultPath2, config.exclude_task_tags || []);
+      if (path30) {
+        const result2 = await getTasksFromNote(index, path30, vaultPath2, config.exclude_task_tags || []);
         if (!result2) {
           return {
-            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path29 }, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify({ error: "Note not found", path: path30 }, null, 2) }]
           };
         }
         let filtered = result2;
@@ -8349,7 +8856,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         const paged2 = filtered.slice(offset, offset + limit);
         return {
           content: [{ type: "text", text: JSON.stringify({
-            path: path29,
+            path: path30,
             total_count: filtered.length,
             returned_count: paged2.length,
             open: result2.filter((t) => t.status === "open").length,
@@ -8358,6 +8865,44 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
           }, null, 2) }]
         };
       }
+      if (isTaskCacheReady()) {
+        refreshIfStale(vaultPath2, index, config.exclude_task_tags);
+        if (has_due_date) {
+          const result3 = queryTasksFromCache({
+            status,
+            folder,
+            excludeTags: config.exclude_task_tags,
+            has_due_date: true,
+            limit,
+            offset
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              total_count: result3.total,
+              returned_count: result3.tasks.length,
+              tasks: result3.tasks
+            }, null, 2) }]
+          };
+        }
+        const result2 = queryTasksFromCache({
+          status,
+          folder,
+          tag,
+          excludeTags: config.exclude_task_tags,
+          limit,
+          offset
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            total_count: result2.total,
+            open_count: result2.open_count,
+            completed_count: result2.completed_count,
+            cancelled_count: result2.cancelled_count,
+            returned_count: result2.tasks.length,
+            tasks: result2.tasks
+          }, null, 2) }]
+        };
+      }
       if (has_due_date) {
         const allResults = await getTasksWithDueDates(index, vaultPath2, {
           status,
@@ -8385,6 +8930,8 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
         content: [{ type: "text", text: JSON.stringify({
           total_count: result.total,
           open_count: result.open_count,
+          completed_count: result.completed_count,
+          cancelled_count: result.cancelled_count,
           returned_count: paged.length,
           tasks: paged
         }, null, 2) }]
@@ -8465,7 +9012,7 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
 // src/tools/read/migrations.ts
 import { z as z7 } from "zod";
 import * as fs13 from "fs/promises";
-import * as path13 from "path";
+import * as path14 from "path";
 import matter2 from "gray-matter";
 function getNotesInFolder(index, folder) {
   const notes = [];
@@ -8478,7 +9025,7 @@ function getNotesInFolder(index, folder) {
   return notes;
 }
 async function readFileContent(notePath, vaultPath2) {
-  const fullPath = path13.join(vaultPath2, notePath);
+  const fullPath = path14.join(vaultPath2, notePath);
   try {
     return await fs13.readFile(fullPath, "utf-8");
   } catch {
@@ -8486,7 +9033,7 @@ async function readFileContent(notePath, vaultPath2) {
   }
 }
 async function writeFileContent(notePath, vaultPath2, content) {
-  const fullPath = path13.join(vaultPath2, notePath);
+  const fullPath = path14.join(vaultPath2, notePath);
   try {
     await fs13.writeFile(fullPath, content, "utf-8");
     return true;
@@ -8667,7 +9214,7 @@ function registerMigrationTools(server2, getIndex, getVaultPath) {
 
 // src/tools/read/graphAnalysis.ts
 import fs14 from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 import { z as z8 } from "zod";
 
 // src/tools/read/schema.ts
@@ -9221,7 +9768,26 @@ function purgeOldSnapshots(stateDb2, retentionDays = 90) {
 }
 
 // src/tools/read/graphAnalysis.ts
-function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb) {
+function isPeriodicNote(notePath) {
+  const filename = notePath.split("/").pop() || "";
+  const nameWithoutExt = filename.replace(/\.md$/, "");
+  const patterns = [
+    /^\d{4}-\d{2}-\d{2}$/,
+    // YYYY-MM-DD (daily)
+    /^\d{4}-W\d{2}$/,
+    // YYYY-Wnn (weekly)
+    /^\d{4}-\d{2}$/,
+    // YYYY-MM (monthly)
+    /^\d{4}-Q[1-4]$/,
+    // YYYY-Qn (quarterly)
+    /^\d{4}$/
+    // YYYY (yearly)
+  ];
+  const periodicFolders = ["daily", "weekly", "monthly", "quarterly", "yearly", "journal", "journals"];
+  const folder = notePath.split("/")[0]?.toLowerCase() || "";
+  return patterns.some((p) => p.test(nameWithoutExt)) || periodicFolders.includes(folder);
+}
+function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb, getConfig) {
   server2.registerTool(
     "graph_analysis",
     {
@@ -9244,7 +9810,7 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb)
       const index = getIndex();
       switch (analysis) {
         case "orphans": {
-          const allOrphans = findOrphanNotes(index, folder);
+          const allOrphans = findOrphanNotes(index, folder).filter((o) => !isPeriodicNote(o.path));
           const orphans = allOrphans.slice(offset, offset + limit);
           return {
             content: [{ type: "text", text: JSON.stringify({
@@ -9287,7 +9853,17 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb)
           };
         }
         case "hubs": {
-          const allHubs = findHubNotes(index, min_links);
+          const excludeTags = new Set(
+            (getConfig?.()?.exclude_analysis_tags ?? []).map((t) => t.toLowerCase())
+          );
+          const allHubs = findHubNotes(index, min_links).filter((h) => {
+            if (excludeTags.size === 0) return true;
+            const note = index.notes.get(h.path);
+            if (!note) return true;
+            const tags = note.frontmatter?.tags;
+            const tagList = Array.isArray(tags) ? tags : typeof tags === "string" ? [tags] : [];
+            return !tagList.some((t) => excludeTags.has(String(t).toLowerCase()));
+          });
           const hubs = allHubs.slice(offset, offset + limit);
           return {
             content: [{ type: "text", text: JSON.stringify({
@@ -9329,14 +9905,14 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb)
         case "immature": {
           const vaultPath2 = getVaultPath();
           const allNotes = Array.from(index.notes.values()).filter(
-            (note) => !folder || note.path.startsWith(folder + "/") || note.path.substring(0, note.path.lastIndexOf("/")) === folder
+            (note) => (!folder || note.path.startsWith(folder + "/") || note.path.substring(0, note.path.lastIndexOf("/")) === folder) && !isPeriodicNote(note.path)
           );
           const conventions = inferFolderConventions(index, folder, 0.5);
           const expectedFields = conventions.inferred_fields.map((f) => f.name);
           const scored = allNotes.map((note) => {
             let wordCount = 0;
             try {
-              const content = fs14.readFileSync(path14.join(vaultPath2, note.path), "utf-8");
+              const content = fs14.readFileSync(path15.join(vaultPath2, note.path), "utf-8");
               const body = content.replace(/^---[\s\S]*?---\n?/, "");
               wordCount = body.split(/\s+/).filter((w) => w.length > 0).length;
             } catch {
@@ -9385,8 +9961,8 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb)
           };
         }
         case "evolution": {
-          const db3 = getStateDb?.();
-          if (!db3) {
+          const db4 = getStateDb?.();
+          if (!db4) {
             return {
               content: [{ type: "text", text: JSON.stringify({
                 error: "StateDb not available \u2014 graph evolution requires persistent state"
@@ -9394,7 +9970,7 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb)
             };
           }
           const daysBack = days ?? 30;
-          const evolutions = getGraphEvolution(db3, daysBack);
+          const evolutions = getGraphEvolution(db4, daysBack);
           return {
             content: [{ type: "text", text: JSON.stringify({
               analysis: "evolution",
@@ -9404,8 +9980,8 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb)
           };
         }
         case "emerging_hubs": {
-          const db3 = getStateDb?.();
-          if (!db3) {
+          const db4 = getStateDb?.();
+          if (!db4) {
             return {
               content: [{ type: "text", text: JSON.stringify({
                 error: "StateDb not available \u2014 emerging hubs requires persistent state"
@@ -9413,7 +9989,23 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath, getStateDb)
             };
           }
           const daysBack = days ?? 30;
-          const hubs = getEmergingHubs(db3, daysBack);
+          let hubs = getEmergingHubs(db4, daysBack);
+          const excludeTags = new Set(
+            (getConfig?.()?.exclude_analysis_tags ?? []).map((t) => t.toLowerCase())
+          );
+          if (excludeTags.size > 0) {
+            const notesByTitle = /* @__PURE__ */ new Map();
+            for (const note of index.notes.values()) {
+              notesByTitle.set(note.title.toLowerCase(), note);
+            }
+            hubs = hubs.filter((hub) => {
+              const note = notesByTitle.get(hub.entity.toLowerCase());
+              if (!note) return true;
+              const tags = note.frontmatter?.tags;
+              const tagList = Array.isArray(tags) ? tags : typeof tags === "string" ? [tags] : [];
+              return !tagList.some((t) => excludeTags.has(String(t).toLowerCase()));
+            });
+          }
           return {
             content: [{ type: "text", text: JSON.stringify({
               analysis: "emerging_hubs",
@@ -9902,13 +10494,12 @@ import { z as z10 } from "zod";
 
 // src/tools/read/bidirectional.ts
 import * as fs15 from "fs/promises";
-import * as path15 from "path";
+import * as path16 from "path";
 import matter3 from "gray-matter";
 var PROSE_PATTERN_REGEX = /^([A-Za-z][A-Za-z0-9 _-]*):\s*(?:\[\[([^\]]+)\]\]|"([^"]+)"|([^\n]+?))\s*$/gm;
 var CODE_BLOCK_REGEX2 = /```[\s\S]*?```|`[^`\n]+`/g;
-var WIKILINK_REGEX2 = /\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|[^\]]+)?\]\]/g;
 async function readFileContent2(notePath, vaultPath2) {
-  const fullPath = path15.join(vaultPath2, notePath);
+  const fullPath = path16.join(vaultPath2, notePath);
   try {
     return await fs15.readFile(fullPath, "utf-8");
   } catch {
@@ -9931,21 +10522,6 @@ function removeCodeBlocks(content) {
     return "\n".repeat(newlines);
   });
 }
-function extractWikilinksFromValue(value) {
-  if (typeof value === "string") {
-    const matches = [];
-    let match;
-    WIKILINK_REGEX2.lastIndex = 0;
-    while ((match = WIKILINK_REGEX2.exec(value)) !== null) {
-      matches.push(match[1].trim());
-    }
-    return matches;
-  }
-  if (Array.isArray(value)) {
-    return value.flatMap((v) => extractWikilinksFromValue(v));
-  }
-  return [];
-}
 function isWikilinkValue(value) {
   return /^\[\[.+\]\]$/.test(value.trim());
 }
@@ -10072,116 +10648,40 @@ async function suggestWikilinksInFrontmatter(index, notePath, vaultPath2) {
   const suggestions = [];
   function checkValue(field, value, arrayIndex) {
     if (typeof value !== "string") return;
-    if (isWikilinkValue(value)) return;
-    if (!value.trim()) return;
-    const normalizedValue = normalizeRef(value);
-    const matchedPath = index.entities.get(normalizedValue);
-    if (matchedPath) {
-      const targetNote = index.notes.get(matchedPath);
-      suggestions.push({
-        field,
-        current_value: value,
-        suggested_link: `[[${targetNote?.title || value}]]`,
-        target_note: matchedPath,
-        array_index: arrayIndex
-      });
-    }
-  }
-  for (const [field, value] of Object.entries(frontmatter)) {
-    if (Array.isArray(value)) {
-      value.forEach((v, i) => checkValue(field, v, i));
-    } else {
-      checkValue(field, value);
-    }
-  }
-  return {
-    path: notePath,
-    suggestions
-  };
-}
-async function validateCrossLayer(index, notePath, vaultPath2) {
-  const content = await readFileContent2(notePath, vaultPath2);
-  if (content === null) {
-    return {
-      path: notePath,
-      frontmatter_only: [],
-      prose_only: [],
-      consistent: [],
-      error: "File not found"
-    };
-  }
-  let frontmatter = {};
-  let body = content;
-  try {
-    const parsed = matter3(content);
-    frontmatter = parsed.data;
-    body = parsed.content;
-  } catch {
-  }
-  const frontmatterRefs = /* @__PURE__ */ new Map();
-  for (const [field, value] of Object.entries(frontmatter)) {
-    const wikilinks = extractWikilinksFromValue(value);
-    for (const target of wikilinks) {
-      frontmatterRefs.set(normalizeRef(target), { field, target });
-    }
-    if (typeof value === "string" && !isWikilinkValue(value)) {
-      const normalized = normalizeRef(value);
-      if (index.entities.has(normalized)) {
-        frontmatterRefs.set(normalized, { field, target: value });
-      }
-    }
-    if (Array.isArray(value)) {
-      for (const v of value) {
-        if (typeof v === "string" && !isWikilinkValue(v)) {
-          const normalized = normalizeRef(v);
-          if (index.entities.has(normalized)) {
-            frontmatterRefs.set(normalized, { field, target: v });
-          }
-        }
-      }
-    }
-  }
-  const proseRefs = /* @__PURE__ */ new Map();
-  const cleanBody = removeCodeBlocks(body);
-  const lines = cleanBody.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    WIKILINK_REGEX2.lastIndex = 0;
-    let match;
-    while ((match = WIKILINK_REGEX2.exec(line)) !== null) {
-      const target = match[1].trim();
-      proseRefs.set(normalizeRef(target), { line: i + 1, target });
+    if (isWikilinkValue(value)) return;
+    if (!value.trim()) return;
+    const normalizedValue = normalizeRef(value);
+    const matchedPath = index.entities.get(normalizedValue);
+    if (matchedPath) {
+      const targetNote = index.notes.get(matchedPath);
+      suggestions.push({
+        field,
+        current_value: value,
+        suggested_link: `[[${targetNote?.title || value}]]`,
+        target_note: matchedPath,
+        array_index: arrayIndex
+      });
     }
   }
-  const frontmatter_only = [];
-  const prose_only = [];
-  const consistent = [];
-  for (const [normalized, { field, target }] of frontmatterRefs) {
-    if (proseRefs.has(normalized)) {
-      consistent.push({ field, target });
+  for (const [field, value] of Object.entries(frontmatter)) {
+    if (Array.isArray(value)) {
+      value.forEach((v, i) => checkValue(field, v, i));
     } else {
-      frontmatter_only.push({ field, target });
-    }
-  }
-  for (const [normalized, { line, target }] of proseRefs) {
-    if (!frontmatterRefs.has(normalized)) {
-      prose_only.push({ pattern: `[[${target}]]`, target, line });
+      checkValue(field, value);
     }
   }
   return {
     path: notePath,
-    frontmatter_only,
-    prose_only,
-    consistent
+    suggestions
   };
 }
 
 // src/tools/read/computed.ts
 import * as fs16 from "fs/promises";
-import * as path16 from "path";
+import * as path17 from "path";
 import matter4 from "gray-matter";
 async function readFileContent3(notePath, vaultPath2) {
-  const fullPath = path16.join(vaultPath2, notePath);
+  const fullPath = path17.join(vaultPath2, notePath);
   try {
     return await fs16.readFile(fullPath, "utf-8");
   } catch {
@@ -10189,7 +10689,7 @@ async function readFileContent3(notePath, vaultPath2) {
   }
 }
 async function getFileStats(notePath, vaultPath2) {
-  const fullPath = path16.join(vaultPath2, notePath);
+  const fullPath = path17.join(vaultPath2, notePath);
   try {
     const stats = await fs16.stat(fullPath);
     return {
@@ -10322,18 +10822,17 @@ async function computeFrontmatter(index, notePath, vaultPath2, fields) {
 // src/tools/read/noteIntelligence.ts
 import fs17 from "node:fs";
 import nodePath from "node:path";
-function registerNoteIntelligenceTools(server2, getIndex, getVaultPath) {
+function registerNoteIntelligenceTools(server2, getIndex, getVaultPath, getConfig) {
   server2.registerTool(
     "note_intelligence",
     {
       title: "Note Intelligence",
-      description: 'Analyze a note for patterns, suggestions, and consistency. Use analysis to pick the mode:\n- "prose_patterns": Find "Key: Value" or "Key: [[wikilink]]" patterns in prose\n- "suggest_frontmatter": Suggest YAML frontmatter from detected prose patterns\n- "suggest_wikilinks": Find frontmatter values that could be wikilinks\n- "cross_layer": Check consistency between frontmatter and prose references\n- "compute": Auto-compute derived fields (word_count, link_count, etc.)\n- "semantic_links": Find semantically related entities not currently linked in the note (requires init_semantic)\n- "all": Run all analyses and return combined result\n\nExample: note_intelligence({ path: "projects/alpha.md", analysis: "wikilinks" })\nExample: note_intelligence({ path: "projects/alpha.md", analysis: "compute", fields: ["word_count", "link_count"] })\nExample: note_intelligence({ path: "projects/alpha.md", analysis: "semantic_links" })',
+      description: 'Analyze a note for patterns, suggestions, and consistency. Use analysis to pick the mode:\n- "prose_patterns": Find "Key: Value" or "Key: [[wikilink]]" patterns in prose\n- "suggest_frontmatter": Suggest YAML frontmatter from detected prose patterns\n- "suggest_wikilinks": Find frontmatter values that could be wikilinks\n- "compute": Auto-compute derived fields (word_count, link_count, etc.)\n- "semantic_links": Find semantically related entities not currently linked in the note (requires init_semantic)\n- "all": Run all analyses and return combined result\n\nExample: note_intelligence({ path: "projects/alpha.md", analysis: "wikilinks" })\nExample: note_intelligence({ path: "projects/alpha.md", analysis: "compute", fields: ["word_count", "link_count"] })\nExample: note_intelligence({ path: "projects/alpha.md", analysis: "semantic_links" })',
       inputSchema: {
         analysis: z10.enum([
           "prose_patterns",
           "suggest_frontmatter",
           "suggest_wikilinks",
-          "cross_layer",
           "compute",
           "semantic_links",
           "all"
@@ -10365,12 +10864,6 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath) {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
           };
         }
-        case "cross_layer": {
-          const result = await validateCrossLayer(index, notePath, vaultPath2);
-          return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-          };
-        }
         case "compute": {
           const result = await computeFrontmatter(index, notePath, vaultPath2, fields);
           return {
@@ -10401,10 +10894,26 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath) {
           while ((wlMatch = wikilinkRegex.exec(noteContent)) !== null) {
             linkedEntities.add(wlMatch[1].toLowerCase());
           }
+          const excludeTags = new Set(
+            (getConfig?.()?.exclude_analysis_tags ?? []).map((t) => t.toLowerCase())
+          );
           try {
             const contentEmbedding = await embedTextCached(noteContent);
             const matches = findSemanticallySimilarEntities(contentEmbedding, 20, linkedEntities);
-            const suggestions = matches.filter((m) => m.similarity >= 0.3).map((m) => ({
+            const suggestions = matches.filter((m) => {
+              if (m.similarity < 0.3) return false;
+              if (excludeTags.size > 0) {
+                const entityNote = index.notes.get(m.entityName.toLowerCase() + ".md") ?? [...index.notes.values()].find((n) => n.title.toLowerCase() === m.entityName.toLowerCase());
+                if (entityNote) {
+                  const noteTags = Object.keys(entityNote.frontmatter).filter((k) => k === "tags").flatMap((k) => {
+                    const v = entityNote.frontmatter[k];
+                    return Array.isArray(v) ? v : typeof v === "string" ? [v] : [];
+                  }).map((t) => String(t).toLowerCase());
+                  if (noteTags.some((t) => excludeTags.has(t))) return false;
+                }
+              }
+              return true;
+            }).map((m) => ({
               entity: m.entityName,
               similarity: m.similarity
             }));
@@ -10426,11 +10935,10 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath) {
           }
         }
         case "all": {
-          const [prosePatterns, suggestedFrontmatter, suggestedWikilinks, crossLayer, computed] = await Promise.all([
+          const [prosePatterns, suggestedFrontmatter, suggestedWikilinks, computed] = await Promise.all([
             detectProsePatterns(index, notePath, vaultPath2),
             suggestFrontmatterFromProse(index, notePath, vaultPath2),
             suggestWikilinksInFrontmatter(index, notePath, vaultPath2),
-            validateCrossLayer(index, notePath, vaultPath2),
             computeFrontmatter(index, notePath, vaultPath2, fields)
           ]);
           return {
@@ -10439,7 +10947,6 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath) {
               prose_patterns: prosePatterns,
               suggested_frontmatter: suggestedFrontmatter,
               suggested_wikilinks: suggestedWikilinks,
-              cross_layer: crossLayer,
               computed
             }, null, 2) }]
           };
@@ -10453,7 +10960,7 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath) {
 init_writer();
 import { z as z11 } from "zod";
 import fs20 from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 
 // src/core/write/validator.ts
 var TIMESTAMP_PATTERN = /^\*\*\d{2}:\d{2}\*\*/;
@@ -10656,7 +11163,7 @@ function runValidationPipeline(content, format, options = {}) {
 // src/core/write/mutation-helpers.ts
 init_writer();
 import fs19 from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 init_constants();
 init_writer();
 function formatMcpResult(result) {
@@ -10705,7 +11212,7 @@ async function handleGitCommit(vaultPath2, notePath, commit, prefix) {
   return info;
 }
 async function ensureFileExists(vaultPath2, notePath) {
-  const fullPath = path18.join(vaultPath2, notePath);
+  const fullPath = path19.join(vaultPath2, notePath);
   try {
     await fs19.access(fullPath);
     return null;
@@ -10735,41 +11242,58 @@ async function withVaultFile(options, operation) {
     if (existsError) {
       return formatMcpResult(existsError);
     }
-    const { content, frontmatter, lineEnding } = await readVaultFile(vaultPath2, notePath);
-    const writeStateDb = getWriteStateDb();
-    if (writeStateDb) {
-      processImplicitFeedback(writeStateDb, notePath, content);
+    const runMutation = async () => {
+      const { content, frontmatter: frontmatter2, lineEnding: lineEnding2, mtimeMs } = await readVaultFile(vaultPath2, notePath);
+      const writeStateDb = getWriteStateDb();
+      if (writeStateDb) {
+        processImplicitFeedback(writeStateDb, notePath, content);
+      }
+      let sectionBoundary;
+      if (section) {
+        const sectionResult = ensureSectionExists(content, section, notePath);
+        if ("error" in sectionResult) {
+          return { error: sectionResult.error };
+        }
+        sectionBoundary = sectionResult.boundary;
+      }
+      const ctx = {
+        content,
+        frontmatter: frontmatter2,
+        lineEnding: lineEnding2,
+        sectionBoundary,
+        vaultPath: vaultPath2,
+        notePath
+      };
+      const opResult2 = await operation(ctx);
+      return { opResult: opResult2, frontmatter: frontmatter2, lineEnding: lineEnding2, mtimeMs };
+    };
+    let result = await runMutation();
+    if ("error" in result) {
+      return formatMcpResult(result.error);
     }
-    let sectionBoundary;
-    if (section) {
-      const sectionResult = ensureSectionExists(content, section, notePath);
-      if ("error" in sectionResult) {
-        return formatMcpResult(sectionResult.error);
+    const fullPath = path19.join(vaultPath2, notePath);
+    const statBefore = await fs19.stat(fullPath);
+    if (statBefore.mtimeMs !== result.mtimeMs) {
+      console.warn(`[withVaultFile] External modification detected on ${notePath}, re-reading and retrying`);
+      result = await runMutation();
+      if ("error" in result) {
+        return formatMcpResult(result.error);
       }
-      sectionBoundary = sectionResult.boundary;
     }
-    const ctx = {
-      content,
-      frontmatter,
-      lineEnding,
-      sectionBoundary,
-      vaultPath: vaultPath2,
-      notePath
-    };
-    const opResult = await operation(ctx);
+    const { opResult, frontmatter, lineEnding } = result;
     let finalFrontmatter = opResult.updatedFrontmatter ?? frontmatter;
     if (scoping && (scoping.agent_id || scoping.session_id)) {
       finalFrontmatter = injectMutationMetadata(finalFrontmatter, scoping);
     }
     await writeVaultFile(vaultPath2, notePath, opResult.updatedContent, finalFrontmatter, lineEnding);
     const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, commitPrefix);
-    const result = successResult(notePath, opResult.message, gitInfo, {
+    const successRes = successResult(notePath, opResult.message, gitInfo, {
       preview: opResult.preview,
       warnings: opResult.warnings,
       outputIssues: opResult.outputIssues,
       normalizationChanges: opResult.normalizationChanges
     });
-    return formatMcpResult(result);
+    return formatMcpResult(successRes);
   } catch (error) {
     const extras = {};
     if (error instanceof DiagnosticError) {
@@ -10810,10 +11334,10 @@ async function withVaultFrontmatter(options, operation) {
 
 // src/tools/write/mutations.ts
 async function createNoteFromTemplate(vaultPath2, notePath, config) {
-  const fullPath = path19.join(vaultPath2, notePath);
-  await fs20.mkdir(path19.dirname(fullPath), { recursive: true });
+  const fullPath = path20.join(vaultPath2, notePath);
+  await fs20.mkdir(path20.dirname(fullPath), { recursive: true });
   const templates = config.templates || {};
-  const filename = path19.basename(notePath, ".md").toLowerCase();
+  const filename = path20.basename(notePath, ".md").toLowerCase();
   let templatePath;
   const dailyPattern = /^\d{4}-\d{2}-\d{2}/;
   const weeklyPattern = /^\d{4}-W\d{2}/;
@@ -10834,10 +11358,10 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   let templateContent;
   if (templatePath) {
     try {
-      const absTemplatePath = path19.join(vaultPath2, templatePath);
+      const absTemplatePath = path20.join(vaultPath2, templatePath);
       templateContent = await fs20.readFile(absTemplatePath, "utf-8");
     } catch {
-      const title = path19.basename(notePath, ".md");
+      const title = path20.basename(notePath, ".md");
       templateContent = `---
 ---
 
@@ -10846,7 +11370,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
       templatePath = void 0;
     }
   } else {
-    const title = path19.basename(notePath, ".md");
+    const title = path20.basename(notePath, ".md");
     templateContent = `---
 ---
 
@@ -10855,7 +11379,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   }
   const now = /* @__PURE__ */ new Date();
   const dateStr = now.toISOString().split("T")[0];
-  templateContent = templateContent.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, path19.basename(notePath, ".md"));
+  templateContent = templateContent.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, path20.basename(notePath, ".md"));
   const matter9 = (await import("gray-matter")).default;
   const parsed = matter9(templateContent);
   if (!parsed.data.date) {
@@ -10894,7 +11418,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
       let noteCreated = false;
       let templateUsed;
       if (create_if_missing) {
-        const fullPath = path19.join(vaultPath2, notePath);
+        const fullPath = path20.join(vaultPath2, notePath);
         try {
           await fs20.access(fullPath);
         } catch {
@@ -11191,6 +11715,8 @@ function registerTaskTools(server2, vaultPath2) {
           finalFrontmatter = injectMutationMetadata(frontmatter, { agent_id, session_id });
         }
         await writeVaultFile(vaultPath2, notePath, toggleResult.content, finalFrontmatter);
+        await updateTaskCacheForFile(vaultPath2, notePath).catch(() => {
+        });
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Flywheel:Task]");
         const newStatus = toggleResult.newState ? "completed" : "incomplete";
         const checkbox = toggleResult.newState ? "[x]" : "[ ]";
@@ -11345,7 +11871,7 @@ Example: vault_update_frontmatter({ path: "projects/alpha.md", frontmatter: { st
 init_writer();
 import { z as z14 } from "zod";
 import fs21 from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 function registerNoteTools(server2, vaultPath2, getIndex) {
   server2.tool(
     "vault_create_note",
@@ -11368,23 +11894,23 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
         if (!validatePath(vaultPath2, notePath)) {
           return formatMcpResult(errorResult(notePath, "Invalid path: path traversal not allowed"));
         }
-        const fullPath = path20.join(vaultPath2, notePath);
+        const fullPath = path21.join(vaultPath2, notePath);
         const existsCheck = await ensureFileExists(vaultPath2, notePath);
         if (existsCheck === null && !overwrite) {
           return formatMcpResult(errorResult(notePath, `File already exists: ${notePath}. Use overwrite=true to replace.`));
         }
-        const dir = path20.dirname(fullPath);
+        const dir = path21.dirname(fullPath);
         await fs21.mkdir(dir, { recursive: true });
         let effectiveContent = content;
         let effectiveFrontmatter = frontmatter;
         if (template) {
-          const templatePath = path20.join(vaultPath2, template);
+          const templatePath = path21.join(vaultPath2, template);
           try {
             const raw = await fs21.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 = path20.basename(notePath, ".md");
+            const title = path21.basename(notePath, ".md");
             let templateContent = parsed.content.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, title);
             if (content) {
               templateContent = templateContent.trimEnd() + "\n\n" + content;
@@ -11399,7 +11925,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
           effectiveFrontmatter.date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
         }
         const warnings = [];
-        const noteName = path20.basename(notePath, ".md");
+        const noteName = path21.basename(notePath, ".md");
         const existingAliases = Array.isArray(effectiveFrontmatter?.aliases) ? effectiveFrontmatter.aliases.filter((a) => typeof a === "string") : [];
         const preflight = await checkPreflightSimilarity(noteName);
         if (preflight.existingEntity) {
@@ -11516,7 +12042,7 @@ ${sources}`;
           }
           return formatMcpResult(errorResult(notePath, previewLines.join("\n")));
         }
-        const fullPath = path20.join(vaultPath2, notePath);
+        const fullPath = path21.join(vaultPath2, notePath);
         await fs21.unlink(fullPath);
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Flywheel:Delete]");
         const message = backlinkWarning ? `Deleted note: ${notePath}
@@ -11536,7 +12062,7 @@ Warning: ${backlinkWarning}` : `Deleted note: ${notePath}`;
 init_writer();
 import { z as z15 } from "zod";
 import fs22 from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 import matter6 from "gray-matter";
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -11555,7 +12081,7 @@ function extractWikilinks2(content) {
   return wikilinks;
 }
 function getTitleFromPath(filePath) {
-  return path21.basename(filePath, ".md");
+  return path22.basename(filePath, ".md");
 }
 async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   const results = [];
@@ -11564,7 +12090,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
     const files = [];
     const entries = await fs22.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path21.join(dir, entry.name);
+      const fullPath = path22.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         files.push(...await scanDir(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -11575,7 +12101,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   }
   const allFiles = await scanDir(vaultPath2);
   for (const filePath of allFiles) {
-    const relativePath = path21.relative(vaultPath2, filePath);
+    const relativePath = path22.relative(vaultPath2, filePath);
     const content = await fs22.readFile(filePath, "utf-8");
     const wikilinks = extractWikilinks2(content);
     const matchingLinks = [];
@@ -11595,7 +12121,7 @@ async function findBacklinks(vaultPath2, targetTitle, targetAliases) {
   return results;
 }
 async function updateBacklinksInFile(vaultPath2, filePath, oldTitles, newTitle) {
-  const fullPath = path21.join(vaultPath2, filePath);
+  const fullPath = path22.join(vaultPath2, filePath);
   const raw = await fs22.readFile(fullPath, "utf-8");
   const parsed = matter6(raw);
   let content = parsed.content;
@@ -11662,8 +12188,8 @@ function registerMoveNoteTools(server2, vaultPath2) {
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        const oldFullPath = path21.join(vaultPath2, oldPath);
-        const newFullPath = path21.join(vaultPath2, newPath);
+        const oldFullPath = path22.join(vaultPath2, oldPath);
+        const newFullPath = path22.join(vaultPath2, newPath);
         try {
           await fs22.access(oldFullPath);
         } catch {
@@ -11713,7 +12239,7 @@ function registerMoveNoteTools(server2, vaultPath2) {
             }
           }
         }
-        const destDir = path21.dirname(newFullPath);
+        const destDir = path22.dirname(newFullPath);
         await fs22.mkdir(destDir, { recursive: true });
         await fs22.rename(oldFullPath, newFullPath);
         let gitCommit;
@@ -11799,10 +12325,10 @@ function registerMoveNoteTools(server2, vaultPath2) {
         if (sanitizedTitle !== newTitle) {
           console.error(`[Flywheel] Title sanitized: "${newTitle}" \u2192 "${sanitizedTitle}"`);
         }
-        const fullPath = path21.join(vaultPath2, notePath);
-        const dir = path21.dirname(notePath);
-        const newPath = dir === "." ? `${sanitizedTitle}.md` : path21.join(dir, `${sanitizedTitle}.md`);
-        const newFullPath = path21.join(vaultPath2, newPath);
+        const fullPath = path22.join(vaultPath2, notePath);
+        const dir = path22.dirname(notePath);
+        const newPath = dir === "." ? `${sanitizedTitle}.md` : path22.join(dir, `${sanitizedTitle}.md`);
+        const newFullPath = path22.join(vaultPath2, newPath);
         try {
           await fs22.access(fullPath);
         } catch {
@@ -11910,15 +12436,146 @@ function registerMoveNoteTools(server2, vaultPath2) {
   );
 }
 
-// src/tools/write/system.ts
+// src/tools/write/merge.ts
+init_writer();
 import { z as z16 } from "zod";
+import fs23 from "fs/promises";
+function registerMergeTools(server2, vaultPath2) {
+  server2.tool(
+    "merge_entities",
+    "Merge a source entity note into a target entity note: adds alias, appends content, updates wikilinks, deletes source",
+    {
+      source_path: z16.string().describe("Vault-relative path of the note to merge FROM (will be deleted)"),
+      target_path: z16.string().describe("Vault-relative path of the note to merge INTO (receives alias + content)")
+    },
+    async ({ source_path, target_path }) => {
+      try {
+        if (!validatePath(vaultPath2, source_path)) {
+          const result2 = {
+            success: false,
+            message: "Invalid source path: path traversal not allowed",
+            path: source_path
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        if (!validatePath(vaultPath2, target_path)) {
+          const result2 = {
+            success: false,
+            message: "Invalid target path: path traversal not allowed",
+            path: target_path
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        let sourceContent;
+        let sourceFrontmatter;
+        try {
+          const source = await readVaultFile(vaultPath2, source_path);
+          sourceContent = source.content;
+          sourceFrontmatter = source.frontmatter;
+        } catch {
+          const result2 = {
+            success: false,
+            message: `Source file not found: ${source_path}`,
+            path: source_path
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        let targetContent;
+        let targetFrontmatter;
+        try {
+          const target = await readVaultFile(vaultPath2, target_path);
+          targetContent = target.content;
+          targetFrontmatter = target.frontmatter;
+        } catch {
+          const result2 = {
+            success: false,
+            message: `Target file not found: ${target_path}`,
+            path: target_path
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const sourceTitle = getTitleFromPath(source_path);
+        const targetTitle = getTitleFromPath(target_path);
+        const existingAliases = extractAliases2(targetFrontmatter);
+        const sourceAliases = extractAliases2(sourceFrontmatter);
+        const allNewAliases = [sourceTitle, ...sourceAliases];
+        const deduped = /* @__PURE__ */ new Set([...existingAliases]);
+        for (const alias of allNewAliases) {
+          if (alias.toLowerCase() !== targetTitle.toLowerCase()) {
+            deduped.add(alias);
+          }
+        }
+        targetFrontmatter.aliases = Array.from(deduped);
+        const trimmedSource = sourceContent.trim();
+        if (trimmedSource.length > 10) {
+          const mergedSection = `
+
+## Merged from ${sourceTitle}
+
+${trimmedSource}`;
+          targetContent = targetContent.trimEnd() + mergedSection;
+        }
+        const allSourceTitles = [sourceTitle, ...sourceAliases];
+        const backlinks = await findBacklinks(vaultPath2, sourceTitle, sourceAliases);
+        let totalBacklinksUpdated = 0;
+        const modifiedFiles = [];
+        for (const backlink of backlinks) {
+          if (backlink.path === source_path || backlink.path === target_path) continue;
+          const updateResult = await updateBacklinksInFile(
+            vaultPath2,
+            backlink.path,
+            allSourceTitles,
+            targetTitle
+          );
+          if (updateResult.updated) {
+            totalBacklinksUpdated += updateResult.linksUpdated;
+            modifiedFiles.push(backlink.path);
+          }
+        }
+        await writeVaultFile(vaultPath2, target_path, targetContent, targetFrontmatter);
+        const fullSourcePath = `${vaultPath2}/${source_path}`;
+        await fs23.unlink(fullSourcePath);
+        initializeEntityIndex(vaultPath2).catch((err) => {
+          console.error(`[Flywheel] Entity cache rebuild failed: ${err}`);
+        });
+        const previewLines = [
+          `Merged: "${sourceTitle}" \u2192 "${targetTitle}"`,
+          `Aliases added: ${allNewAliases.join(", ")}`,
+          `Source content appended: ${trimmedSource.length > 10 ? "yes" : "no"}`,
+          `Backlinks updated: ${totalBacklinksUpdated}`
+        ];
+        if (modifiedFiles.length > 0) {
+          previewLines.push(`Files modified: ${modifiedFiles.join(", ")}`);
+        }
+        const result = {
+          success: true,
+          message: `Merged "${sourceTitle}" into "${targetTitle}"`,
+          path: target_path,
+          preview: previewLines.join("\n"),
+          backlinks_updated: totalBacklinksUpdated
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        const result = {
+          success: false,
+          message: `Failed to merge entities: ${error instanceof Error ? error.message : String(error)}`,
+          path: source_path
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    }
+  );
+}
+
+// src/tools/write/system.ts
+import { z as z17 } from "zod";
 function registerSystemTools2(server2, vaultPath2) {
   server2.tool(
     "vault_undo_last_mutation",
     "Undo the last git commit (typically the last Flywheel mutation). Performs a soft reset.",
     {
-      confirm: z16.boolean().default(false).describe("Must be true to confirm undo operation"),
-      hash: z16.string().optional().describe("Expected commit hash. If provided, undo only proceeds if HEAD matches this hash. Prevents accidentally undoing the wrong commit.")
+      confirm: z17.boolean().default(false).describe("Must be true to confirm undo operation"),
+      hash: z17.string().optional().describe("Expected commit hash. If provided, undo only proceeds if HEAD matches this hash. Prevents accidentally undoing the wrong commit.")
     },
     async ({ confirm, hash }) => {
       try {
@@ -12019,7 +12676,7 @@ Message: ${undoResult.undoneCommit.message}` : void 0
 }
 
 // src/tools/write/policy.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/core/write/policy/index.ts
 init_template();
@@ -12027,8 +12684,8 @@ init_schema();
 
 // src/core/write/policy/parser.ts
 init_schema();
-import fs23 from "fs/promises";
-import path22 from "path";
+import fs24 from "fs/promises";
+import path23 from "path";
 import matter7 from "gray-matter";
 function parseYaml(content) {
   const parsed = matter7(`---
@@ -12053,7 +12710,7 @@ function parsePolicyString(yamlContent) {
 }
 async function loadPolicyFile(filePath) {
   try {
-    const content = await fs23.readFile(filePath, "utf-8");
+    const content = await fs24.readFile(filePath, "utf-8");
     return parsePolicyString(content);
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -12077,15 +12734,15 @@ async function loadPolicyFile(filePath) {
   }
 }
 async function loadPolicy(vaultPath2, policyName) {
-  const policiesDir = path22.join(vaultPath2, ".claude", "policies");
-  const policyPath = path22.join(policiesDir, `${policyName}.yaml`);
+  const policiesDir = path23.join(vaultPath2, ".claude", "policies");
+  const policyPath = path23.join(policiesDir, `${policyName}.yaml`);
   try {
-    await fs23.access(policyPath);
+    await fs24.access(policyPath);
     return loadPolicyFile(policyPath);
   } catch {
-    const ymlPath = path22.join(policiesDir, `${policyName}.yml`);
+    const ymlPath = path23.join(policiesDir, `${policyName}.yml`);
     try {
-      await fs23.access(ymlPath);
+      await fs24.access(ymlPath);
       return loadPolicyFile(ymlPath);
     } catch {
       return {
@@ -12223,8 +12880,8 @@ init_template();
 init_conditions();
 init_schema();
 init_writer();
-import fs25 from "fs/promises";
-import path24 from "path";
+import fs26 from "fs/promises";
+import path25 from "path";
 init_constants();
 async function executeStep(step, vaultPath2, context, conditionResults) {
   const { execute, reason } = shouldStepExecute(step.when, conditionResults);
@@ -12293,9 +12950,9 @@ async function executeAddToSection(params, vaultPath2, context) {
   const preserveListNesting = params.preserveListNesting !== false;
   const suggestOutgoingLinks = params.suggestOutgoingLinks !== false;
   const maxSuggestions = Number(params.maxSuggestions) || 3;
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
-    await fs25.access(fullPath);
+    await fs26.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -12333,9 +12990,9 @@ async function executeRemoveFromSection(params, vaultPath2) {
   const pattern = String(params.pattern || "");
   const mode = params.mode || "first";
   const useRegex = Boolean(params.useRegex);
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
-    await fs25.access(fullPath);
+    await fs26.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -12364,9 +13021,9 @@ async function executeReplaceInSection(params, vaultPath2, context) {
   const mode = params.mode || "first";
   const useRegex = Boolean(params.useRegex);
   const skipWikilinks = Boolean(params.skipWikilinks);
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
-    await fs25.access(fullPath);
+    await fs26.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -12407,16 +13064,16 @@ async function executeCreateNote(params, vaultPath2, context) {
   if (!validatePath(vaultPath2, notePath)) {
     return { success: false, message: "Invalid path: path traversal not allowed", path: notePath };
   }
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
-    await fs25.access(fullPath);
+    await fs26.access(fullPath);
     if (!overwrite) {
       return { success: false, message: `File already exists: ${notePath}`, path: notePath };
     }
   } catch {
   }
-  const dir = path24.dirname(fullPath);
-  await fs25.mkdir(dir, { recursive: true });
+  const dir = path25.dirname(fullPath);
+  await fs26.mkdir(dir, { recursive: true });
   const { content: processedContent } = maybeApplyWikilinks(content, skipWikilinks, notePath);
   await writeVaultFile(vaultPath2, notePath, processedContent, frontmatter);
   return {
@@ -12435,13 +13092,13 @@ async function executeDeleteNote(params, vaultPath2) {
   if (!validatePath(vaultPath2, notePath)) {
     return { success: false, message: "Invalid path: path traversal not allowed", path: notePath };
   }
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
-    await fs25.access(fullPath);
+    await fs26.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
-  await fs25.unlink(fullPath);
+  await fs26.unlink(fullPath);
   return {
     success: true,
     message: `Deleted note: ${notePath}`,
@@ -12452,9 +13109,9 @@ async function executeToggleTask(params, vaultPath2) {
   const notePath = String(params.path || "");
   const task = String(params.task || "");
   const section = params.section ? String(params.section) : void 0;
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
-    await fs25.access(fullPath);
+    await fs26.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -12495,9 +13152,9 @@ async function executeAddTask(params, vaultPath2, context) {
   const completed = Boolean(params.completed);
   const skipWikilinks = Boolean(params.skipWikilinks);
   const preserveListNesting = params.preserveListNesting !== false;
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
-    await fs25.access(fullPath);
+    await fs26.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -12532,9 +13189,9 @@ async function executeAddTask(params, vaultPath2, context) {
 async function executeUpdateFrontmatter(params, vaultPath2) {
   const notePath = String(params.path || "");
   const updates = params.frontmatter || {};
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
-    await fs25.access(fullPath);
+    await fs26.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -12554,9 +13211,9 @@ async function executeAddFrontmatterField(params, vaultPath2) {
   const notePath = String(params.path || "");
   const key = String(params.key || "");
   const value = params.value;
-  const fullPath = path24.join(vaultPath2, notePath);
+  const fullPath = path25.join(vaultPath2, notePath);
   try {
-    await fs25.access(fullPath);
+    await fs26.access(fullPath);
   } catch {
     return { success: false, message: `File not found: ${notePath}`, path: notePath };
   }
@@ -12714,15 +13371,15 @@ async function executePolicy(policy, vaultPath2, variables, commit = false) {
 async function rollbackChanges(vaultPath2, originalContents, filesModified) {
   for (const filePath of filesModified) {
     const original = originalContents.get(filePath);
-    const fullPath = path24.join(vaultPath2, filePath);
+    const fullPath = path25.join(vaultPath2, filePath);
     if (original === null) {
       try {
-        await fs25.unlink(fullPath);
+        await fs26.unlink(fullPath);
       } catch {
       }
     } else if (original !== void 0) {
       try {
-        await fs25.writeFile(fullPath, original);
+        await fs26.writeFile(fullPath, original);
       } catch {
       }
     }
@@ -12768,27 +13425,27 @@ async function previewPolicy(policy, vaultPath2, variables) {
 }
 
 // src/core/write/policy/storage.ts
-import fs26 from "fs/promises";
-import path25 from "path";
+import fs27 from "fs/promises";
+import path26 from "path";
 function getPoliciesDir(vaultPath2) {
-  return path25.join(vaultPath2, ".claude", "policies");
+  return path26.join(vaultPath2, ".claude", "policies");
 }
 async function ensurePoliciesDir(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
-  await fs26.mkdir(dir, { recursive: true });
+  await fs27.mkdir(dir, { recursive: true });
 }
 async function listPolicies(vaultPath2) {
   const dir = getPoliciesDir(vaultPath2);
   const policies = [];
   try {
-    const files = await fs26.readdir(dir);
+    const files = await fs27.readdir(dir);
     for (const file of files) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
         continue;
       }
-      const filePath = path25.join(dir, file);
-      const stat3 = await fs26.stat(filePath);
-      const content = await fs26.readFile(filePath, "utf-8");
+      const filePath = path26.join(dir, file);
+      const stat3 = await fs27.stat(filePath);
+      const content = await fs27.readFile(filePath, "utf-8");
       const metadata = extractPolicyMetadata(content);
       policies.push({
         name: metadata.name || file.replace(/\.ya?ml$/, ""),
@@ -12811,10 +13468,10 @@ async function writePolicyRaw(vaultPath2, policyName, content, overwrite = false
   const dir = getPoliciesDir(vaultPath2);
   await ensurePoliciesDir(vaultPath2);
   const filename = `${policyName}.yaml`;
-  const filePath = path25.join(dir, filename);
+  const filePath = path26.join(dir, filename);
   if (!overwrite) {
     try {
-      await fs26.access(filePath);
+      await fs27.access(filePath);
       return {
         success: false,
         path: filename,
@@ -12831,7 +13488,7 @@ async function writePolicyRaw(vaultPath2, policyName, content, overwrite = false
       message: `Invalid policy: ${validation.errors.map((e) => e.message).join("; ")}`
     };
   }
-  await fs26.writeFile(filePath, content, "utf-8");
+  await fs27.writeFile(filePath, content, "utf-8");
   return {
     success: true,
     path: filename,
@@ -12846,71 +13503,71 @@ function registerPolicyTools(server2, vaultPath2) {
     "policy",
     'Manage vault policies. Actions: "list" (list all policies), "validate" (validate YAML), "preview" (dry-run), "execute" (run policy), "author" (generate policy YAML), "revise" (modify existing policy).',
     {
-      action: z18.enum(["list", "validate", "preview", "execute", "author", "revise"]).describe("Action to perform"),
+      action: z19.enum(["list", "validate", "preview", "execute", "author", "revise"]).describe("Action to perform"),
       // validate
-      yaml: z18.string().optional().describe('Policy YAML content (required for "validate")'),
+      yaml: z19.string().optional().describe('Policy YAML content (required for "validate")'),
       // preview, execute, revise
-      policy: z18.string().optional().describe('Policy name or full YAML content (required for "preview", "execute", "revise")'),
+      policy: z19.string().optional().describe('Policy name or full YAML content (required for "preview", "execute", "revise")'),
       // preview, execute
-      variables: z18.record(z18.unknown()).optional().describe('Variables to pass to the policy (for "preview", "execute")'),
+      variables: z19.record(z19.unknown()).optional().describe('Variables to pass to the policy (for "preview", "execute")'),
       // execute
-      commit: z18.boolean().optional().describe('If true, commit all changes with single atomic commit (for "execute")'),
+      commit: z19.boolean().optional().describe('If true, commit all changes with single atomic commit (for "execute")'),
       // author
-      name: z18.string().optional().describe('Name for the policy (required for "author")'),
-      description: z18.string().optional().describe('Description of what the policy should do (required for "author")'),
-      steps: z18.array(z18.object({
-        tool: z18.string().describe("Tool to call (e.g., vault_add_to_section)"),
-        description: z18.string().describe("What this step does"),
-        params: z18.record(z18.unknown()).describe("Parameters for the tool")
+      name: z19.string().optional().describe('Name for the policy (required for "author")'),
+      description: z19.string().optional().describe('Description of what the policy should do (required for "author")'),
+      steps: z19.array(z19.object({
+        tool: z19.string().describe("Tool to call (e.g., vault_add_to_section)"),
+        description: z19.string().describe("What this step does"),
+        params: z19.record(z19.unknown()).describe("Parameters for the tool")
       })).optional().describe('Steps the policy should perform (required for "author")'),
-      authorVariables: z18.array(z18.object({
-        name: z18.string().describe("Variable name"),
-        type: z18.enum(["string", "number", "boolean", "array", "enum"]).describe("Variable type"),
-        required: z18.boolean().default(true).describe("Whether variable is required"),
-        default: z18.unknown().optional().describe("Default value"),
-        enum: z18.array(z18.string()).optional().describe("Allowed values for enum type"),
-        description: z18.string().optional().describe("Variable description")
+      authorVariables: z19.array(z19.object({
+        name: z19.string().describe("Variable name"),
+        type: z19.enum(["string", "number", "boolean", "array", "enum"]).describe("Variable type"),
+        required: z19.boolean().default(true).describe("Whether variable is required"),
+        default: z19.unknown().optional().describe("Default value"),
+        enum: z19.array(z19.string()).optional().describe("Allowed values for enum type"),
+        description: z19.string().optional().describe("Variable description")
       })).optional().describe('Variables the policy accepts (for "author")'),
-      conditions: z18.array(z18.object({
-        id: z18.string().describe("Condition ID"),
-        check: z18.string().describe("Condition type (file_exists, section_exists, etc.)"),
-        path: z18.string().optional().describe("File path"),
-        section: z18.string().optional().describe("Section name"),
-        field: z18.string().optional().describe("Frontmatter field"),
-        value: z18.unknown().optional().describe("Expected value")
+      conditions: z19.array(z19.object({
+        id: z19.string().describe("Condition ID"),
+        check: z19.string().describe("Condition type (file_exists, section_exists, etc.)"),
+        path: z19.string().optional().describe("File path"),
+        section: z19.string().optional().describe("Section name"),
+        field: z19.string().optional().describe("Frontmatter field"),
+        value: z19.unknown().optional().describe("Expected value")
       })).optional().describe('Conditions for conditional execution (for "author")'),
       // author, revise
-      save: z18.boolean().optional().describe('If true, save to .claude/policies/ (for "author", "revise")'),
+      save: z19.boolean().optional().describe('If true, save to .claude/policies/ (for "author", "revise")'),
       // revise
-      changes: z18.object({
-        description: z18.string().optional().describe("New description"),
-        addVariables: z18.array(z18.object({
-          name: z18.string(),
-          type: z18.enum(["string", "number", "boolean", "array", "enum"]),
-          required: z18.boolean().default(true),
-          default: z18.unknown().optional(),
-          enum: z18.array(z18.string()).optional(),
-          description: z18.string().optional()
+      changes: z19.object({
+        description: z19.string().optional().describe("New description"),
+        addVariables: z19.array(z19.object({
+          name: z19.string(),
+          type: z19.enum(["string", "number", "boolean", "array", "enum"]),
+          required: z19.boolean().default(true),
+          default: z19.unknown().optional(),
+          enum: z19.array(z19.string()).optional(),
+          description: z19.string().optional()
         })).optional().describe("Variables to add"),
-        removeVariables: z18.array(z18.string()).optional().describe("Variable names to remove"),
-        addSteps: z18.array(z18.object({
-          id: z18.string(),
-          tool: z18.string(),
-          params: z18.record(z18.unknown()),
-          when: z18.string().optional(),
-          description: z18.string().optional(),
-          afterStep: z18.string().optional().describe("Insert after this step ID")
+        removeVariables: z19.array(z19.string()).optional().describe("Variable names to remove"),
+        addSteps: z19.array(z19.object({
+          id: z19.string(),
+          tool: z19.string(),
+          params: z19.record(z19.unknown()),
+          when: z19.string().optional(),
+          description: z19.string().optional(),
+          afterStep: z19.string().optional().describe("Insert after this step ID")
         })).optional().describe("Steps to add"),
-        removeSteps: z18.array(z18.string()).optional().describe("Step IDs to remove"),
-        addConditions: z18.array(z18.object({
-          id: z18.string(),
-          check: z18.string(),
-          path: z18.string().optional(),
-          section: z18.string().optional(),
-          field: z18.string().optional(),
-          value: z18.unknown().optional()
+        removeSteps: z19.array(z19.string()).optional().describe("Step IDs to remove"),
+        addConditions: z19.array(z19.object({
+          id: z19.string(),
+          check: z19.string(),
+          path: z19.string().optional(),
+          section: z19.string().optional(),
+          field: z19.string().optional(),
+          value: z19.unknown().optional()
         })).optional().describe("Conditions to add"),
-        removeConditions: z18.array(z18.string()).optional().describe("Condition IDs to remove")
+        removeConditions: z19.array(z19.string()).optional().describe("Condition IDs to remove")
       }).optional().describe('Changes to make (required for "revise")')
     },
     async (params) => {
@@ -13351,11 +14008,11 @@ function registerPolicyTools(server2, vaultPath2) {
 }
 
 // src/tools/write/tags.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/core/write/tagRename.ts
-import * as fs27 from "fs/promises";
-import * as path26 from "path";
+import * as fs28 from "fs/promises";
+import * as path27 from "path";
 import matter8 from "gray-matter";
 import { getProtectedZones } from "@velvetmonkey/vault-core";
 function getNotesInFolder3(index, folder) {
@@ -13461,10 +14118,10 @@ async function renameTag(index, vaultPath2, oldTag, newTag, options) {
   const previews = [];
   let totalChanges = 0;
   for (const note of affectedNotes) {
-    const fullPath = path26.join(vaultPath2, note.path);
+    const fullPath = path27.join(vaultPath2, note.path);
     let fileContent;
     try {
-      fileContent = await fs27.readFile(fullPath, "utf-8");
+      fileContent = await fs28.readFile(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -13537,7 +14194,7 @@ async function renameTag(index, vaultPath2, oldTag, newTag, options) {
       previews.push(preview);
       if (!dryRun) {
         const newContent = matter8.stringify(updatedContent, fm);
-        await fs27.writeFile(fullPath, newContent, "utf-8");
+        await fs28.writeFile(fullPath, newContent, "utf-8");
       }
     }
   }
@@ -13560,12 +14217,12 @@ function registerTagTools(server2, getIndex, getVaultPath) {
       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)")
+        old_tag: z20.string().describe('Tag to rename (without #, e.g., "project")'),
+        new_tag: z20.string().describe('New tag name (without #, e.g., "work")'),
+        rename_children: z20.boolean().optional().describe("Also rename child tags (e.g., #project/active \u2192 #work/active). Default: true"),
+        folder: z20.string().optional().describe('Limit to notes in this folder (e.g., "projects")'),
+        dry_run: z20.boolean().optional().describe("Preview only, no changes (default: true)"),
+        commit: z20.boolean().optional().describe("Commit changes to git (default: false)")
       }
     },
     async ({ old_tag, new_tag, rename_children, folder, dry_run, commit }) => {
@@ -13590,20 +14247,20 @@ function registerTagTools(server2, getIndex, getVaultPath) {
 }
 
 // src/tools/write/wikilinkFeedback.ts
-import { z as z20 } from "zod";
+import { z as z21 } 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.',
+      description: 'Report and query wikilink accuracy feedback. Modes: "report" (record feedback), "list" (view recent feedback), "stats" (entity accuracy statistics), "dashboard" (full feedback loop data for visualization). 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)")
+        mode: z21.enum(["report", "list", "stats", "dashboard"]).describe("Operation mode"),
+        entity: z21.string().optional().describe("Entity name (required for report mode, optional filter for list/stats)"),
+        note_path: z21.string().optional().describe("Note path where the wikilink appeared (for report mode)"),
+        context: z21.string().optional().describe("Surrounding text context (for report mode)"),
+        correct: z21.boolean().optional().describe("Whether the wikilink was correct (for report mode)"),
+        limit: z21.number().optional().describe("Max entries to return for list mode (default: 20)")
       }
     },
     async ({ mode, entity, note_path, context, correct, limit }) => {
@@ -13653,6 +14310,16 @@ function registerWikilinkFeedbackTools(server2, getStateDb) {
           };
           break;
         }
+        case "dashboard": {
+          const dashboard = getDashboardData(stateDb2);
+          result = {
+            mode: "dashboard",
+            dashboard,
+            total_feedback: dashboard.total_feedback,
+            total_suppressed: dashboard.total_suppressed
+          };
+          break;
+        }
       }
       return {
         content: [
@@ -13666,8 +14333,57 @@ function registerWikilinkFeedbackTools(server2, getStateDb) {
   );
 }
 
+// src/tools/write/config.ts
+import { z as z22 } from "zod";
+import { saveFlywheelConfigToDb as saveFlywheelConfigToDb2 } from "@velvetmonkey/vault-core";
+function registerConfigTools(server2, getConfig, setConfig, getStateDb) {
+  server2.registerTool(
+    "flywheel_config",
+    {
+      title: "Flywheel Config",
+      description: 'Read or update Flywheel configuration.\n- "get": Returns the current FlywheelConfig\n- "set": Updates a single config key and returns the updated config\n\nExample: flywheel_config({ mode: "get" })\nExample: flywheel_config({ mode: "set", key: "exclude_analysis_tags", value: ["habit", "daily"] })',
+      inputSchema: {
+        mode: z22.enum(["get", "set"]).describe("Operation mode"),
+        key: z22.string().optional().describe("Config key to update (required for set mode)"),
+        value: z22.unknown().optional().describe("New value for the key (required for set mode)")
+      }
+    },
+    async ({ mode, key, value }) => {
+      switch (mode) {
+        case "get": {
+          const config = getConfig();
+          return {
+            content: [{ type: "text", text: JSON.stringify(config, null, 2) }]
+          };
+        }
+        case "set": {
+          if (!key) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "key is required for set mode" }) }]
+            };
+          }
+          const stateDb2 = getStateDb();
+          if (!stateDb2) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
+            };
+          }
+          const current = getConfig();
+          const updated = { ...current, [key]: value };
+          saveFlywheelConfigToDb2(stateDb2, updated);
+          const reloaded = loadConfig(stateDb2);
+          setConfig(reloaded);
+          return {
+            content: [{ type: "text", text: JSON.stringify(reloaded, null, 2) }]
+          };
+        }
+      }
+    }
+  );
+}
+
 // src/tools/read/metrics.ts
-import { z as z21 } from "zod";
+import { z as z23 } from "zod";
 
 // src/core/shared/metrics.ts
 var ALL_METRICS = [
@@ -13833,10 +14549,10 @@ function registerMetricsTools(server2, getIndex, getStateDb) {
       title: "Vault Growth",
       description: 'Track vault growth over time. Modes: "current" (live snapshot), "history" (time series), "trends" (deltas vs N days ago), "index_activity" (rebuild history). 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", "index_activity"]).describe("Query mode: current snapshot, historical time series, trend analysis, or index rebuild activity"),
-        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)"),
-        limit: z21.number().optional().describe("Number of recent events to return for index_activity mode (default: 20)")
+        mode: z23.enum(["current", "history", "trends", "index_activity"]).describe("Query mode: current snapshot, historical time series, trend analysis, or index rebuild activity"),
+        metric: z23.string().optional().describe('Filter to specific metric (e.g., "note_count"). Omit for all metrics.'),
+        days_back: z23.number().optional().describe("Number of days to look back for history/trends (default: 30)"),
+        limit: z23.number().optional().describe("Number of recent events to return for index_activity mode (default: 20)")
       }
     },
     async ({ mode, metric, days_back, limit: eventLimit }) => {
@@ -13909,7 +14625,7 @@ function registerMetricsTools(server2, getIndex, getStateDb) {
 }
 
 // src/tools/read/activity.ts
-import { z as z22 } from "zod";
+import { z as z24 } from "zod";
 
 // src/core/shared/toolTracking.ts
 function recordToolInvocation(stateDb2, event) {
@@ -13989,8 +14705,8 @@ function getNoteAccessFrequency(stateDb2, daysBack = 30) {
       }
     }
   }
-  return Array.from(noteMap.entries()).map(([path29, stats]) => ({
-    path: path29,
+  return Array.from(noteMap.entries()).map(([path30, stats]) => ({
+    path: path30,
     access_count: stats.access_count,
     last_accessed: stats.last_accessed,
     tools_used: Array.from(stats.tools)
@@ -14069,10 +14785,10 @@ function registerActivityTools(server2, getStateDb, getSessionId2) {
       title: "Vault Activity",
       description: 'Track tool usage patterns and session activity. Modes:\n- "session": Current session summary (tools called, notes accessed)\n- "sessions": List of recent sessions\n- "note_access": Notes ranked by query frequency\n- "tool_usage": Tool usage patterns (most-used tools, avg duration)',
       inputSchema: {
-        mode: z22.enum(["session", "sessions", "note_access", "tool_usage"]).describe("Activity query mode"),
-        session_id: z22.string().optional().describe("Specific session ID (for session mode, defaults to current)"),
-        days_back: z22.number().optional().describe("Number of days to look back (default: 30)"),
-        limit: z22.number().optional().describe("Maximum results to return (default: 20)")
+        mode: z24.enum(["session", "sessions", "note_access", "tool_usage"]).describe("Activity query mode"),
+        session_id: z24.string().optional().describe("Specific session ID (for session mode, defaults to current)"),
+        days_back: z24.number().optional().describe("Number of days to look back (default: 30)"),
+        limit: z24.number().optional().describe("Maximum results to return (default: 20)")
       }
     },
     async ({ mode, session_id, days_back, limit: resultLimit }) => {
@@ -14139,11 +14855,11 @@ function registerActivityTools(server2, getStateDb, getSessionId2) {
 }
 
 // src/tools/read/similarity.ts
-import { z as z23 } from "zod";
+import { z as z25 } from "zod";
 
 // src/core/read/similarity.ts
-import * as fs28 from "fs";
-import * as path27 from "path";
+import * as fs29 from "fs";
+import * as path28 from "path";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
   "be",
@@ -14278,12 +14994,12 @@ function extractKeyTerms(content, maxTerms = 15) {
   }
   return Array.from(freq.entries()).sort((a, b) => b[1] - a[1]).slice(0, maxTerms).map(([word]) => word);
 }
-function findSimilarNotes(db3, vaultPath2, index, sourcePath, options = {}) {
+function findSimilarNotes(db4, vaultPath2, index, sourcePath, options = {}) {
   const limit = options.limit ?? 10;
-  const absPath = path27.join(vaultPath2, sourcePath);
+  const absPath = path28.join(vaultPath2, sourcePath);
   let content;
   try {
-    content = fs28.readFileSync(absPath, "utf-8");
+    content = fs29.readFileSync(absPath, "utf-8");
   } catch {
     return [];
   }
@@ -14291,7 +15007,7 @@ function findSimilarNotes(db3, vaultPath2, index, sourcePath, options = {}) {
   if (terms.length === 0) return [];
   const query = terms.join(" OR ");
   try {
-    const results = db3.prepare(`
+    const results = db4.prepare(`
       SELECT
         path,
         title,
@@ -14359,9 +15075,9 @@ async function findSemanticSimilarNotes(vaultPath2, index, sourcePath, options =
     // Semantic results don't have snippets
   }));
 }
-async function findHybridSimilarNotes(db3, vaultPath2, index, sourcePath, options = {}) {
+async function findHybridSimilarNotes(db4, vaultPath2, index, sourcePath, options = {}) {
   const limit = options.limit ?? 10;
-  const bm25Results = findSimilarNotes(db3, vaultPath2, index, sourcePath, {
+  const bm25Results = findSimilarNotes(db4, vaultPath2, index, sourcePath, {
     limit: limit * 2,
     excludeLinked: options.excludeLinked
   });
@@ -14403,12 +15119,12 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
       title: "Find Similar Notes",
       description: "Find notes similar to a given note using FTS5 keyword matching. When embeddings have been built (via init_semantic), automatically uses hybrid ranking (BM25 + embedding similarity via Reciprocal Rank Fusion). Use exclude_linked to filter out notes already connected via wikilinks.",
       inputSchema: {
-        path: z23.string().describe('Path to the source note (relative to vault root, e.g. "projects/alpha.md")'),
-        limit: z23.number().optional().describe("Maximum number of similar notes to return (default: 10)"),
-        exclude_linked: z23.boolean().optional().describe("Exclude notes already linked to/from the source note (default: true)")
+        path: z25.string().describe('Path to the source note (relative to vault root, e.g. "projects/alpha.md")'),
+        limit: z25.number().optional().describe("Maximum number of similar notes to return (default: 10)"),
+        exclude_linked: z25.boolean().optional().describe("Exclude notes already linked to/from the source note (default: true)")
       }
     },
-    async ({ path: path29, limit, exclude_linked }) => {
+    async ({ path: path30, limit, exclude_linked }) => {
       const index = getIndex();
       const vaultPath2 = getVaultPath();
       const stateDb2 = getStateDb();
@@ -14417,10 +15133,10 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
           content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
         };
       }
-      if (!index.notes.has(path29)) {
+      if (!index.notes.has(path30)) {
         return {
           content: [{ type: "text", text: JSON.stringify({
-            error: `Note not found: ${path29}`,
+            error: `Note not found: ${path30}`,
             hint: "Use the full relative path including .md extension"
           }, null, 2) }]
         };
@@ -14431,12 +15147,12 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
       };
       const useHybrid = hasEmbeddingsIndex();
       const method = useHybrid ? "hybrid" : "bm25";
-      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path29, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path29, opts);
+      const results = useHybrid ? await findHybridSimilarNotes(stateDb2.db, vaultPath2, index, path30, opts) : findSimilarNotes(stateDb2.db, vaultPath2, index, path30, opts);
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
-            source: path29,
+            source: path30,
             method,
             exclude_linked: exclude_linked ?? true,
             count: results.length,
@@ -14449,7 +15165,7 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
 }
 
 // src/tools/read/semantic.ts
-import { z as z24 } from "zod";
+import { z as z26 } from "zod";
 import { getAllEntitiesFromDb } from "@velvetmonkey/vault-core";
 function registerSemanticTools(server2, getVaultPath, getStateDb) {
   server2.registerTool(
@@ -14458,7 +15174,7 @@ function registerSemanticTools(server2, getVaultPath, getStateDb) {
       title: "Initialize Semantic Search",
       description: "Download the embedding model and build semantic search index for this vault. After running, search and find_similar automatically use hybrid ranking (BM25 + semantic). Run once per vault \u2014 subsequent calls skip already-embedded notes unless force=true.",
       inputSchema: {
-        force: z24.boolean().optional().describe(
+        force: z26.boolean().optional().describe(
           "Rebuild all embeddings even if they already exist (default: false)"
         )
       }
@@ -14536,6 +15252,142 @@ function registerSemanticTools(server2, getVaultPath, getStateDb) {
   );
 }
 
+// src/tools/read/merges.ts
+init_levenshtein();
+import { z as z27 } from "zod";
+import { getAllEntitiesFromDb as getAllEntitiesFromDb2, getDismissedMergePairs, recordMergeDismissal } from "@velvetmonkey/vault-core";
+function normalizeName(name) {
+  return name.toLowerCase().replace(/[.\-_]/g, "").replace(/js$/, "").replace(/ts$/, "");
+}
+function registerMergeTools2(server2, getStateDb) {
+  server2.tool(
+    "suggest_entity_merges",
+    "Find potential duplicate entities that could be merged based on name similarity",
+    {
+      limit: z27.number().optional().default(50).describe("Maximum number of suggestions to return")
+    },
+    async ({ limit }) => {
+      const stateDb2 = getStateDb();
+      if (!stateDb2) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ suggestions: [], error: "StateDb not available" }) }]
+        };
+      }
+      const entities = getAllEntitiesFromDb2(stateDb2);
+      if (entities.length === 0) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ suggestions: [] }) }]
+        };
+      }
+      const dismissedPairs = getDismissedMergePairs(stateDb2);
+      const suggestions = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (let i = 0; i < entities.length; i++) {
+        for (let j = i + 1; j < entities.length; j++) {
+          const a = entities[i];
+          const b = entities[j];
+          if (a.path === b.path) continue;
+          const pairKey = [a.path, b.path].sort().join("::");
+          if (seen.has(pairKey)) continue;
+          if (dismissedPairs.has(pairKey)) continue;
+          const aLower = a.name.toLowerCase();
+          const bLower = b.name.toLowerCase();
+          const aNorm = normalizeName(a.name);
+          const bNorm = normalizeName(b.name);
+          let reason = "";
+          let confidence = 0;
+          if (aLower === bLower) {
+            reason = "exact name match (case-insensitive)";
+            confidence = 0.95;
+          } else if (aNorm === bNorm && aNorm.length >= 3) {
+            reason = "normalized name match";
+            confidence = 0.85;
+          } else if (aLower.length >= 3 && bLower.length >= 3) {
+            if (aLower.includes(bLower) || bLower.includes(aLower)) {
+              const shorter = aLower.length <= bLower.length ? aLower : bLower;
+              const longer = aLower.length > bLower.length ? aLower : bLower;
+              const ratio = shorter.length / longer.length;
+              if (ratio > 0.5) {
+                reason = "substring match";
+                confidence = 0.6 + ratio * 0.2;
+              }
+            }
+          }
+          if (!reason && aLower.length >= 4 && bLower.length >= 4) {
+            const maxLen = Math.max(aLower.length, bLower.length);
+            const dist = levenshteinDistance(aLower, bLower);
+            const ratio = dist / maxLen;
+            if (ratio < 0.35) {
+              reason = `similar name (edit distance ${dist})`;
+              confidence = 0.5 + (1 - ratio) * 0.4;
+            }
+          }
+          if (!reason) continue;
+          seen.add(pairKey);
+          const aHub = a.hubScore ?? 0;
+          const bHub = b.hubScore ?? 0;
+          let source = a;
+          let target = b;
+          if (aHub > bHub || aHub === bHub && a.name.length > b.name.length) {
+            source = b;
+            target = a;
+          }
+          suggestions.push({
+            source: {
+              name: source.name,
+              path: source.path,
+              category: source.category,
+              hubScore: source.hubScore ?? 0,
+              aliases: source.aliases ?? []
+            },
+            target: {
+              name: target.name,
+              path: target.path,
+              category: target.category,
+              hubScore: target.hubScore ?? 0,
+              aliases: target.aliases ?? []
+            },
+            reason,
+            confidence
+          });
+        }
+      }
+      suggestions.sort((a, b) => b.confidence - a.confidence);
+      const result = {
+        suggestions: suggestions.slice(0, limit),
+        total_candidates: suggestions.length
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "dismiss_merge_suggestion",
+    "Permanently dismiss a merge suggestion so it never reappears",
+    {
+      source_path: z27.string().describe("Path of the source entity"),
+      target_path: z27.string().describe("Path of the target entity"),
+      source_name: z27.string().describe("Name of the source entity"),
+      target_name: z27.string().describe("Name of the target entity"),
+      reason: z27.string().describe("Original suggestion reason")
+    },
+    async ({ source_path, target_path, source_name, target_name, reason }) => {
+      const stateDb2 = getStateDb();
+      if (!stateDb2) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ dismissed: false, error: "StateDb not available" }) }]
+        };
+      }
+      recordMergeDismissal(stateDb2, source_path, target_path, source_name, target_name, reason);
+      const pairKey = [source_path, target_path].sort().join("::");
+      return {
+        content: [{ type: "text", text: JSON.stringify({ dismissed: true, pair_key: pairKey }) }]
+      };
+    }
+  );
+}
+
 // src/resources/vault.ts
 function registerVaultResources(server2, getIndex) {
   server2.registerResource(
@@ -14708,11 +15560,11 @@ function parseEnabledCategories() {
         categories.add(c);
       }
     } else {
-      console.error(`[Memory] Warning: Unknown tool category "${item}" - ignoring`);
+      serverLog("server", `Unknown tool category "${item}" \u2014 ignoring`, "warn");
     }
   }
   if (categories.size === 0) {
-    console.error(`[Memory] No valid categories found, using default (${DEFAULT_PRESET})`);
+    serverLog("server", `No valid categories found, using default (${DEFAULT_PRESET})`, "warn");
     return new Set(PRESETS[DEFAULT_PRESET]);
   }
   return categories;
@@ -14781,7 +15633,16 @@ var TOOL_CATEGORY = {
   // health (activity tracking)
   vault_activity: "health",
   // schema (content similarity)
-  find_similar: "schema"
+  find_similar: "schema",
+  // health (config management)
+  flywheel_config: "health",
+  // health (server activity log)
+  server_log: "health",
+  // health (merge suggestions)
+  suggest_entity_merges: "health",
+  dismiss_merge_suggestion: "health",
+  // notes (entity merge)
+  merge_entities: "notes"
 };
 var server = new McpServer({
   name: "flywheel-memory",
@@ -14858,7 +15719,7 @@ if (_originalRegisterTool) {
   };
 }
 var categoryList = Array.from(enabledCategories).sort().join(", ");
-console.error(`[Memory] Tool categories: ${categoryList}`);
+serverLog("server", `Tool categories: ${categoryList}`);
 registerHealthTools(server, () => vaultIndex, () => vaultPath, () => flywheelConfig, () => stateDb);
 registerSystemTools(
   server,
@@ -14876,19 +15737,28 @@ registerGraphTools(server, () => vaultIndex, () => vaultPath);
 registerWikilinkTools(server, () => vaultIndex, () => vaultPath);
 registerQueryTools(server, () => vaultIndex, () => vaultPath, () => stateDb);
 registerPrimitiveTools(server, () => vaultIndex, () => vaultPath, () => flywheelConfig);
-registerGraphAnalysisTools(server, () => vaultIndex, () => vaultPath, () => stateDb);
+registerGraphAnalysisTools(server, () => vaultIndex, () => vaultPath, () => stateDb, () => flywheelConfig);
 registerVaultSchemaTools(server, () => vaultIndex, () => vaultPath);
-registerNoteIntelligenceTools(server, () => vaultIndex, () => vaultPath);
+registerNoteIntelligenceTools(server, () => vaultIndex, () => vaultPath, () => flywheelConfig);
 registerMigrationTools(server, () => vaultIndex, () => vaultPath);
 registerMutationTools(server, vaultPath, () => flywheelConfig);
 registerTaskTools(server, vaultPath);
 registerFrontmatterTools(server, vaultPath);
 registerNoteTools(server, vaultPath, () => vaultIndex);
 registerMoveNoteTools(server, vaultPath);
+registerMergeTools(server, vaultPath);
 registerSystemTools2(server, vaultPath);
 registerPolicyTools(server, vaultPath);
 registerTagTools(server, () => vaultIndex, () => vaultPath);
 registerWikilinkFeedbackTools(server, () => stateDb);
+registerConfigTools(
+  server,
+  () => flywheelConfig,
+  (newConfig) => {
+    flywheelConfig = newConfig;
+  },
+  () => stateDb
+);
 registerMetricsTools(server, () => vaultIndex, () => stateDb);
 registerActivityTools(server, () => stateDb, () => {
   try {
@@ -14899,66 +15769,68 @@ registerActivityTools(server, () => stateDb, () => {
 });
 registerSimilarityTools(server, () => vaultIndex, () => vaultPath, () => stateDb);
 registerSemanticTools(server, () => vaultPath, () => stateDb);
+registerMergeTools2(server, () => stateDb);
 registerVaultResources(server, () => vaultIndex ?? null);
-console.error(`[Memory] Registered ${_registeredCount} tools, skipped ${_skippedCount}`);
+serverLog("server", `Registered ${_registeredCount} tools, skipped ${_skippedCount}`);
 async function main() {
-  console.error(`[Memory] Starting Flywheel Memory server...`);
-  console.error(`[Memory] Vault: ${vaultPath}`);
+  serverLog("server", "Starting Flywheel Memory server...");
+  serverLog("server", `Vault: ${vaultPath}`);
   const startTime = Date.now();
   try {
     stateDb = openStateDb(vaultPath);
-    console.error("[Memory] StateDb initialized");
+    serverLog("statedb", "StateDb initialized");
     setFTS5Database(stateDb.db);
     setEmbeddingsDatabase(stateDb.db);
+    setTaskCacheDatabase(stateDb.db);
     loadEntityEmbeddingsToMemory();
     setWriteStateDb(stateDb);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    console.error(`[Memory] StateDb initialization failed: ${msg}`);
-    console.error("[Memory] Auto-wikilinks will be disabled for this session");
+    serverLog("statedb", `StateDb initialization failed: ${msg}`, "error");
+    serverLog("server", "Auto-wikilinks will be disabled for this session", "warn");
   }
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("[Memory] MCP server connected");
+  serverLog("server", "MCP server connected");
   initializeLogger(vaultPath).then(() => {
     const logger3 = getLogger();
     if (logger3?.enabled) {
-      console.error(`[Memory] Unified logging enabled`);
+      serverLog("server", "Unified logging enabled");
     }
   }).catch(() => {
   });
   initializeLogger2(vaultPath).catch((err) => {
-    console.error(`[Memory] Write logger initialization failed: ${err}`);
+    serverLog("server", `Write logger initialization failed: ${err}`, "error");
   });
   if (process.env.FLYWHEEL_SKIP_FTS5 !== "true") {
     if (isIndexStale(vaultPath)) {
       buildFTS5Index(vaultPath).then(() => {
-        console.error("[Memory] FTS5 search index ready");
+        serverLog("fts5", "Search index ready");
       }).catch((err) => {
-        console.error("[Memory] FTS5 build failed:", err);
+        serverLog("fts5", `Build failed: ${err instanceof Error ? err.message : err}`, "error");
       });
     } else {
-      console.error("[Memory] FTS5 search index already fresh, skipping rebuild");
+      serverLog("fts5", "Search index already fresh, skipping rebuild");
     }
   } else {
-    console.error("[Memory] FTS5 indexing skipped (FLYWHEEL_SKIP_FTS5=true)");
+    serverLog("fts5", "Skipping \u2014 FLYWHEEL_SKIP_FTS5");
   }
   let cachedIndex = null;
   if (stateDb) {
     try {
       const files = await scanVault(vaultPath);
       const noteCount = files.length;
-      console.error(`[Memory] Found ${noteCount} markdown files`);
+      serverLog("index", `Found ${noteCount} markdown files`);
       cachedIndex = loadVaultIndexFromCache(stateDb, noteCount);
     } catch (err) {
-      console.error("[Memory] Cache check failed:", err);
+      serverLog("index", `Cache check failed: ${err instanceof Error ? err.message : err}`, "warn");
     }
   }
   if (cachedIndex) {
     vaultIndex = cachedIndex;
     setIndexState("ready");
     const duration = Date.now() - startTime;
-    console.error(`[Memory] Index loaded from cache in ${duration}ms`);
+    serverLog("index", `Loaded from cache in ${duration}ms \u2014 ${cachedIndex.notes.size} notes`);
     if (stateDb) {
       recordIndexEvent(stateDb, {
         trigger: "startup_cache",
@@ -14968,12 +15840,12 @@ async function main() {
     }
     runPostIndexWork(vaultIndex);
   } else {
-    console.error("[Memory] Building vault index...");
+    serverLog("index", "Building vault index...");
     try {
       vaultIndex = await buildVaultIndex(vaultPath);
       setIndexState("ready");
       const duration = Date.now() - startTime;
-      console.error(`[Memory] Vault index ready in ${duration}ms`);
+      serverLog("index", `Vault index ready in ${duration}ms \u2014 ${vaultIndex.notes.size} notes`);
       if (stateDb) {
         recordIndexEvent(stateDb, {
           trigger: "startup_build",
@@ -14984,9 +15856,9 @@ async function main() {
       if (stateDb) {
         try {
           saveVaultIndexToCache(stateDb, vaultIndex);
-          console.error("[Memory] Index cache saved");
+          serverLog("index", "Index cache saved");
         } catch (err) {
-          console.error("[Memory] Failed to save index cache:", err);
+          serverLog("index", `Failed to save index cache: ${err instanceof Error ? err.message : err}`, "error");
         }
       }
       await runPostIndexWork(vaultIndex);
@@ -15002,7 +15874,7 @@ async function main() {
           error: err instanceof Error ? err.message : String(err)
         });
       }
-      console.error("[Memory] Failed to build vault index:", err);
+      serverLog("index", `Failed to build vault index: ${err instanceof Error ? err.message : err}`, "error");
     }
   }
 }
@@ -15033,9 +15905,9 @@ async function updateEntitiesInStateDb() {
       ]
     });
     stateDb.replaceAllEntities(entityIndex2);
-    console.error(`[Memory] Updated ${entityIndex2._metadata.total_entities} entities in StateDb`);
+    serverLog("index", `Updated ${entityIndex2._metadata.total_entities} entities in StateDb`);
   } catch (e) {
-    console.error("[Memory] Failed to update entities in StateDb:", e);
+    serverLog("index", `Failed to update entities in StateDb: ${e instanceof Error ? e.message : e}`, "error");
   }
 }
 async function runPostIndexWork(index) {
@@ -15049,9 +15921,9 @@ async function runPostIndexWork(index) {
       purgeOldMetrics(stateDb, 90);
       purgeOldIndexEvents(stateDb, 90);
       purgeOldInvocations(stateDb, 90);
-      console.error("[Memory] Growth metrics recorded");
+      serverLog("server", "Growth metrics recorded");
     } catch (err) {
-      console.error("[Memory] Failed to record metrics:", err);
+      serverLog("server", `Failed to record metrics: ${err instanceof Error ? err.message : err}`, "error");
     }
   }
   if (stateDb) {
@@ -15060,14 +15932,14 @@ async function runPostIndexWork(index) {
       recordGraphSnapshot(stateDb, graphMetrics);
       purgeOldSnapshots(stateDb, 90);
     } catch (err) {
-      console.error("[Memory] Failed to record graph snapshot:", err);
+      serverLog("server", `Failed to record graph snapshot: ${err instanceof Error ? err.message : err}`, "error");
     }
   }
   if (stateDb) {
     try {
       updateSuppressionList(stateDb);
     } catch (err) {
-      console.error("[Memory] Failed to update suppression list:", err);
+      serverLog("server", `Failed to update suppression list: ${err instanceof Error ? err.message : err}`, "error");
     }
   }
   const existing = loadConfig(stateDb);
@@ -15076,21 +15948,25 @@ async function runPostIndexWork(index) {
     saveConfig(stateDb, inferred, existing);
   }
   flywheelConfig = loadConfig(stateDb);
+  if (stateDb) {
+    refreshIfStale(vaultPath, index, flywheelConfig.exclude_task_tags);
+    serverLog("tasks", "Task cache ready");
+  }
   if (flywheelConfig.vault_name) {
-    console.error(`[Memory] Vault: ${flywheelConfig.vault_name}`);
+    serverLog("config", `Vault: ${flywheelConfig.vault_name}`);
   }
   if (process.env.FLYWHEEL_SKIP_EMBEDDINGS !== "true") {
     if (hasEmbeddingsIndex()) {
-      console.error("[Memory] Embeddings already built, skipping full scan");
+      serverLog("semantic", "Embeddings already built, skipping full scan");
     } else {
       setEmbeddingsBuilding(true);
       buildEmbeddingsIndex(vaultPath, (p) => {
         if (p.current % 100 === 0 || p.current === p.total) {
-          console.error(`[Semantic] ${p.current}/${p.total}`);
+          serverLog("semantic", `Embedding ${p.current}/${p.total} notes...`);
         }
       }).then(async () => {
         if (stateDb) {
-          const entities = getAllEntitiesFromDb2(stateDb);
+          const entities = getAllEntitiesFromDb3(stateDb);
           if (entities.length > 0) {
             const entityMap = new Map(entities.map((e) => [e.name, {
               name: e.name,
@@ -15102,29 +15978,29 @@ async function runPostIndexWork(index) {
           }
         }
         loadEntityEmbeddingsToMemory();
-        console.error("[Memory] Embeddings refreshed");
+        serverLog("semantic", "Embeddings ready");
       }).catch((err) => {
-        console.error("[Memory] Embeddings refresh failed:", err);
+        serverLog("semantic", `Embeddings build failed: ${err instanceof Error ? err.message : err}`, "error");
       });
     }
   } else {
-    console.error("[Memory] Embeddings skipped (FLYWHEEL_SKIP_EMBEDDINGS=true)");
+    serverLog("semantic", "Skipping \u2014 FLYWHEEL_SKIP_EMBEDDINGS");
   }
   if (process.env.FLYWHEEL_WATCH !== "false") {
     const config = parseWatcherConfig();
-    console.error(`[Memory] File watcher enabled (debounce: ${config.debounceMs}ms)`);
+    serverLog("watcher", `File watcher enabled (debounce: ${config.debounceMs}ms)`);
     const watcher = createVaultWatcher({
       vaultPath,
       config,
       onBatch: async (batch) => {
-        console.error(`[Memory] Processing ${batch.events.length} file changes`);
+        serverLog("watcher", `Processing ${batch.events.length} file changes`);
         const batchStart = Date.now();
         const changedPaths = batch.events.map((e) => e.path);
         try {
           vaultIndex = await buildVaultIndex(vaultPath);
           setIndexState("ready");
           const duration = Date.now() - batchStart;
-          console.error(`[Memory] Index rebuilt in ${duration}ms`);
+          serverLog("watcher", `Index rebuilt in ${duration}ms`);
           if (stateDb) {
             recordIndexEvent(stateDb, {
               trigger: "watcher",
@@ -15142,7 +16018,7 @@ async function runPostIndexWork(index) {
                 if (event.type === "delete") {
                   removeEmbedding(event.path);
                 } else if (event.path.endsWith(".md")) {
-                  const absPath = path28.join(vaultPath, event.path);
+                  const absPath = path29.join(vaultPath, event.path);
                   await updateEmbedding(event.path, absPath);
                 }
               } catch {
@@ -15151,7 +16027,7 @@ async function runPostIndexWork(index) {
           }
           if (hasEntityEmbeddingsIndex() && stateDb) {
             try {
-              const allEntities = getAllEntitiesFromDb2(stateDb);
+              const allEntities = getAllEntitiesFromDb3(stateDb);
               for (const event of batch.events) {
                 if (event.type === "delete" || !event.path.endsWith(".md")) continue;
                 const matching = allEntities.filter((e) => e.path === event.path);
@@ -15171,7 +16047,17 @@ async function runPostIndexWork(index) {
             try {
               saveVaultIndexToCache(stateDb, vaultIndex);
             } catch (err) {
-              console.error("[Memory] Failed to update index cache:", err);
+              serverLog("index", `Failed to update index cache: ${err instanceof Error ? err.message : err}`, "error");
+            }
+          }
+          for (const event of batch.events) {
+            try {
+              if (event.type === "delete") {
+                removeTaskCacheForFile(event.path);
+              } else if (event.path.endsWith(".md")) {
+                await updateTaskCacheForFile(vaultPath, event.path);
+              }
+            } catch {
             }
           }
         } catch (err) {
@@ -15188,16 +16074,16 @@ async function runPostIndexWork(index) {
               error: err instanceof Error ? err.message : String(err)
             });
           }
-          console.error("[Memory] Failed to rebuild index:", err);
+          serverLog("watcher", `Failed to rebuild index: ${err instanceof Error ? err.message : err}`, "error");
         }
       },
       onStateChange: (status) => {
         if (status.state === "dirty") {
-          console.error("[Memory] Warning: Index may be stale");
+          serverLog("watcher", "Index may be stale", "warn");
         }
       },
       onError: (err) => {
-        console.error("[Memory] Watcher error:", err.message);
+        serverLog("watcher", `Watcher error: ${err.message}`, "error");
       }
     });
     watcher.start();
@@ -15208,15 +16094,15 @@ if (process.argv.includes("--init-semantic")) {
     console.error("[Semantic] Pre-warming semantic search...");
     console.error(`[Semantic] Vault: ${vaultPath}`);
     try {
-      const db3 = openStateDb(vaultPath);
-      setEmbeddingsDatabase(db3.db);
+      const db4 = openStateDb(vaultPath);
+      setEmbeddingsDatabase(db4.db);
       const progress = await buildEmbeddingsIndex(vaultPath, (p) => {
         if (p.current % 50 === 0 || p.current === p.total) {
           console.error(`[Semantic] Embedding ${p.current}/${p.total} notes (${p.skipped} skipped)...`);
         }
       });
       console.error(`[Semantic] Done. Embedded ${progress.total - progress.skipped} notes, skipped ${progress.skipped}.`);
-      db3.close();
+      db4.close();
       process.exit(0);
     } catch (err) {
       console.error("[Semantic] Failed:", err instanceof Error ? err.message : err);