@velvetmonkey/flywheel-memory 2.0.50 → 2.0.52

package/dist/index.js

@@ -1834,6 +1834,15 @@ var embeddingsBuilding = false;
 var embeddingCache = /* @__PURE__ */ new Map();
 var EMBEDDING_CACHE_MAX = 500;
 var entityEmbeddingsMap = /* @__PURE__ */ new Map();
+function getEmbeddingsBuildState() {
+  if (!db) return "none";
+  const row = db.prepare(`SELECT value FROM fts_metadata WHERE key = 'embeddings_state'`).get();
+  return row?.value || "none";
+}
+function setEmbeddingsBuildState(state2) {
+  if (!db) return;
+  db.prepare(`INSERT OR REPLACE INTO fts_metadata (key, value) VALUES ('embeddings_state', ?)`).run(state2);
+}
 function setEmbeddingsDatabase(database) {
   db = database;
 }
@@ -1887,6 +1896,7 @@ async function buildEmbeddingsIndex(vaultPath2, onProgress) {
     throw new Error("Embeddings database not initialized. Call setEmbeddingsDatabase() first.");
   }
   embeddingsBuilding = true;
+  setEmbeddingsBuildState("building_notes");
   await initEmbeddings();
   const files = await scanVault(vaultPath2);
   const indexable = files.filter((f) => shouldIndexFile(f.path));
