@velvetmonkey/flywheel-memory 2.0.50 → 2.0.51

package/dist/index.js

@@ -16390,8 +16390,1059 @@ function registerCorrectionTools(server2, getStateDb) {
   );
 }
 
+// src/tools/write/memory.ts
+import { z as z23 } from "zod";
+
+// 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 (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": {
+          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({
+                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 "search": {
+          if (!args.query) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "search requires query" }) }],
+              isError: true
+            };
+          }
+          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: "forget requires key" }) }],
+              isError: true
+            };
+          }
+          const deleted = forgetMemory(stateDb2, args.key);
+          return {
+            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/read/recall.ts
+import { z as z24 } from "zod";
+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;
+}
+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 = [];
+  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 {
+    }
+  }
+  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 z23 } from "zod";
+import { z as z26 } from "zod";
 import { saveFlywheelConfigToDb as saveFlywheelConfigToDb2 } from "@velvetmonkey/vault-core";
 function registerConfigTools(server2, getConfig, setConfig, getStateDb) {
   server2.registerTool(
@@ -16400,9 +17451,9 @@ function registerConfigTools(server2, getConfig, setConfig, getStateDb) {
       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)")
+        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 }) => {
@@ -16440,7 +17491,7 @@ function registerConfigTools(server2, getConfig, setConfig, getStateDb) {
 }
 
 // src/tools/write/enrich.ts
-import { z as z24 } from "zod";
+import { z as z27 } from "zod";
 import * as fs29 from "fs/promises";
 import * as path30 from "path";
 function hasSkipWikilinks(content) {
@@ -16495,9 +17546,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 +17643,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 +17809,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 +17885,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 +17893,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 +17963,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 +18227,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 +18273,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 +18282,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 +18362,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 +18372,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 +18474,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 +18639,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 +18665,8 @@ var ALL_CATEGORIES = [
   "frontmatter",
   "notes",
   "git",
-  "policy"
+  "policy",
+  "memory"
 ];
 var DEFAULT_PRESET = "full";
 function parseEnabledCategories() {
@@ -17868,7 +18770,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 +18906,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() {