@@ -2037,8 +2047,13 @@ function setEmbeddingsBuilding(value) {
 function hasEmbeddingsIndex() {
   if (!db) return false;
   try {
-    const row = db.prepare("SELECT COUNT(*) as count FROM note_embeddings").get();
-    return row.count > 0;
+    const state2 = getEmbeddingsBuildState();
+    if (state2 === "complete") return true;
+    if (state2 === "none") {
+      const row = db.prepare("SELECT COUNT(*) as count FROM note_embeddings").get();
+      return row.count > 0;
+    }
+    return false;
   } catch {
     return false;
   }
@@ -2090,6 +2105,7 @@ async function buildEntityEmbeddingsIndex(vaultPath2, entities, onProgress) {
     throw new Error("Embeddings database not initialized. Call setEmbeddingsDatabase() first.");
   }
   await initEmbeddings();
+  setEmbeddingsBuildState("building_entities");
   const existingHashes = /* @__PURE__ */ new Map();
   const rows = db.prepare("SELECT entity_name, source_hash FROM entity_embeddings").all();
   for (const row of rows) {
@@ -3915,6 +3931,20 @@ function processImplicitFeedback(stateDb2, notePath, currentContent) {
   if (removed.length > 0) {
     updateSuppressionList(stateDb2);
   }
+  const SURVIVAL_COOLDOWN_MS = 24 * 60 * 60 * 1e3;
+  const getLastSurvival = stateDb2.db.prepare(
+    `SELECT MAX(created_at) as last FROM wikilink_feedback
+     WHERE entity = ? COLLATE NOCASE AND context = 'implicit:survived' AND note_path = ?`
+  );
+  for (const { entity } of trackedWithTime) {
+    if (currentLinks.has(entity.toLowerCase())) {
+      const lastSurvival = getLastSurvival.get(entity, notePath);
+      const lastAt = lastSurvival?.last ? new Date(lastSurvival.last).getTime() : 0;
+      if (Date.now() - lastAt > SURVIVAL_COOLDOWN_MS) {
+        recordFeedback(stateDb2, entity, "implicit:survived", notePath, true, 0.8);
+      }
+    }
+  }
   return removed;
 }
 var TIER_LABELS = [
@@ -5534,6 +5564,68 @@ function tokenIdf(token, coocIndex) {
   const rawIdf = Math.log((N + 1) / (df + 1));
   return Math.max(0.5, Math.min(2.5, rawIdf));
 }
+function serializeCooccurrenceIndex(index) {
+  const serialized = {};
+  for (const [entity, assocs] of Object.entries(index.associations)) {
+    serialized[entity] = Object.fromEntries(assocs);
+  }
+  return {
+    associations: serialized,
+    minCount: index.minCount,
+    documentFrequency: Object.fromEntries(index.documentFrequency),
+    totalNotesScanned: index.totalNotesScanned,
+    _metadata: index._metadata
+  };
+}
+function deserializeCooccurrenceIndex(data) {
+  try {
+    const associations = {};
+    const assocData = data.associations;
+    if (!assocData) return null;
+    for (const [entity, assocs] of Object.entries(assocData)) {
+      associations[entity] = new Map(Object.entries(assocs));
+    }
+    const dfData = data.documentFrequency;
+    const documentFrequency = dfData ? new Map(Object.entries(dfData).map(([k, v]) => [k, v])) : /* @__PURE__ */ new Map();
+    const totalNotesScanned = data.totalNotesScanned || 0;
+    return {
+      associations,
+      minCount: data.minCount || DEFAULT_MIN_COOCCURRENCE,
+      documentFrequency,
+      totalNotesScanned,
+      _metadata: data._metadata
+    };
+  } catch {
+    return null;
+  }
+}
+var COOCCURRENCE_CACHE_MAX_AGE_MS = 60 * 60 * 1e3;
+function saveCooccurrenceToStateDb(stateDb2, index) {
+  const serialized = serializeCooccurrenceIndex(index);
+  const data = JSON.stringify(serialized);
+  const entityCount = Object.keys(index.associations).length;
+  const associationCount = index._metadata.total_associations;
+  stateDb2.db.prepare(`
+    INSERT OR REPLACE INTO cooccurrence_cache (id, data, built_at, entity_count, association_count)
+    VALUES (1, ?, ?, ?, ?)
+  `).run(data, Date.now(), entityCount, associationCount);
+}
+function loadCooccurrenceFromStateDb(stateDb2) {
+  const row = stateDb2.db.prepare(
+    "SELECT data, built_at FROM cooccurrence_cache WHERE id = 1"
+  ).get();
+  if (!row) return null;
+  const ageMs = Date.now() - row.built_at;
+  if (ageMs > COOCCURRENCE_CACHE_MAX_AGE_MS) return null;
+  try {
+    const parsed = JSON.parse(row.data);
+    const index = deserializeCooccurrenceIndex(parsed);
+    if (!index) return null;
+    return { index, builtAt: row.built_at };
+  } catch {
+    return null;
+  }
+}
 
 // src/core/write/edgeWeights.ts
 var moduleStateDb4 = null;
@@ -7909,7 +8001,7 @@ function registerGraphTools(server2, getIndex, getVaultPath, getStateDb) {
 
 // src/tools/read/wikilinks.ts
 import { z as z2 } from "zod";
-import { detectImplicitEntities as detectImplicitEntities2 } from "@velvetmonkey/vault-core";
+import { detectImplicitEntities as detectImplicitEntities2, IMPLICIT_EXCLUDE_WORDS } from "@velvetmonkey/vault-core";
 function findEntityMatches(text, entities) {
   const matches = [];
   const sortedEntities = Array.from(entities.entries()).filter(([name]) => name.length >= 2).sort((a, b) => b[0].length - a[0].length);
@@ -8031,6 +8123,8 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
         if (links.length < 2) continue;
         if (index.entities.has(target.toLowerCase())) continue;
         if (linkedSet.has(target.toLowerCase())) continue;
+        if (IMPLICIT_EXCLUDE_WORDS.has(target.toLowerCase())) continue;
+        if (target.length < 4) continue;
         const targetLower = target.toLowerCase();
         const textLower = text.toLowerCase();
         let searchPos = 0;
@@ -16294,6 +16388,24 @@ function resolveCorrection(stateDb2, id, newStatus) {
   `).run(newStatus, id);
   return result.changes > 0;
 }
+function processPendingCorrections(stateDb2) {
+  const pending = listCorrections(stateDb2, "pending");
+  let processed = 0;
+  for (const correction of pending) {
+    if (!correction.entity) {
+      resolveCorrection(stateDb2, correction.id, "dismissed");
+      continue;
+    }
+    if (correction.correction_type === "wrong_link") {
+      recordFeedback(stateDb2, correction.entity, "correction:wrong_link", correction.note_path || "", false, 1);
+    } else if (correction.correction_type === "wrong_category") {
+      recordFeedback(stateDb2, correction.entity, "correction:wrong_category", "", false, 0.5);
+    }
+    resolveCorrection(stateDb2, correction.id, "applied");
+    processed++;
+  }
+  return processed;
+}
 
 // src/tools/write/corrections.ts
 function registerCorrectionTools(server2, getStateDb) {
@@ -16390,99 +16502,1150 @@ function registerCorrectionTools(server2, getStateDb) {
   );
 }
 
-// src/tools/write/config.ts
+// src/tools/write/memory.ts
 import { z as z23 } 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: z23.enum(["get", "set"]).describe("Operation mode"),
-        key: z23.string().optional().describe("Config key to update (required for set mode)"),
-        value: z23.unknown().optional().describe("New value for the key (required for set mode)")
+
+// src/core/write/memory.ts
+import { recordEntityMention as recordEntityMention2 } from "@velvetmonkey/vault-core";
+function detectEntities(stateDb2, text) {
+  const allEntities = stateDb2.getAllEntities.all();
+  const detected = /* @__PURE__ */ new Set();
+  const textLower = text.toLowerCase();
+  for (const entity of allEntities) {
+    if (textLower.includes(entity.name_lower)) {
+      detected.add(entity.name);
+    }
+    if (entity.aliases_json) {
+      try {
+        const aliases = JSON.parse(entity.aliases_json);
+        for (const alias of aliases) {
+          if (alias.length >= 3 && textLower.includes(alias.toLowerCase())) {
+            detected.add(entity.name);
+            break;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return [...detected];
+}
+function updateGraphSignals(stateDb2, memoryKey, entities) {
+  if (entities.length === 0) return;
+  const now = /* @__PURE__ */ new Date();
+  for (const entity of entities) {
+    recordEntityMention2(stateDb2, entity, now);
+  }
+  const sourcePath = `memory:${memoryKey}`;
+  const targets = new Set(entities.map((e) => e.toLowerCase()));
+  updateStoredNoteLinks(stateDb2, sourcePath, targets);
+}
+function removeGraphSignals(stateDb2, memoryKey) {
+  const sourcePath = `memory:${memoryKey}`;
+  updateStoredNoteLinks(stateDb2, sourcePath, /* @__PURE__ */ new Set());
+}
+function storeMemory(stateDb2, options) {
+  const {
+    key,
+    value,
+    type,
+    entity,
+    confidence = 1,
+    ttl_days,
+    agent_id,
+    session_id,
+    visibility = "shared"
+  } = options;
+  const now = Date.now();
+  const detectedEntities = detectEntities(stateDb2, value);
+  if (entity && !detectedEntities.includes(entity)) {
+    detectedEntities.push(entity);
+  }
+  const entitiesJson = detectedEntities.length > 0 ? JSON.stringify(detectedEntities) : null;
+  const existing = stateDb2.db.prepare(
+    "SELECT id FROM memories WHERE key = ?"
+  ).get(key);
+  if (existing) {
+    stateDb2.db.prepare(`
+      UPDATE memories SET
+        value = ?, memory_type = ?, entity = ?, entities_json = ?,
+        source_agent_id = ?, source_session_id = ?,
+        confidence = ?, updated_at = ?, accessed_at = ?,
+        ttl_days = ?, visibility = ?, superseded_by = NULL
+      WHERE key = ?
+    `).run(
+      value,
+      type,
+      entity ?? null,
+      entitiesJson,
+      agent_id ?? null,
+      session_id ?? null,
+      confidence,
+      now,
+      now,
+      ttl_days ?? null,
+      visibility,
+      key
+    );
+  } else {
+    stateDb2.db.prepare(`
+      INSERT INTO memories (key, value, memory_type, entity, entities_json,
+        source_agent_id, source_session_id, confidence,
+        created_at, updated_at, accessed_at, ttl_days, visibility)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      key,
+      value,
+      type,
+      entity ?? null,
+      entitiesJson,
+      agent_id ?? null,
+      session_id ?? null,
+      confidence,
+      now,
+      now,
+      now,
+      ttl_days ?? null,
+      visibility
+    );
+  }
+  updateGraphSignals(stateDb2, key, detectedEntities);
+  return stateDb2.db.prepare(
+    "SELECT * FROM memories WHERE key = ?"
+  ).get(key);
+}
+function getMemory(stateDb2, key) {
+  const memory = stateDb2.db.prepare(
+    "SELECT * FROM memories WHERE key = ? AND superseded_by IS NULL"
+  ).get(key);
+  if (!memory) return null;
+  stateDb2.db.prepare(
+    "UPDATE memories SET accessed_at = ? WHERE id = ?"
+  ).run(Date.now(), memory.id);
+  return memory;
+}
+function searchMemories(stateDb2, options) {
+  const { query, type, entity, limit = 20, agent_id } = options;
+  const conditions = ["m.superseded_by IS NULL"];
+  const params = [];
+  if (type) {
+    conditions.push("m.memory_type = ?");
+    params.push(type);
+  }
+  if (entity) {
+    conditions.push("(m.entity = ? COLLATE NOCASE OR m.entities_json LIKE ?)");
+    params.push(entity, `%"${entity}"%`);
+  }
+  if (agent_id) {
+    conditions.push("(m.visibility = 'shared' OR m.source_agent_id = ?)");
+    params.push(agent_id);
+  }
+  const where = conditions.length > 0 ? `AND ${conditions.join(" AND ")}` : "";
+  try {
+    const results = stateDb2.db.prepare(`
+      SELECT m.* FROM memories_fts
+      JOIN memories m ON m.id = memories_fts.rowid
+      WHERE memories_fts MATCH ?
+      ${where}
+      ORDER BY bm25(memories_fts)
+      LIMIT ?
+    `).all(query, ...params, limit);
+    return results;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("fts5: syntax error")) {
+      throw new Error(`Invalid search query: ${query}. Check FTS5 syntax.`);
+    }
+    throw err;
+  }
+}
+function listMemories(stateDb2, options = {}) {
+  const { type, entity, limit = 50, agent_id, include_expired = false } = options;
+  const conditions = [];
+  const params = [];
+  if (!include_expired) {
+    conditions.push("superseded_by IS NULL");
+  }
+  if (type) {
+    conditions.push("memory_type = ?");
+    params.push(type);
+  }
+  if (entity) {
+    conditions.push("(entity = ? COLLATE NOCASE OR entities_json LIKE ?)");
+    params.push(entity, `%"${entity}"%`);
+  }
+  if (agent_id) {
+    conditions.push("(visibility = 'shared' OR source_agent_id = ?)");
+    params.push(agent_id);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  params.push(limit);
+  return stateDb2.db.prepare(
+    `SELECT * FROM memories ${where} ORDER BY updated_at DESC LIMIT ?`
+  ).all(...params);
+}
+function forgetMemory(stateDb2, key) {
+  const memory = stateDb2.db.prepare(
+    "SELECT id FROM memories WHERE key = ?"
+  ).get(key);
+  if (!memory) return false;
+  removeGraphSignals(stateDb2, key);
+  stateDb2.db.prepare("DELETE FROM memories WHERE key = ?").run(key);
+  return true;
+}
+function storeSessionSummary(stateDb2, sessionId, summary, options = {}) {
+  const now = Date.now();
+  const { topics, notes_modified, agent_id, started_at, tool_count } = options;
+  stateDb2.db.prepare(`
+    INSERT OR REPLACE INTO session_summaries
+      (session_id, summary, topics_json, notes_modified_json,
+       agent_id, started_at, ended_at, tool_count)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    sessionId,
+    summary,
+    topics ? JSON.stringify(topics) : null,
+    notes_modified ? JSON.stringify(notes_modified) : null,
+    agent_id ?? null,
+    started_at ?? null,
+    now,
+    tool_count ?? null
+  );
+  return stateDb2.db.prepare(
+    "SELECT * FROM session_summaries WHERE session_id = ?"
+  ).get(sessionId);
+}
+function getRecentSessionSummaries(stateDb2, limit = 5, agent_id) {
+  if (agent_id) {
+    return stateDb2.db.prepare(
+      "SELECT * FROM session_summaries WHERE agent_id = ? ORDER BY ended_at DESC LIMIT ?"
+    ).all(agent_id, limit);
+  }
+  return stateDb2.db.prepare(
+    "SELECT * FROM session_summaries ORDER BY ended_at DESC LIMIT ?"
+  ).all(limit);
+}
+function findContradictions2(stateDb2, entity) {
+  const conditions = ["superseded_by IS NULL"];
+  const params = [];
+  if (entity) {
+    conditions.push("(entity = ? COLLATE NOCASE OR entities_json LIKE ?)");
+    params.push(entity, `%"${entity}"%`);
+  }
+  const where = `WHERE ${conditions.join(" AND ")}`;
+  const memories = stateDb2.db.prepare(
+    `SELECT * FROM memories ${where} ORDER BY entity, key, updated_at DESC`
+  ).all(...params);
+  const contradictions = [];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const m of memories) {
+    const group = m.key;
+    const list = byKey.get(group) || [];
+    list.push(m);
+    byKey.set(group, list);
+  }
+  for (const [, mems] of byKey) {
+    if (mems.length > 1) {
+      for (let i = 0; i < mems.length - 1; i++) {
+        contradictions.push({ memory_a: mems[i], memory_b: mems[i + 1] });
       }
+    }
+  }
+  return contradictions;
+}
+
+// src/tools/write/memory.ts
+function registerMemoryTools(server2, getStateDb) {
+  server2.tool(
+    "memory",
+    "Store, retrieve, search, and manage agent working memory. Actions: store, get, search, list, forget, summarize_session.",
+    {
+      action: z23.enum(["store", "get", "search", "list", "forget", "summarize_session"]).describe("Action to perform"),
+      // store params
+      key: z23.string().optional().describe('Memory key (e.g., "user.pref.theme", "project.x.deadline")'),
+      value: z23.string().optional().describe("The fact/preference/observation to store (up to 2000 chars)"),
+      type: z23.enum(["fact", "preference", "observation", "summary"]).optional().describe("Memory type"),
+      entity: z23.string().optional().describe("Primary entity association"),
+      confidence: z23.number().min(0).max(1).optional().describe("Confidence level (0-1, default 1.0)"),
+      ttl_days: z23.number().min(1).optional().describe("Time-to-live in days (null = permanent)"),
+      // search params
+      query: z23.string().optional().describe("FTS5 search query"),
+      // list/search params
+      limit: z23.number().min(1).max(200).optional().describe("Max results to return"),
+      // summarize_session params
+      session_id: z23.string().optional().describe("Session ID for summarize_session"),
+      summary: z23.string().optional().describe("Session summary text"),
+      topics: z23.array(z23.string()).optional().describe("Topics discussed in session"),
+      notes_modified: z23.array(z23.string()).optional().describe("Note paths modified during session"),
+      tool_count: z23.number().optional().describe("Number of tool calls in session")
     },
-    async ({ mode, key, value }) => {
-      switch (mode) {
+    async (args) => {
+      const stateDb2 = getStateDb();
+      if (!stateDb2) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }],
+          isError: true
+        };
+      }
+      const agentId = process.env.FLYWHEEL_AGENT_ID || void 0;
+      let sessionId;
+      try {
+        const { getSessionId: getSessionId2 } = await import("@velvetmonkey/vault-core");
+        sessionId = getSessionId2();
+      } catch {
+      }
+      switch (args.action) {
+        case "store": {
+          if (!args.key || !args.value || !args.type) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "store requires key, value, and type" }) }],
+              isError: true
+            };
+          }
+          if (args.value.length > 2e3) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "value must be 2000 chars or less" }) }],
+              isError: true
+            };
+          }
+          const memory = storeMemory(stateDb2, {
+            key: args.key,
+            value: args.value,
+            type: args.type,
+            entity: args.entity,
+            confidence: args.confidence,
+            ttl_days: args.ttl_days,
+            agent_id: agentId,
+            session_id: sessionId
+          });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                stored: true,
+                memory: {
+                  key: memory.key,
+                  value: memory.value,
+                  type: memory.memory_type,
+                  entity: memory.entity,
+                  entities_detected: memory.entities_json ? JSON.parse(memory.entities_json) : [],
+                  confidence: memory.confidence
+                }
+              }, null, 2)
+            }]
+          };
+        }
         case "get": {
-          const config = getConfig();
+          if (!args.key) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "get requires key" }) }],
+              isError: true
+            };
+          }
+          const memory = getMemory(stateDb2, args.key);
+          if (!memory) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ found: false, key: args.key }) }]
+            };
+          }
           return {
-            content: [{ type: "text", text: JSON.stringify(config, null, 2) }]
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                found: true,
+                memory: {
+                  key: memory.key,
+                  value: memory.value,
+                  type: memory.memory_type,
+                  entity: memory.entity,
+                  entities: memory.entities_json ? JSON.parse(memory.entities_json) : [],
+                  confidence: memory.confidence,
+                  created_at: memory.created_at,
+                  updated_at: memory.updated_at,
+                  accessed_at: memory.accessed_at
+                }
+              }, null, 2)
+            }]
           };
         }
-        case "set": {
-          if (!key) {
+        case "search": {
+          if (!args.query) {
             return {
-              content: [{ type: "text", text: JSON.stringify({ error: "key is required for set mode" }) }]
+              content: [{ type: "text", text: JSON.stringify({ error: "search requires query" }) }],
+              isError: true
             };
           }
-          const stateDb2 = getStateDb();
-          if (!stateDb2) {
+          const results = searchMemories(stateDb2, {
+            query: args.query,
+            type: args.type,
+            entity: args.entity,
+            limit: args.limit,
+            agent_id: agentId
+          });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                results: results.map((m) => ({
+                  key: m.key,
+                  value: m.value,
+                  type: m.memory_type,
+                  entity: m.entity,
+                  confidence: m.confidence,
+                  updated_at: m.updated_at
+                })),
+                count: results.length
+              }, null, 2)
+            }]
+          };
+        }
+        case "list": {
+          const results = listMemories(stateDb2, {
+            type: args.type,
+            entity: args.entity,
+            limit: args.limit,
+            agent_id: agentId
+          });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                memories: results.map((m) => ({
+                  key: m.key,
+                  value: m.value,
+                  type: m.memory_type,
+                  entity: m.entity,
+                  confidence: m.confidence,
+                  updated_at: m.updated_at
+                })),
+                count: results.length
+              }, null, 2)
+            }]
+          };
+        }
+        case "forget": {
+          if (!args.key) {
             return {
-              content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }]
+              content: [{ type: "text", text: JSON.stringify({ error: "forget requires key" }) }],
+              isError: true
             };
           }
-          const current = getConfig();
-          const updated = { ...current, [key]: value };
-          saveFlywheelConfigToDb2(stateDb2, updated);
-          const reloaded = loadConfig(stateDb2);
-          setConfig(reloaded);
+          const deleted = forgetMemory(stateDb2, args.key);
           return {
-            content: [{ type: "text", text: JSON.stringify(reloaded, null, 2) }]
+            content: [{
+              type: "text",
+              text: JSON.stringify({ forgotten: deleted, key: args.key }, null, 2)
+            }]
+          };
+        }
+        case "summarize_session": {
+          const sid = args.session_id || sessionId;
+          if (!sid || !args.summary) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "summarize_session requires session_id and summary" }) }],
+              isError: true
+            };
+          }
+          const result = storeSessionSummary(stateDb2, sid, args.summary, {
+            topics: args.topics,
+            notes_modified: args.notes_modified,
+            agent_id: agentId,
+            tool_count: args.tool_count
+          });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                stored: true,
+                session_id: result.session_id,
+                summary_length: result.summary.length
+              }, null, 2)
+            }]
           };
         }
+        default:
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: `Unknown action: ${args.action}` }) }],
+            isError: true
+          };
       }
     }
   );
 }
 
-// src/tools/write/enrich.ts
+// src/tools/read/recall.ts
 import { z as z24 } from "zod";
-import * as fs29 from "fs/promises";
-import * as path30 from "path";
-function hasSkipWikilinks(content) {
-  if (!content.startsWith("---")) return false;
-  const endIndex = content.indexOf("\n---", 3);
-  if (endIndex === -1) return false;
-  const frontmatter = content.substring(4, endIndex);
-  return /^skipWikilinks:\s*true\s*$/m.test(frontmatter);
+import { searchEntities as searchEntitiesDb2 } from "@velvetmonkey/vault-core";
+function scoreTextRelevance(query, content) {
+  const queryTokens = tokenize(query).map((t) => t.toLowerCase());
+  const queryStems = queryTokens.map((t) => stem(t));
+  const contentLower = content.toLowerCase();
+  const contentTokens = new Set(tokenize(contentLower));
+  const contentStems = new Set([...contentTokens].map((t) => stem(t)));
+  let score = 0;
+  for (let i = 0; i < queryTokens.length; i++) {
+    const token = queryTokens[i];
+    const stemmed = queryStems[i];
+    if (contentTokens.has(token)) {
+      score += 10;
+    } else if (contentStems.has(stemmed)) {
+      score += 5;
+    }
+  }
+  if (contentLower.includes(query.toLowerCase())) {
+    score += 15;
+  }
+  return score;
 }
-async function collectMarkdownFiles(dirPath, basePath, excludeFolders) {
+function getEdgeWeightBoost(entityName, edgeWeightMap) {
+  const avgWeight = edgeWeightMap.get(entityName.toLowerCase());
+  if (!avgWeight || avgWeight <= 1) return 0;
+  return Math.min((avgWeight - 1) * 3, 6);
+}
+async function performRecall(stateDb2, query, options = {}) {
+  const {
+    max_results = 20,
+    focus = "all",
+    entity,
+    max_tokens
+  } = options;
   const results = [];
-  try {
-    const entries = await fs29.readdir(dirPath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith(".")) continue;
-      const fullPath = path30.join(dirPath, entry.name);
-      if (entry.isDirectory()) {
-        if (excludeFolders.some((f) => entry.name.toLowerCase() === f.toLowerCase())) continue;
-        const sub = await collectMarkdownFiles(fullPath, basePath, excludeFolders);
-        results.push(...sub);
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        results.push(path30.relative(basePath, fullPath));
+  const recencyIndex2 = loadRecencyFromStateDb();
+  const edgeWeightMap = getEntityEdgeWeightMap(stateDb2);
+  const feedbackBoosts = getAllFeedbackBoosts(stateDb2);
+  if (focus === "all" || focus === "entities") {
+    try {
+      const entityResults = searchEntitiesDb2(stateDb2, query, max_results);
+      for (const e of entityResults) {
+        const textScore = scoreTextRelevance(query, `${e.name} ${e.description || ""}`);
+        const recency = recencyIndex2 ? getRecencyBoost(e.name, recencyIndex2) : 0;
+        const feedback = feedbackBoosts.get(e.name) ?? 0;
+        const edgeWeight = getEdgeWeightBoost(e.name, edgeWeightMap);
+        const total = textScore + recency + feedback + edgeWeight;
+        if (total > 0) {
+          results.push({
+            type: "entity",
+            id: e.name,
+            content: e.description || `Entity: ${e.name} (${e.category})`,
+            score: total,
+            breakdown: {
+              textRelevance: textScore,
+              recencyBoost: recency,
+              cooccurrenceBoost: 0,
+              feedbackBoost: feedback,
+              edgeWeightBoost: edgeWeight,
+              semanticBoost: 0
+            }
+          });
+        }
       }
+    } catch {
     }
-  } catch {
   }
-  return results;
-}
-var EXCLUDE_FOLDERS = [
-  "daily-notes",
-  "daily",
-  "weekly",
-  "weekly-notes",
-  "monthly",
-  "monthly-notes",
-  "quarterly",
-  "yearly-notes",
-  "periodic",
-  "journal",
-  "inbox",
-  "templates",
-  "attachments",
+  if (focus === "all" || focus === "notes") {
+    try {
+      const noteResults = searchFTS5("", query, max_results);
+      for (const n of noteResults) {
+        const textScore = Math.max(10, scoreTextRelevance(query, `${n.title || ""} ${n.snippet || ""}`));
+        results.push({
+          type: "note",
+          id: n.path,
+          content: n.snippet || n.title || n.path,
+          score: textScore,
+          breakdown: {
+            textRelevance: textScore,
+            recencyBoost: 0,
+            cooccurrenceBoost: 0,
+            feedbackBoost: 0,
+            edgeWeightBoost: 0,
+            semanticBoost: 0
+          }
+        });
+      }
+    } catch {
+    }
+  }
+  if (focus === "all" || focus === "memories") {
+    try {
+      const memResults = searchMemories(stateDb2, {
+        query,
+        entity,
+        limit: max_results
+      });
+      for (const m of memResults) {
+        const textScore = scoreTextRelevance(query, `${m.key} ${m.value}`);
+        const memScore = textScore + m.confidence * 5;
+        results.push({
+          type: "memory",
+          id: m.key,
+          content: m.value,
+          score: memScore,
+          breakdown: {
+            textRelevance: textScore,
+            recencyBoost: 0,
+            cooccurrenceBoost: 0,
+            feedbackBoost: m.confidence * 5,
+            edgeWeightBoost: 0,
+            semanticBoost: 0
+          }
+        });
+      }
+    } catch {
+    }
+  }
+  if ((focus === "all" || focus === "entities") && query.length >= 20 && hasEntityEmbeddingsIndex()) {
+    try {
+      const embedding = await embedTextCached(query);
+      const semanticMatches = findSemanticallySimilarEntities(embedding, max_results);
+      for (const match of semanticMatches) {
+        if (match.similarity < 0.3) continue;
+        const boost = match.similarity * 15;
+        const existing = results.find((r) => r.type === "entity" && r.id === match.entityName);
+        if (existing) {
+          existing.score += boost;
+          existing.breakdown.semanticBoost = boost;
+        } else {
+          results.push({
+            type: "entity",
+            id: match.entityName,
+            content: `Semantically similar to: "${query}"`,
+            score: boost,
+            breakdown: {
+              textRelevance: 0,
+              recencyBoost: 0,
+              cooccurrenceBoost: 0,
+              feedbackBoost: 0,
+              edgeWeightBoost: 0,
+              semanticBoost: boost
+            }
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = results.filter((r) => {
+    const key = `${r.type}:${r.id}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  const truncated = deduped.slice(0, max_results);
+  if (max_tokens) {
+    let tokenBudget = max_tokens;
+    const budgeted = [];
+    for (const r of truncated) {
+      const estimatedTokens = Math.ceil(r.content.length / 4);
+      if (tokenBudget - estimatedTokens < 0 && budgeted.length > 0) break;
+      tokenBudget -= estimatedTokens;
+      budgeted.push(r);
+    }
+    return budgeted;
+  }
+  return truncated;
+}
+function registerRecallTools(server2, getStateDb) {
+  server2.tool(
+    "recall",
+    "Query everything the system knows about a topic. Searches across entities, notes, and memories with graph-boosted ranking.",
+    {
+      query: z24.string().describe('What to recall (e.g., "Project X", "meetings about auth")'),
+      max_results: z24.number().min(1).max(100).optional().describe("Max results (default: 20)"),
+      focus: z24.enum(["entities", "notes", "memories", "all"]).optional().describe("Limit search to specific type (default: all)"),
+      entity: z24.string().optional().describe("Filter memories by entity association"),
+      max_tokens: z24.number().optional().describe("Token budget for response (truncates lower-ranked results)")
+    },
+    async (args) => {
+      const stateDb2 = getStateDb();
+      if (!stateDb2) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }],
+          isError: true
+        };
+      }
+      const results = await performRecall(stateDb2, args.query, {
+        max_results: args.max_results,
+        focus: args.focus,
+        entity: args.entity,
+        max_tokens: args.max_tokens
+      });
+      const entities = results.filter((r) => r.type === "entity");
+      const notes = results.filter((r) => r.type === "note");
+      const memories = results.filter((r) => r.type === "memory");
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            query: args.query,
+            total: results.length,
+            entities: entities.map((e) => ({
+              name: e.id,
+              description: e.content,
+              score: Math.round(e.score * 10) / 10,
+              breakdown: e.breakdown
+            })),
+            notes: notes.map((n) => ({
+              path: n.id,
+              snippet: n.content,
+              score: Math.round(n.score * 10) / 10
+            })),
+            memories: memories.map((m) => ({
+              key: m.id,
+              value: m.content,
+              score: Math.round(m.score * 10) / 10
+            }))
+          }, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+// src/tools/read/brief.ts
+import { z as z25 } from "zod";
+
+// src/core/shared/toolTracking.ts
+function recordToolInvocation(stateDb2, event) {
+  stateDb2.db.prepare(
+    `INSERT INTO tool_invocations (timestamp, tool_name, session_id, note_paths, duration_ms, success)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(
+    Date.now(),
+    event.tool_name,
+    event.session_id ?? null,
+    event.note_paths ? JSON.stringify(event.note_paths) : null,
+    event.duration_ms ?? null,
+    event.success !== false ? 1 : 0
+  );
+}
+function rowToInvocation(row) {
+  return {
+    id: row.id,
+    timestamp: row.timestamp,
+    tool_name: row.tool_name,
+    session_id: row.session_id,
+    note_paths: row.note_paths ? JSON.parse(row.note_paths) : null,
+    duration_ms: row.duration_ms,
+    success: row.success === 1
+  };
+}
+function getToolUsageSummary(stateDb2, daysBack = 30) {
+  const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
+  const rows = stateDb2.db.prepare(`
+    SELECT
+      tool_name,
+      COUNT(*) as invocation_count,
+      AVG(duration_ms) as avg_duration_ms,
+      SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) * 1.0 / COUNT(*) as success_rate,
+      MAX(timestamp) as last_used
+    FROM tool_invocations
+    WHERE timestamp >= ?
+    GROUP BY tool_name
+    ORDER BY invocation_count DESC
+  `).all(cutoff);
+  return rows.map((r) => ({
+    tool_name: r.tool_name,
+    invocation_count: r.invocation_count,
+    avg_duration_ms: Math.round(r.avg_duration_ms ?? 0),
+    success_rate: Math.round(r.success_rate * 1e3) / 1e3,
+    last_used: r.last_used
+  }));
+}
+function getNoteAccessFrequency(stateDb2, daysBack = 30) {
+  const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
+  const rows = stateDb2.db.prepare(`
+    SELECT note_paths, tool_name, timestamp
+    FROM tool_invocations
+    WHERE timestamp >= ? AND note_paths IS NOT NULL
+    ORDER BY timestamp DESC
+  `).all(cutoff);
+  const noteMap = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    let paths;
+    try {
+      paths = JSON.parse(row.note_paths);
+    } catch {
+      continue;
+    }
+    for (const p of paths) {
+      const existing = noteMap.get(p);
+      if (existing) {
+        existing.access_count++;
+        existing.last_accessed = Math.max(existing.last_accessed, row.timestamp);
+        existing.tools.add(row.tool_name);
+      } else {
+        noteMap.set(p, {
+          access_count: 1,
+          last_accessed: row.timestamp,
+          tools: /* @__PURE__ */ new Set([row.tool_name])
+        });
+      }
+    }
+  }
+  return Array.from(noteMap.entries()).map(([path33, stats]) => ({
+    path: path33,
+    access_count: stats.access_count,
+    last_accessed: stats.last_accessed,
+    tools_used: Array.from(stats.tools)
+  })).sort((a, b) => b.access_count - a.access_count);
+}
+function getSessionHistory(stateDb2, sessionId) {
+  if (sessionId) {
+    const rows2 = stateDb2.db.prepare(`
+      SELECT * FROM tool_invocations
+      WHERE session_id = ?
+      ORDER BY timestamp
+    `).all(sessionId);
+    if (rows2.length === 0) return [];
+    const tools = /* @__PURE__ */ new Set();
+    const notes = /* @__PURE__ */ new Set();
+    for (const row of rows2) {
+      tools.add(row.tool_name);
+      if (row.note_paths) {
+        try {
+          for (const p of JSON.parse(row.note_paths)) {
+            notes.add(p);
+          }
+        } catch {
+        }
+      }
+    }
+    return [{
+      session_id: sessionId,
+      started_at: rows2[0].timestamp,
+      last_activity: rows2[rows2.length - 1].timestamp,
+      tool_count: rows2.length,
+      unique_tools: Array.from(tools),
+      notes_accessed: Array.from(notes)
+    }];
+  }
+  const rows = stateDb2.db.prepare(`
+    SELECT
+      session_id,
+      MIN(timestamp) as started_at,
+      MAX(timestamp) as last_activity,
+      COUNT(*) as tool_count
+    FROM tool_invocations
+    WHERE session_id IS NOT NULL
+    GROUP BY session_id
+    ORDER BY last_activity DESC
+    LIMIT 20
+  `).all();
+  return rows.map((r) => ({
+    session_id: r.session_id,
+    started_at: r.started_at,
+    last_activity: r.last_activity,
+    tool_count: r.tool_count,
+    unique_tools: [],
+    notes_accessed: []
+  }));
+}
+function getRecentInvocations(stateDb2, limit = 20) {
+  const rows = stateDb2.db.prepare(
+    "SELECT * FROM tool_invocations ORDER BY timestamp DESC LIMIT ?"
+  ).all(limit);
+  return rows.map(rowToInvocation);
+}
+function purgeOldInvocations(stateDb2, retentionDays = 90) {
+  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+  const result = stateDb2.db.prepare(
+    "DELETE FROM tool_invocations WHERE timestamp < ?"
+  ).run(cutoff);
+  return result.changes;
+}
+
+// src/tools/read/brief.ts
+function estimateTokens2(value) {
+  const str = JSON.stringify(value);
+  return Math.ceil(str.length / 4);
+}
+function buildSessionSection(stateDb2, limit) {
+  const summaries = getRecentSessionSummaries(stateDb2, limit);
+  if (summaries.length > 0) {
+    const content2 = summaries.map((s) => ({
+      session_id: s.session_id,
+      summary: s.summary,
+      topics: s.topics_json ? JSON.parse(s.topics_json) : [],
+      ended_at: s.ended_at,
+      tool_count: s.tool_count
+    }));
+    return {
+      name: "recent_sessions",
+      priority: 1,
+      content: content2,
+      estimated_tokens: estimateTokens2(content2)
+    };
+  }
+  const sessions = getSessionHistory(stateDb2);
+  const recentSessions = sessions.slice(0, limit);
+  if (recentSessions.length === 0) {
+    return { name: "recent_sessions", priority: 1, content: [], estimated_tokens: 0 };
+  }
+  const content = recentSessions.map((s) => ({
+    session_id: s.session_id,
+    started_at: s.started_at,
+    last_activity: s.last_activity,
+    tool_count: s.tool_count,
+    tools_used: s.unique_tools
+  }));
+  return {
+    name: "recent_sessions",
+    priority: 1,
+    content,
+    estimated_tokens: estimateTokens2(content)
+  };
+}
+function buildActiveEntitiesSection(stateDb2, limit) {
+  const rows = stateDb2.db.prepare(`
+    SELECT r.entity_name_lower, r.last_mentioned_at, r.mention_count,
+           e.name, e.category, e.description
+    FROM recency r
+    LEFT JOIN entities e ON e.name_lower = r.entity_name_lower
+    ORDER BY r.last_mentioned_at DESC
+    LIMIT ?
+  `).all(limit);
+  const content = rows.map((r) => ({
+    name: r.name || r.entity_name_lower,
+    category: r.category,
+    description: r.description,
+    last_mentioned: r.last_mentioned_at,
+    mentions: r.mention_count
+  }));
+  return {
+    name: "active_entities",
+    priority: 2,
+    content,
+    estimated_tokens: estimateTokens2(content)
+  };
+}
+function buildActiveMemoriesSection(stateDb2, limit) {
+  const memories = listMemories(stateDb2, { limit });
+  const content = memories.map((m) => ({
+    key: m.key,
+    value: m.value,
+    type: m.memory_type,
+    entity: m.entity,
+    confidence: m.confidence,
+    updated_at: m.updated_at
+  }));
+  return {
+    name: "active_memories",
+    priority: 3,
+    content,
+    estimated_tokens: estimateTokens2(content)
+  };
+}
+function buildCorrectionsSection(stateDb2, limit) {
+  const corrections = listCorrections(stateDb2, "pending", void 0, limit);
+  const content = corrections.map((c) => ({
+    id: c.id,
+    type: c.correction_type,
+    description: c.description,
+    entity: c.entity,
+    created_at: c.created_at
+  }));
+  return {
+    name: "pending_corrections",
+    priority: 4,
+    content,
+    estimated_tokens: estimateTokens2(content)
+  };
+}
+function buildVaultPulseSection(stateDb2) {
+  const now = Date.now();
+  const day = 864e5;
+  const recentToolCount = stateDb2.db.prepare(
+    "SELECT COUNT(*) as cnt FROM tool_invocations WHERE timestamp > ?"
+  ).get(now - day).cnt;
+  const entityCount = stateDb2.db.prepare(
+    "SELECT COUNT(*) as cnt FROM entities"
+  ).get().cnt;
+  const memoryCount = stateDb2.db.prepare(
+    "SELECT COUNT(*) as cnt FROM memories WHERE superseded_by IS NULL"
+  ).get().cnt;
+  let noteCount = 0;
+  try {
+    noteCount = stateDb2.db.prepare(
+      "SELECT COUNT(*) as cnt FROM notes_fts"
+    ).get().cnt;
+  } catch {
+  }
+  const contradictions = findContradictions2(stateDb2);
+  const content = {
+    notes: noteCount,
+    entities: entityCount,
+    memories: memoryCount,
+    tool_calls_24h: recentToolCount,
+    contradictions: contradictions.length
+  };
+  return {
+    name: "vault_pulse",
+    priority: 5,
+    content,
+    estimated_tokens: estimateTokens2(content)
+  };
+}
+function registerBriefTools(server2, getStateDb) {
+  server2.tool(
+    "brief",
+    "Get a startup context briefing: recent sessions, active entities, memories, pending corrections, and vault stats. Call at conversation start.",
+    {
+      max_tokens: z25.number().optional().describe("Token budget (lower-priority sections truncated first)"),
+      focus: z25.string().optional().describe("Focus entity or topic (filters content)"),
+      sections: z25.array(z25.enum(["recent_sessions", "active_entities", "active_memories", "pending_corrections", "vault_pulse"])).optional().describe("Which sections to include (default: all)")
+    },
+    async (args) => {
+      const stateDb2 = getStateDb();
+      if (!stateDb2) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }],
+          isError: true
+        };
+      }
+      const requestedSections = args.sections ? new Set(args.sections) : /* @__PURE__ */ new Set(["recent_sessions", "active_entities", "active_memories", "pending_corrections", "vault_pulse"]);
+      const sections = [];
+      if (requestedSections.has("recent_sessions")) {
+        sections.push(buildSessionSection(stateDb2, 5));
+      }
+      if (requestedSections.has("active_entities")) {
+        sections.push(buildActiveEntitiesSection(stateDb2, 10));
+      }
+      if (requestedSections.has("active_memories")) {
+        sections.push(buildActiveMemoriesSection(stateDb2, 20));
+      }
+      if (requestedSections.has("pending_corrections")) {
+        sections.push(buildCorrectionsSection(stateDb2, 10));
+      }
+      if (requestedSections.has("vault_pulse")) {
+        sections.push(buildVaultPulseSection(stateDb2));
+      }
+      if (args.max_tokens) {
+        let totalTokens2 = 0;
+        sections.sort((a, b) => a.priority - b.priority);
+        for (const section of sections) {
+          totalTokens2 += section.estimated_tokens;
+          if (totalTokens2 > args.max_tokens) {
+            if (Array.isArray(section.content)) {
+              const remaining = Math.max(0, args.max_tokens - (totalTokens2 - section.estimated_tokens));
+              const itemTokens = section.estimated_tokens / Math.max(1, section.content.length);
+              const keepCount = Math.max(1, Math.floor(remaining / itemTokens));
+              section.content = section.content.slice(0, keepCount);
+              section.estimated_tokens = estimateTokens2(section.content);
+            }
+          }
+        }
+      }
+      const response = {};
+      let totalTokens = 0;
+      for (const section of sections) {
+        response[section.name] = section.content;
+        totalTokens += section.estimated_tokens;
+      }
+      response._meta = { total_estimated_tokens: totalTokens };
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(response, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+// src/tools/write/config.ts
+import { z as z26 } 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: z26.enum(["get", "set"]).describe("Operation mode"),
+        key: z26.string().optional().describe("Config key to update (required for set mode)"),
+        value: z26.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/write/enrich.ts
+import { z as z27 } from "zod";
+import * as fs29 from "fs/promises";
+import * as path30 from "path";
+function hasSkipWikilinks(content) {
+  if (!content.startsWith("---")) return false;
+  const endIndex = content.indexOf("\n---", 3);
+  if (endIndex === -1) return false;
+  const frontmatter = content.substring(4, endIndex);
+  return /^skipWikilinks:\s*true\s*$/m.test(frontmatter);
+}
+async function collectMarkdownFiles(dirPath, basePath, excludeFolders) {
+  const results = [];
+  try {
+    const entries = await fs29.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const fullPath = path30.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        if (excludeFolders.some((f) => entry.name.toLowerCase() === f.toLowerCase())) continue;
+        const sub = await collectMarkdownFiles(fullPath, basePath, excludeFolders);
+        results.push(...sub);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        results.push(path30.relative(basePath, fullPath));
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+var EXCLUDE_FOLDERS = [
+  "daily-notes",
+  "daily",
+  "weekly",
+  "weekly-notes",
+  "monthly",
+  "monthly-notes",
+  "quarterly",
+  "yearly-notes",
+  "periodic",
+  "journal",
+  "inbox",
+  "templates",
+  "attachments",
   "tmp",
   "clippings",
   "readwise",
@@ -16495,9 +17658,9 @@ function registerInitTools(server2, vaultPath2, getStateDb) {
     "vault_init",
     "Initialize vault for Flywheel \u2014 scans legacy notes with zero wikilinks and applies entity links. Safe to re-run (idempotent). Use dry_run (default) to preview.",
     {
-      dry_run: z24.boolean().default(true).describe("If true (default), preview what would be linked without modifying files"),
-      batch_size: z24.number().default(50).describe("Maximum notes to process per invocation (default: 50)"),
-      offset: z24.number().default(0).describe("Skip this many eligible notes (for pagination across invocations)")
+      dry_run: z27.boolean().default(true).describe("If true (default), preview what would be linked without modifying files"),
+      batch_size: z27.number().default(50).describe("Maximum notes to process per invocation (default: 50)"),
+      offset: z27.number().default(0).describe("Skip this many eligible notes (for pagination across invocations)")
     },
     async ({ dry_run, batch_size, offset }) => {
       const startTime = Date.now();
@@ -16592,7 +17755,7 @@ function registerInitTools(server2, vaultPath2, getStateDb) {
 }
 
 // src/tools/read/metrics.ts
-import { z as z25 } from "zod";
+import { z as z28 } from "zod";
 
 // src/core/shared/metrics.ts
 var ALL_METRICS = [
@@ -16758,10 +17921,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: z25.enum(["current", "history", "trends", "index_activity"]).describe("Query mode: current snapshot, historical time series, trend analysis, or index rebuild activity"),
-        metric: z25.string().optional().describe('Filter to specific metric (e.g., "note_count"). Omit for all metrics.'),
-        days_back: z25.number().optional().describe("Number of days to look back for history/trends (default: 30)"),
-        limit: z25.number().optional().describe("Number of recent events to return for index_activity mode (default: 20)")
+        mode: z28.enum(["current", "history", "trends", "index_activity"]).describe("Query mode: current snapshot, historical time series, trend analysis, or index rebuild activity"),
+        metric: z28.string().optional().describe('Filter to specific metric (e.g., "note_count"). Omit for all metrics.'),
+        days_back: z28.number().optional().describe("Number of days to look back for history/trends (default: 30)"),
+        limit: z28.number().optional().describe("Number of recent events to return for index_activity mode (default: 20)")
       }
     },
     async ({ mode, metric, days_back, limit: eventLimit }) => {
@@ -16834,159 +17997,7 @@ function registerMetricsTools(server2, getIndex, getStateDb) {
 }
 
 // src/tools/read/activity.ts
-import { z as z26 } from "zod";
-
-// src/core/shared/toolTracking.ts
-function recordToolInvocation(stateDb2, event) {
-  stateDb2.db.prepare(
-    `INSERT INTO tool_invocations (timestamp, tool_name, session_id, note_paths, duration_ms, success)
-     VALUES (?, ?, ?, ?, ?, ?)`
-  ).run(
-    Date.now(),
-    event.tool_name,
-    event.session_id ?? null,
-    event.note_paths ? JSON.stringify(event.note_paths) : null,
-    event.duration_ms ?? null,
-    event.success !== false ? 1 : 0
-  );
-}
-function rowToInvocation(row) {
-  return {
-    id: row.id,
-    timestamp: row.timestamp,
-    tool_name: row.tool_name,
-    session_id: row.session_id,
-    note_paths: row.note_paths ? JSON.parse(row.note_paths) : null,
-    duration_ms: row.duration_ms,
-    success: row.success === 1
-  };
-}
-function getToolUsageSummary(stateDb2, daysBack = 30) {
-  const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
-  const rows = stateDb2.db.prepare(`
-    SELECT
-      tool_name,
-      COUNT(*) as invocation_count,
-      AVG(duration_ms) as avg_duration_ms,
-      SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) * 1.0 / COUNT(*) as success_rate,
-      MAX(timestamp) as last_used
-    FROM tool_invocations
-    WHERE timestamp >= ?
-    GROUP BY tool_name
-    ORDER BY invocation_count DESC
-  `).all(cutoff);
-  return rows.map((r) => ({
-    tool_name: r.tool_name,
-    invocation_count: r.invocation_count,
-    avg_duration_ms: Math.round(r.avg_duration_ms ?? 0),
-    success_rate: Math.round(r.success_rate * 1e3) / 1e3,
-    last_used: r.last_used
-  }));
-}
-function getNoteAccessFrequency(stateDb2, daysBack = 30) {
-  const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
-  const rows = stateDb2.db.prepare(`
-    SELECT note_paths, tool_name, timestamp
-    FROM tool_invocations
-    WHERE timestamp >= ? AND note_paths IS NOT NULL
-    ORDER BY timestamp DESC
-  `).all(cutoff);
-  const noteMap = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    let paths;
-    try {
-      paths = JSON.parse(row.note_paths);
-    } catch {
-      continue;
-    }
-    for (const p of paths) {
-      const existing = noteMap.get(p);
-      if (existing) {
-        existing.access_count++;
-        existing.last_accessed = Math.max(existing.last_accessed, row.timestamp);
-        existing.tools.add(row.tool_name);
-      } else {
-        noteMap.set(p, {
-          access_count: 1,
-          last_accessed: row.timestamp,
-          tools: /* @__PURE__ */ new Set([row.tool_name])
-        });
-      }
-    }
-  }
-  return Array.from(noteMap.entries()).map(([path33, stats]) => ({
-    path: path33,
-    access_count: stats.access_count,
-    last_accessed: stats.last_accessed,
-    tools_used: Array.from(stats.tools)
-  })).sort((a, b) => b.access_count - a.access_count);
-}
-function getSessionHistory(stateDb2, sessionId) {
-  if (sessionId) {
-    const rows2 = stateDb2.db.prepare(`
-      SELECT * FROM tool_invocations
-      WHERE session_id = ?
-      ORDER BY timestamp
-    `).all(sessionId);
-    if (rows2.length === 0) return [];
-    const tools = /* @__PURE__ */ new Set();
-    const notes = /* @__PURE__ */ new Set();
-    for (const row of rows2) {
-      tools.add(row.tool_name);
-      if (row.note_paths) {
-        try {
-          for (const p of JSON.parse(row.note_paths)) {
-            notes.add(p);
-          }
-        } catch {
-        }
-      }
-    }
-    return [{
-      session_id: sessionId,
-      started_at: rows2[0].timestamp,
-      last_activity: rows2[rows2.length - 1].timestamp,
-      tool_count: rows2.length,
-      unique_tools: Array.from(tools),
-      notes_accessed: Array.from(notes)
-    }];
-  }
-  const rows = stateDb2.db.prepare(`
-    SELECT
-      session_id,
-      MIN(timestamp) as started_at,
-      MAX(timestamp) as last_activity,
-      COUNT(*) as tool_count
-    FROM tool_invocations
-    WHERE session_id IS NOT NULL
-    GROUP BY session_id
-    ORDER BY last_activity DESC
-    LIMIT 20
-  `).all();
-  return rows.map((r) => ({
-    session_id: r.session_id,
-    started_at: r.started_at,
-    last_activity: r.last_activity,
-    tool_count: r.tool_count,
-    unique_tools: [],
-    notes_accessed: []
-  }));
-}
-function getRecentInvocations(stateDb2, limit = 20) {
-  const rows = stateDb2.db.prepare(
-    "SELECT * FROM tool_invocations ORDER BY timestamp DESC LIMIT ?"
-  ).all(limit);
-  return rows.map(rowToInvocation);
-}
-function purgeOldInvocations(stateDb2, retentionDays = 90) {
-  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
-  const result = stateDb2.db.prepare(
-    "DELETE FROM tool_invocations WHERE timestamp < ?"
-  ).run(cutoff);
-  return result.changes;
-}
-
-// src/tools/read/activity.ts
+import { z as z29 } from "zod";
 function registerActivityTools(server2, getStateDb, getSessionId2) {
   server2.registerTool(
     "vault_activity",
@@ -16994,10 +18005,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: z26.enum(["session", "sessions", "note_access", "tool_usage"]).describe("Activity query mode"),
-        session_id: z26.string().optional().describe("Specific session ID (for session mode, defaults to current)"),
-        days_back: z26.number().optional().describe("Number of days to look back (default: 30)"),
-        limit: z26.number().optional().describe("Maximum results to return (default: 20)")
+        mode: z29.enum(["session", "sessions", "note_access", "tool_usage"]).describe("Activity query mode"),
+        session_id: z29.string().optional().describe("Specific session ID (for session mode, defaults to current)"),
+        days_back: z29.number().optional().describe("Number of days to look back (default: 30)"),
+        limit: z29.number().optional().describe("Maximum results to return (default: 20)")
       }
     },
     async ({ mode, session_id, days_back, limit: resultLimit }) => {
@@ -17064,7 +18075,7 @@ function registerActivityTools(server2, getStateDb, getSessionId2) {
 }
 
 // src/tools/read/similarity.ts
-import { z as z27 } from "zod";
+import { z as z30 } from "zod";
 
 // src/core/read/similarity.ts
 import * as fs30 from "fs";
@@ -17328,9 +18339,9 @@ 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: z27.string().describe('Path to the source note (relative to vault root, e.g. "projects/alpha.md")'),
-        limit: z27.number().optional().describe("Maximum number of similar notes to return (default: 10)"),
-        exclude_linked: z27.boolean().optional().describe("Exclude notes already linked to/from the source note (default: true)")
+        path: z30.string().describe('Path to the source note (relative to vault root, e.g. "projects/alpha.md")'),
+        limit: z30.number().optional().describe("Maximum number of similar notes to return (default: 10)"),
+        exclude_linked: z30.boolean().optional().describe("Exclude notes already linked to/from the source note (default: true)")
       }
     },
     async ({ path: path33, limit, exclude_linked }) => {
@@ -17374,7 +18385,7 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
 }
 
 // src/tools/read/semantic.ts
-import { z as z28 } from "zod";
+import { z as z31 } from "zod";
 import { getAllEntitiesFromDb } from "@velvetmonkey/vault-core";
 function registerSemanticTools(server2, getVaultPath, getStateDb) {
   server2.registerTool(
@@ -17383,7 +18394,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: z28.boolean().optional().describe(
+        force: z31.boolean().optional().describe(
           "Rebuild all embeddings even if they already exist (default: false)"
         )
       }
@@ -17463,7 +18474,7 @@ function registerSemanticTools(server2, getVaultPath, getStateDb) {
 
 // src/tools/read/merges.ts
 init_levenshtein();
-import { z as z29 } from "zod";
+import { z as z32 } from "zod";
 import { getAllEntitiesFromDb as getAllEntitiesFromDb2, getDismissedMergePairs, recordMergeDismissal } from "@velvetmonkey/vault-core";
 function normalizeName(name) {
   return name.toLowerCase().replace(/[.\-_]/g, "").replace(/js$/, "").replace(/ts$/, "");
@@ -17473,7 +18484,7 @@ function registerMergeTools2(server2, getStateDb) {
     "suggest_entity_merges",
     "Find potential duplicate entities that could be merged based on name similarity",
     {
-      limit: z29.number().optional().default(50).describe("Maximum number of suggestions to return")
+      limit: z32.number().optional().default(50).describe("Maximum number of suggestions to return")
     },
     async ({ limit }) => {
       const stateDb2 = getStateDb();
@@ -17575,11 +18586,11 @@ function registerMergeTools2(server2, getStateDb) {
     "dismiss_merge_suggestion",
     "Permanently dismiss a merge suggestion so it never reappears",
     {
-      source_path: z29.string().describe("Path of the source entity"),
-      target_path: z29.string().describe("Path of the target entity"),
-      source_name: z29.string().describe("Name of the source entity"),
-      target_name: z29.string().describe("Name of the target entity"),
-      reason: z29.string().describe("Original suggestion reason")
+      source_path: z32.string().describe("Path of the source entity"),
+      target_path: z32.string().describe("Path of the target entity"),
+      source_name: z32.string().describe("Name of the source entity"),
+      target_name: z32.string().describe("Name of the target entity"),
+      reason: z32.string().describe("Original suggestion reason")
     },
     async ({ source_path, target_path, source_name, target_name, reason }) => {
       const stateDb2 = getStateDb();
@@ -17740,8 +18751,10 @@ var PRESETS = {
     "frontmatter",
     "notes",
     "git",
-    "policy"
+    "policy",
+    "memory"
   ],
+  agent: ["search", "structure", "append", "frontmatter", "notes", "memory"],
   // Composable bundles
   graph: ["backlinks", "orphans", "hubs", "paths"],
   analysis: ["schema", "wikilinks"],
@@ -17764,7 +18777,8 @@ var ALL_CATEGORIES = [
   "frontmatter",
   "notes",
   "git",
-  "policy"
+  "policy",
+  "memory"
 ];
 var DEFAULT_PRESET = "full";
 function parseEnabledCategories() {
@@ -17868,7 +18882,11 @@ var TOOL_CATEGORY = {
   suggest_entity_merges: "health",
   dismiss_merge_suggestion: "health",
   // notes (entity merge)
-  merge_entities: "notes"
+  merge_entities: "notes",
+  // memory (agent working memory)
+  memory: "memory",
+  recall: "memory",
+  brief: "memory"
 };
 var server = new McpServer({
   name: "flywheel-memory",
@@ -18000,6 +19018,9 @@ registerActivityTools(server, () => stateDb, () => {
 registerSimilarityTools(server, () => vaultIndex, () => vaultPath, () => stateDb);
 registerSemanticTools(server, () => vaultPath, () => stateDb);
 registerMergeTools2(server, () => stateDb);
+registerMemoryTools(server, () => stateDb);
+registerRecallTools(server, () => stateDb);
+registerBriefTools(server, () => stateDb);
 registerVaultResources(server, () => vaultIndex ?? null);
 serverLog("server", `Registered ${_registeredCount} tools, skipped ${_skippedCount}`);
 async function main() {
@@ -18017,6 +19038,12 @@ async function main() {
     setWriteStateDb(stateDb);
     setRecencyStateDb(stateDb);
     setEdgeWeightStateDb(stateDb);
+    const cachedCooc = loadCooccurrenceFromStateDb(stateDb);
+    if (cachedCooc) {
+      setCooccurrenceIndex(cachedCooc.index);
+      lastCooccurrenceRebuildAt = cachedCooc.builtAt;
+      serverLog("index", `Co-occurrence: loaded from cache (${Object.keys(cachedCooc.index.associations).length} entities, ${cachedCooc.index._metadata.total_associations} associations)`);
+    }
     const vaultInitRow = stateDb.getMetadataValue.get("vault_init_last_run_at");
     if (!vaultInitRow) {
       serverLog("server", "Vault not initialized \u2014 call vault_init to enrich legacy notes");
@@ -18245,6 +19272,7 @@ async function runPostIndexWork(index) {
           }
         }
         loadEntityEmbeddingsToMemory();
+        setEmbeddingsBuildState("complete");
         serverLog("semantic", "Embeddings ready");
       }).catch((err) => {
         serverLog("semantic", `Embeddings build failed: ${err instanceof Error ? err.message : err}`, "error");
@@ -18430,17 +19458,22 @@ async function runPostIndexWork(index) {
         tracker.end({ entity_count: entitiesAfter.length, ...entityDiff, category_changes: categoryChanges, description_changes: descriptionChanges });
         serverLog("watcher", `Entity scan: ${entitiesAfter.length} entities`);
         tracker.start("hub_scores", { entity_count: entitiesAfter.length });
-        const hubUpdated = await exportHubScores(vaultIndex, stateDb);
-        const hubDiffs = [];
-        if (stateDb) {
-          const rows = stateDb.db.prepare("SELECT name, hub_score FROM entities").all();
-          for (const r of rows) {
-            const prev = hubBefore.get(r.name) ?? 0;
-            if (prev !== r.hub_score) hubDiffs.push({ entity: r.name, before: prev, after: r.hub_score });
+        try {
+          const hubUpdated = await exportHubScores(vaultIndex, stateDb);
+          const hubDiffs = [];
+          if (stateDb) {
+            const rows = stateDb.db.prepare("SELECT name, hub_score FROM entities").all();
+            for (const r of rows) {
+              const prev = hubBefore.get(r.name) ?? 0;
+              if (prev !== r.hub_score) hubDiffs.push({ entity: r.name, before: prev, after: r.hub_score });
+            }
           }
+          tracker.end({ updated: hubUpdated ?? 0, diffs: hubDiffs.slice(0, 10) });
+          serverLog("watcher", `Hub scores: ${hubUpdated ?? 0} updated`);
+        } catch (e) {
+          tracker.end({ error: String(e) });
+          serverLog("watcher", `Hub scores: failed: ${e}`, "error");
         }
-        tracker.end({ updated: hubUpdated ?? 0, diffs: hubDiffs.slice(0, 10) });
-        serverLog("watcher", `Hub scores: ${hubUpdated ?? 0} updated`);
         tracker.start("recency", { entity_count: entitiesAfter.length });
         try {
           const cachedRecency = loadRecencyFromStateDb();
@@ -18467,6 +19500,9 @@ async function runPostIndexWork(index) {
             const cooccurrenceIdx = await mineCooccurrences(vaultPath, entityNames);
             setCooccurrenceIndex(cooccurrenceIdx);
             lastCooccurrenceRebuildAt = Date.now();
+            if (stateDb) {
+              saveCooccurrenceToStateDb(stateDb, cooccurrenceIdx);
+            }
             tracker.end({ rebuilt: true, associations: cooccurrenceIdx._metadata.total_associations });
             serverLog("watcher", `Co-occurrence: rebuilt ${cooccurrenceIdx._metadata.total_associations} associations`);
           } else {
@@ -18582,87 +19618,99 @@ async function runPostIndexWork(index) {
         }
         tracker.end({ updated: taskUpdated, removed: taskRemoved });
         serverLog("watcher", `Task cache: ${taskUpdated} updated, ${taskRemoved} removed`);
-        tracker.start("forward_links", { files: filteredEvents.length });
-        const eventTypeMap = new Map(filteredEvents.map((e) => [e.path, e.type]));
         const forwardLinkResults = [];
         let totalResolved = 0;
         let totalDead = 0;
-        for (const event of filteredEvents) {
-          if (event.type === "delete" || !event.path.endsWith(".md")) continue;
-          try {
-            const links = getForwardLinksForNote(vaultIndex, event.path);
-            const resolved = [];
-            const dead = [];
-            const seen = /* @__PURE__ */ new Set();
-            for (const link of links) {
-              const name = link.target;
-              if (seen.has(name.toLowerCase())) continue;
-              seen.add(name.toLowerCase());
-              if (link.exists) resolved.push(name);
-              else dead.push(name);
-            }
-            if (resolved.length > 0 || dead.length > 0) {
-              forwardLinkResults.push({ file: event.path, resolved, dead });
-            }
-            totalResolved += resolved.length;
-            totalDead += dead.length;
-          } catch {
-          }
-        }
         const linkDiffs = [];
         const survivedLinks = [];
-        if (stateDb) {
-          const upsertHistory = stateDb.db.prepare(`
+        tracker.start("forward_links", { files: filteredEvents.length });
+        try {
+          const eventTypeMap = new Map(filteredEvents.map((e) => [e.path, e.type]));
+          for (const event of filteredEvents) {
+            if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+            try {
+              const links = getForwardLinksForNote(vaultIndex, event.path);
+              const resolved = [];
+              const dead = [];
+              const seen = /* @__PURE__ */ new Set();
+              for (const link of links) {
+                const name = link.target;
+                if (seen.has(name.toLowerCase())) continue;
+                seen.add(name.toLowerCase());
+                if (link.exists) resolved.push(name);
+                else dead.push(name);
+              }
+              if (resolved.length > 0 || dead.length > 0) {
+                forwardLinkResults.push({ file: event.path, resolved, dead });
+              }
+              totalResolved += resolved.length;
+              totalDead += dead.length;
+            } catch {
+            }
+          }
+          if (stateDb) {
+            const upsertHistory = stateDb.db.prepare(`
               INSERT INTO note_link_history (note_path, target) VALUES (?, ?)
               ON CONFLICT(note_path, target) DO UPDATE SET edits_survived = edits_survived + 1
             `);
-          const checkThreshold = stateDb.db.prepare(`
+            const checkThreshold = stateDb.db.prepare(`
               SELECT target FROM note_link_history
               WHERE note_path = ? AND target = ? AND edits_survived >= 3 AND last_positive_at IS NULL
             `);
-          const markPositive = stateDb.db.prepare(`
+            const markPositive = stateDb.db.prepare(`
               UPDATE note_link_history SET last_positive_at = datetime('now') WHERE note_path = ? AND target = ?
             `);
-          const getEdgeCount = stateDb.db.prepare(
-            "SELECT edits_survived FROM note_link_history WHERE note_path=? AND target=?"
-          );
-          for (const entry of forwardLinkResults) {
-            const currentSet = /* @__PURE__ */ new Set([
-              ...entry.resolved.map((n) => n.toLowerCase()),
-              ...entry.dead.map((n) => n.toLowerCase())
-            ]);
-            const previousSet = getStoredNoteLinks(stateDb, entry.file);
-            if (previousSet.size === 0) {
+            const getEdgeCount = stateDb.db.prepare(
+              "SELECT edits_survived FROM note_link_history WHERE note_path=? AND target=?"
+            );
+            for (const entry of forwardLinkResults) {
+              const currentSet = /* @__PURE__ */ new Set([
+                ...entry.resolved.map((n) => n.toLowerCase()),
+                ...entry.dead.map((n) => n.toLowerCase())
+              ]);
+              const previousSet = getStoredNoteLinks(stateDb, entry.file);
+              if (previousSet.size === 0) {
+                updateStoredNoteLinks(stateDb, entry.file, currentSet);
+                continue;
+              }
+              const diff = diffNoteLinks(previousSet, currentSet);
+              if (diff.added.length > 0 || diff.removed.length > 0) {
+                linkDiffs.push({ file: entry.file, ...diff });
+              }
               updateStoredNoteLinks(stateDb, entry.file, currentSet);
-              continue;
-            }
-            const diff = diffNoteLinks(previousSet, currentSet);
-            if (diff.added.length > 0 || diff.removed.length > 0) {
-              linkDiffs.push({ file: entry.file, ...diff });
-            }
-            updateStoredNoteLinks(stateDb, entry.file, currentSet);
-            if (diff.removed.length === 0) continue;
-            for (const link of currentSet) {
-              if (!previousSet.has(link)) continue;
-              upsertHistory.run(entry.file, link);
-              const countRow = getEdgeCount.get(entry.file, link);
-              if (countRow) {
-                survivedLinks.push({ entity: link, file: entry.file, count: countRow.edits_survived });
+              if (diff.removed.length === 0) continue;
+              for (const link of currentSet) {
+                if (!previousSet.has(link)) continue;
+                upsertHistory.run(entry.file, link);
+                const countRow = getEdgeCount.get(entry.file, link);
+                if (countRow) {
+                  survivedLinks.push({ entity: link, file: entry.file, count: countRow.edits_survived });
+                }
+                const hit = checkThreshold.get(entry.file, link);
+                if (hit) {
+                  const entity = entitiesAfter.find(
+                    (e) => e.nameLower === link || (e.aliases ?? []).some((a) => a.toLowerCase() === link)
+                  );
+                  if (entity) {
+                    recordFeedback(stateDb, entity.name, "implicit:kept", entry.file, true, 0.8);
+                    markPositive.run(entry.file, link);
+                  }
+                }
               }
-              const hit = checkThreshold.get(entry.file, link);
-              if (hit) {
-                const entity = entitiesAfter.find(
-                  (e) => e.nameLower === link || (e.aliases ?? []).some((a) => a.toLowerCase() === link)
-                );
-                if (entity) {
-                  recordFeedback(stateDb, entity.name, "implicit:kept", entry.file, true, 0.8);
-                  markPositive.run(entry.file, link);
+            }
+            for (const event of filteredEvents) {
+              if (event.type === "delete") {
+                const previousSet = getStoredNoteLinks(stateDb, event.path);
+                if (previousSet.size > 0) {
+                  linkDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
+                  updateStoredNoteLinks(stateDb, event.path, /* @__PURE__ */ new Set());
                 }
               }
             }
-          }
-          for (const event of filteredEvents) {
-            if (event.type === "delete") {
+            const processedFiles = new Set(forwardLinkResults.map((r) => r.file));
+            for (const event of filteredEvents) {
+              if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+              if (processedFiles.has(event.path)) continue;
               const previousSet = getStoredNoteLinks(stateDb, event.path);
               if (previousSet.size > 0) {
                 linkDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
@@ -18670,33 +19718,26 @@ async function runPostIndexWork(index) {
               }
             }
           }
-          const processedFiles = new Set(forwardLinkResults.map((r) => r.file));
-          for (const event of filteredEvents) {
-            if (event.type === "delete" || !event.path.endsWith(".md")) continue;
-            if (processedFiles.has(event.path)) continue;
-            const previousSet = getStoredNoteLinks(stateDb, event.path);
-            if (previousSet.size > 0) {
-              linkDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
-              updateStoredNoteLinks(stateDb, event.path, /* @__PURE__ */ new Set());
+          const newDeadLinks = [];
+          for (const diff of linkDiffs) {
+            const newDead = diff.added.filter((target) => !vaultIndex.entities.has(target.toLowerCase()));
+            if (newDead.length > 0) {
+              newDeadLinks.push({ file: diff.file, targets: newDead });
             }
           }
+          tracker.end({
+            total_resolved: totalResolved,
+            total_dead: totalDead,
+            links: forwardLinkResults,
+            link_diffs: linkDiffs,
+            survived: survivedLinks,
+            new_dead_links: newDeadLinks
+          });
+          serverLog("watcher", `Forward links: ${totalResolved} resolved, ${totalDead} dead${newDeadLinks.length > 0 ? `, ${newDeadLinks.reduce((s, d) => s + d.targets.length, 0)} new dead` : ""}`);
+        } catch (e) {
+          tracker.end({ error: String(e) });
+          serverLog("watcher", `Forward links: failed: ${e}`, "error");
         }
-        const newDeadLinks = [];
-        for (const diff of linkDiffs) {
-          const newDead = diff.added.filter((target) => !vaultIndex.entities.has(target.toLowerCase()));
-          if (newDead.length > 0) {
-            newDeadLinks.push({ file: diff.file, targets: newDead });
-          }
-        }
-        tracker.end({
-          total_resolved: totalResolved,
-          total_dead: totalDead,
-          links: forwardLinkResults,
-          link_diffs: linkDiffs,
-          survived: survivedLinks,
-          new_dead_links: newDeadLinks
-        });
-        serverLog("watcher", `Forward links: ${totalResolved} resolved, ${totalDead} dead${newDeadLinks.length > 0 ? `, ${newDeadLinks.reduce((s, d) => s + d.targets.length, 0)} new dead` : ""}`);
         tracker.start("wikilink_check", { files: filteredEvents.length });
         const trackedLinks = [];
         if (stateDb) {
@@ -18821,6 +19862,24 @@ async function runPostIndexWork(index) {
         if (newlySuppressed.length > 0) {
           serverLog("watcher", `Suppression: ${newlySuppressed.length} entities newly suppressed: ${newlySuppressed.join(", ")}`);
         }
+        tracker.start("corrections", {});
+        try {
+          if (stateDb) {
+            const corrProcessed = processPendingCorrections(stateDb);
+            if (corrProcessed > 0) {
+              updateSuppressionList(stateDb);
+            }
+            tracker.end({ processed: corrProcessed });
+            if (corrProcessed > 0) {
+              serverLog("watcher", `Corrections: ${corrProcessed} processed`);
+            }
+          } else {
+            tracker.end({ skipped: true });
+          }
+        } catch (e) {
+          tracker.end({ error: String(e) });
+          serverLog("watcher", `Corrections: failed: ${e}`, "error");
+        }
         tracker.start("prospect_scan", { files: filteredEvents.length });
         const prospectResults = [];
         for (const event of filteredEvents) {
@@ -18884,45 +19943,50 @@ async function runPostIndexWork(index) {
           serverLog("watcher", `Suggestion scoring: ${suggestionResults.length} files scored`);
         }
         tracker.start("tag_scan", { files: filteredEvents.length });
-        const tagDiffs = [];
-        if (stateDb) {
-          const noteTagsForward = /* @__PURE__ */ new Map();
-          for (const [tag, paths] of vaultIndex.tags) {
-            for (const notePath of paths) {
-              if (!noteTagsForward.has(notePath)) noteTagsForward.set(notePath, /* @__PURE__ */ new Set());
-              noteTagsForward.get(notePath).add(tag);
+        try {
+          const tagDiffs = [];
+          if (stateDb) {
+            const noteTagsForward = /* @__PURE__ */ new Map();
+            for (const [tag, paths] of vaultIndex.tags) {
+              for (const notePath of paths) {
+                if (!noteTagsForward.has(notePath)) noteTagsForward.set(notePath, /* @__PURE__ */ new Set());
+                noteTagsForward.get(notePath).add(tag);
+              }
             }
-          }
-          for (const event of filteredEvents) {
-            if (event.type === "delete" || !event.path.endsWith(".md")) continue;
-            const currentSet = noteTagsForward.get(event.path) ?? /* @__PURE__ */ new Set();
-            const previousSet = getStoredNoteTags(stateDb, event.path);
-            if (previousSet.size === 0 && currentSet.size > 0) {
+            for (const event of filteredEvents) {
+              if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+              const currentSet = noteTagsForward.get(event.path) ?? /* @__PURE__ */ new Set();
+              const previousSet = getStoredNoteTags(stateDb, event.path);
+              if (previousSet.size === 0 && currentSet.size > 0) {
+                updateStoredNoteTags(stateDb, event.path, currentSet);
+                continue;
+              }
+              const added = [...currentSet].filter((t) => !previousSet.has(t));
+              const removed = [...previousSet].filter((t) => !currentSet.has(t));
+              if (added.length > 0 || removed.length > 0) {
+                tagDiffs.push({ file: event.path, added, removed });
+              }
               updateStoredNoteTags(stateDb, event.path, currentSet);
-              continue;
-            }
-            const added = [...currentSet].filter((t) => !previousSet.has(t));
-            const removed = [...previousSet].filter((t) => !currentSet.has(t));
-            if (added.length > 0 || removed.length > 0) {
-              tagDiffs.push({ file: event.path, added, removed });
             }
-            updateStoredNoteTags(stateDb, event.path, currentSet);
-          }
-          for (const event of filteredEvents) {
-            if (event.type === "delete") {
-              const previousSet = getStoredNoteTags(stateDb, event.path);
-              if (previousSet.size > 0) {
-                tagDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
-                updateStoredNoteTags(stateDb, event.path, /* @__PURE__ */ new Set());
+            for (const event of filteredEvents) {
+              if (event.type === "delete") {
+                const previousSet = getStoredNoteTags(stateDb, event.path);
+                if (previousSet.size > 0) {
+                  tagDiffs.push({ file: event.path, added: [], removed: [...previousSet] });
+                  updateStoredNoteTags(stateDb, event.path, /* @__PURE__ */ new Set());
+                }
               }
             }
           }
-        }
-        const totalTagsAdded = tagDiffs.reduce((s, d) => s + d.added.length, 0);
-        const totalTagsRemoved = tagDiffs.reduce((s, d) => s + d.removed.length, 0);
-        tracker.end({ total_added: totalTagsAdded, total_removed: totalTagsRemoved, tag_diffs: tagDiffs });
-        if (tagDiffs.length > 0) {
-          serverLog("watcher", `Tag scan: ${totalTagsAdded} added, ${totalTagsRemoved} removed across ${tagDiffs.length} files`);
+          const totalTagsAdded = tagDiffs.reduce((s, d) => s + d.added.length, 0);
+          const totalTagsRemoved = tagDiffs.reduce((s, d) => s + d.removed.length, 0);
+          tracker.end({ total_added: totalTagsAdded, total_removed: totalTagsRemoved, tag_diffs: tagDiffs });
+          if (tagDiffs.length > 0) {
+            serverLog("watcher", `Tag scan: ${totalTagsAdded} added, ${totalTagsRemoved} removed across ${tagDiffs.length} files`);
+          }
+        } catch (e) {
+          tracker.end({ error: String(e) });
+          serverLog("watcher", `Tag scan: failed: ${e}`, "error");
         }
         const duration = Date.now() - batchStart;
         if (stateDb) {