@hasna/mementos 0.11.1 → 0.14.2

package/dist/mcp/index.js

@@ -1,13 +1,40 @@
 #!/usr/bin/env bun
 // @bun
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -912,6 +939,44 @@ CREATE INDEX IF NOT EXISTS idx_memory_embeddings_model ON memory_embeddings(mode
 
 PRAGMA foreign_keys = ON;
 INSERT OR IGNORE INTO _migrations (id) VALUES (29);
+`,
+    `
+ALTER TABLE memories ADD COLUMN when_to_use TEXT DEFAULT NULL;
+CREATE INDEX IF NOT EXISTS idx_memories_when_to_use ON memories(when_to_use) WHERE when_to_use IS NOT NULL;
+ALTER TABLE memory_versions ADD COLUMN when_to_use TEXT;
+INSERT OR IGNORE INTO _migrations (id) VALUES (30);
+`,
+    `
+CREATE TABLE IF NOT EXISTS tool_events (
+  id TEXT PRIMARY KEY,
+  tool_name TEXT NOT NULL,
+  action TEXT,
+  success INTEGER NOT NULL DEFAULT 1,
+  error_type TEXT CHECK(error_type IS NULL OR error_type IN ('timeout', 'permission', 'not_found', 'syntax', 'rate_limit', 'other')),
+  error_message TEXT,
+  tokens_used INTEGER,
+  latency_ms INTEGER,
+  context TEXT,
+  lesson TEXT,
+  when_to_use TEXT,
+  agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  session_id TEXT,
+  metadata TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_tool_events_tool_name ON tool_events(tool_name);
+CREATE INDEX IF NOT EXISTS idx_tool_events_agent ON tool_events(agent_id);
+CREATE INDEX IF NOT EXISTS idx_tool_events_project ON tool_events(project_id);
+CREATE INDEX IF NOT EXISTS idx_tool_events_success ON tool_events(success);
+CREATE INDEX IF NOT EXISTS idx_tool_events_created ON tool_events(created_at);
+INSERT OR IGNORE INTO _migrations (id) VALUES (31);
+`,
+    `
+ALTER TABLE memories ADD COLUMN sequence_group TEXT DEFAULT NULL;
+ALTER TABLE memories ADD COLUMN sequence_order INTEGER DEFAULT NULL;
+CREATE INDEX IF NOT EXISTS idx_memories_sequence_group ON memories(sequence_group) WHERE sequence_group IS NOT NULL;
+INSERT OR IGNORE INTO _migrations (id) VALUES (32);
 `
   ];
 });
@@ -1175,6 +1240,18 @@ var init_poisoning = __esm(() => {
 });
 
 // src/db/entity-memories.ts
+function parseEntityRow(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    type: row["type"],
+    description: row["description"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    project_id: row["project_id"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"]
+  };
+}
 function parseEntityMemoryRow(row) {
   return {
     entity_id: row["entity_id"],
@@ -1203,6 +1280,14 @@ function getMemoriesForEntity(entityId, db) {
        ORDER BY m.importance DESC, m.created_at DESC`).all(entityId);
   return rows.map(parseMemoryRow);
 }
+function getEntitiesForMemory(memoryId, db) {
+  const d = db || getDatabase();
+  const rows = d.query(`SELECT e.* FROM entities e
+       INNER JOIN entity_memories em ON em.entity_id = e.id
+       WHERE em.memory_id = ?
+       ORDER BY e.name ASC`).all(memoryId);
+  return rows.map(parseEntityRow);
+}
 function getEntityMemoryLinks(entityId, memoryId, db) {
   const d = db || getDatabase();
   const conditions = [];
@@ -1266,6 +1351,9 @@ function parseMemoryRow(row) {
     session_id: row["session_id"] || null,
     machine_id: row["machine_id"] || null,
     flag: row["flag"] || null,
+    when_to_use: row["when_to_use"] || null,
+    sequence_group: row["sequence_group"] || null,
+    sequence_order: row["sequence_order"] ?? null,
     content_type: row["content_type"] || "text",
     namespace: row["namespace"] || null,
     created_by_agent: row["created_by_agent"] || null,
@@ -1324,6 +1412,7 @@ function createMemory(input, dedupeMode = "merge", db) {
       d.run(`UPDATE memories SET
            value = ?, category = ?, summary = ?, tags = ?,
            importance = ?, metadata = ?, expires_at = ?,
+           when_to_use = ?,
            pinned = COALESCE(pinned, 0),
            version = version + 1, updated_at = ?
          WHERE id = ?`, [
@@ -1334,6 +1423,7 @@ function createMemory(input, dedupeMode = "merge", db) {
         input.importance ?? 5,
         metadataJson,
         expiresAt,
+        input.when_to_use || null,
         timestamp,
         existing.id
       ]);
@@ -1358,8 +1448,8 @@ function createMemory(input, dedupeMode = "merge", db) {
       return merged;
     }
   }
-  d.run(`INSERT INTO memories (id, key, value, category, scope, summary, tags, importance, source, status, pinned, agent_id, project_id, session_id, machine_id, namespace, created_by_agent, metadata, access_count, version, expires_at, valid_from, valid_until, ingested_at, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', 0, ?, ?, ?, ?, ?, ?, ?, 0, 1, ?, ?, ?, ?, ?, ?)`, [
+  d.run(`INSERT INTO memories (id, key, value, category, scope, summary, tags, importance, source, status, pinned, agent_id, project_id, session_id, machine_id, namespace, created_by_agent, when_to_use, sequence_group, sequence_order, metadata, access_count, version, expires_at, valid_from, valid_until, ingested_at, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 1, ?, ?, ?, ?, ?, ?)`, [
     id,
     input.key,
     input.value,
@@ -1375,6 +1465,9 @@ function createMemory(input, dedupeMode = "merge", db) {
     input.machine_id || null,
     input.namespace || null,
     input.agent_id || null,
+    input.when_to_use || null,
+    input.sequence_group || null,
+    input.sequence_order ?? null,
     metadataJson,
     expiresAt,
     input.metadata?.valid_from ?? timestamp,
@@ -1585,8 +1678,8 @@ function updateMemory(id, input, db) {
     throw new VersionConflictError(id, input.version, existing.version);
   }
   try {
-    d.run(`INSERT OR IGNORE INTO memory_versions (id, memory_id, version, value, importance, scope, category, tags, summary, pinned, status, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    d.run(`INSERT OR IGNORE INTO memory_versions (id, memory_id, version, value, importance, scope, category, tags, summary, pinned, status, when_to_use, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
       uuid(),
       existing.id,
       existing.version,
@@ -1598,6 +1691,7 @@ function updateMemory(id, input, db) {
       existing.summary,
       existing.pinned ? 1 : 0,
       existing.status,
+      existing.when_to_use || null,
       existing.updated_at
     ]);
   } catch {}
@@ -1643,6 +1737,10 @@ function updateMemory(id, input, db) {
     sets.push("flag = ?");
     params.push(input.flag ?? null);
   }
+  if (input.when_to_use !== undefined) {
+    sets.push("when_to_use = ?");
+    params.push(input.when_to_use ?? null);
+  }
   if (input.tags !== undefined) {
     sets.push("tags = ?");
     params.push(JSON.stringify(input.tags));
@@ -1806,7 +1904,7 @@ var init_memories = __esm(() => {
 var exports_entities = {};
 __export(exports_entities, {
   updateEntity: () => updateEntity,
-  parseEntityRow: () => parseEntityRow,
+  parseEntityRow: () => parseEntityRow2,
   mergeEntities: () => mergeEntities,
   listEntities: () => listEntities,
   graphTraverse: () => graphTraverse,
@@ -1816,7 +1914,7 @@ __export(exports_entities, {
   deleteEntity: () => deleteEntity,
   createEntity: () => createEntity
 });
-function parseEntityRow(row) {
+function parseEntityRow2(row) {
   return {
     id: row["id"],
     name: row["name"],
@@ -1876,7 +1974,7 @@ function getEntity(id, db) {
   const row = d.query("SELECT * FROM entities WHERE id = ?").get(id);
   if (!row)
     throw new EntityNotFoundError(id);
-  return parseEntityRow(row);
+  return parseEntityRow2(row);
 }
 function getEntityByName(name, type, projectId, db) {
   const d = db || getDatabase();
@@ -1894,7 +1992,7 @@ function getEntityByName(name, type, projectId, db) {
   const row = d.query(sql).get(...params);
   if (!row)
     return null;
-  return parseEntityRow(row);
+  return parseEntityRow2(row);
 }
 function listEntities(filter = {}, db) {
   const d = db || getDatabase();
@@ -1927,7 +2025,7 @@ function listEntities(filter = {}, db) {
     params.push(filter.offset);
   }
   const rows = d.query(sql).all(...params);
-  return rows.map(parseEntityRow);
+  return rows.map(parseEntityRow2);
 }
 function updateEntity(id, input, db) {
   const d = db || getDatabase();
@@ -2000,7 +2098,7 @@ function trigramSimilarity(a, b) {
 function findDuplicateEntities(threshold = 0.8, db) {
   const d = db || getDatabase();
   const entities = d.query("SELECT * FROM entities ORDER BY type, project_id, name").all();
-  const parsed = entities.map(parseEntityRow);
+  const parsed = entities.map(parseEntityRow2);
   const groups = new Map;
   for (const e of parsed) {
     const groupKey = `${e.type}:${e.project_id || ""}`;
@@ -2152,7 +2250,7 @@ function parseRelationRow(row) {
     created_at: row["created_at"]
   };
 }
-function parseEntityRow2(row) {
+function parseEntityRow3(row) {
   return {
     id: row["id"],
     name: row["name"],
@@ -2234,7 +2332,7 @@ function getEntityGraph(entityId, depth = 2, db) {
         WHERE g.depth < ?
       )
       SELECT DISTINCT e.* FROM entities e JOIN graph g ON e.id = g.id`).all(entityId, depth);
-  const entities = entityRows.map(parseEntityRow2);
+  const entities = entityRows.map(parseEntityRow3);
   const entityIds = new Set(entities.map((e) => e.id));
   if (entityIds.size === 0) {
     return { entities: [], relations: [] };
@@ -2267,7 +2365,7 @@ function findPath(fromEntityId, toEntityId, maxDepth = 5, db) {
   for (const id of ids) {
     const row = d.query("SELECT * FROM entities WHERE id = ?").get(id);
     if (row)
-      entities.push(parseEntityRow2(row));
+      entities.push(parseEntityRow3(row));
   }
   return entities.length > 0 ? entities : null;
 }
@@ -2940,6 +3038,262 @@ var init_search = __esm(() => {
   ]);
 });
 
+// src/lib/profile-synthesizer.ts
+var exports_profile_synthesizer = {};
+__export(exports_profile_synthesizer, {
+  synthesizeProfile: () => synthesizeProfile,
+  markProfileStale: () => markProfileStale,
+  getProfileKey: () => getProfileKey
+});
+function getProfileKey(scope, id) {
+  return `_profile_${scope}_${id}`;
+}
+async function synthesizeProfile(options) {
+  const scope = options.scope || (options.project_id ? "project" : options.agent_id ? "agent" : "global");
+  const id = options.project_id || options.agent_id || "global";
+  const profileKey = getProfileKey(scope, id);
+  if (!options.force_refresh) {
+    const cached = getMemoryByKey(profileKey, "shared", undefined, options.project_id);
+    if (cached) {
+      const age = Date.now() - new Date(cached.updated_at).getTime();
+      const maxAge = 24 * 60 * 60 * 1000;
+      const isStale = cached.metadata?.stale === true;
+      if (age < maxAge && !isStale) {
+        return { profile: cached.value, memory_count: 0, from_cache: true };
+      }
+    }
+  }
+  const prefMemories = listMemories({
+    category: "preference",
+    project_id: options.project_id,
+    status: "active",
+    limit: 30
+  });
+  const factMemories = listMemories({
+    category: "fact",
+    project_id: options.project_id,
+    status: "active",
+    limit: 30
+  });
+  const allMemories = [...prefMemories, ...factMemories];
+  if (allMemories.length === 0)
+    return null;
+  const apiKey = process.env["ANTHROPIC_API_KEY"];
+  if (!apiKey) {
+    const lines = allMemories.map((m) => `- ${m.key}: ${m.value}`).join(`
+`);
+    const fallbackProfile = `## Profile
+${lines}`;
+    saveProfile(profileKey, fallbackProfile, allMemories.length, options);
+    return { profile: fallbackProfile, memory_count: allMemories.length, from_cache: false };
+  }
+  try {
+    const memoryList = allMemories.sort((a, b) => b.importance - a.importance).map((m) => `[${m.category}] ${m.key}: ${m.value}`).join(`
+`);
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "claude-haiku-4-5-20251001",
+        max_tokens: 500,
+        system: PROFILE_PROMPT,
+        messages: [{ role: "user", content: `Synthesize a profile from these ${allMemories.length} memories:
+
+${memoryList}` }]
+      })
+    });
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    const profile = data.content?.[0]?.text?.trim();
+    if (!profile)
+      return null;
+    saveProfile(profileKey, profile, allMemories.length, options);
+    return { profile, memory_count: allMemories.length, from_cache: false };
+  } catch {
+    return null;
+  }
+}
+function saveProfile(key, value, memoryCount, options) {
+  try {
+    createMemory({
+      key,
+      value,
+      category: "fact",
+      scope: "shared",
+      importance: 10,
+      source: "auto",
+      tags: ["profile", "synthesized"],
+      when_to_use: "When needing to understand this agent's or project's preferences, style, and conventions",
+      metadata: { memory_count: memoryCount, synthesized_at: new Date().toISOString(), stale: false },
+      agent_id: options.agent_id,
+      project_id: options.project_id
+    });
+  } catch {}
+}
+function markProfileStale(projectId, _agentId) {
+  try {
+    const { getDatabase: getDatabase2 } = (init_database(), __toCommonJS(exports_database));
+    const db = getDatabase2();
+    db.run(`UPDATE memories SET metadata = json_set(COALESCE(metadata, '{}'), '$.stale', json('true'))
+       WHERE key LIKE '_profile_%' AND COALESCE(project_id, '') = ?`, [projectId || ""]);
+  } catch {}
+}
+var PROFILE_PROMPT = `You synthesize a coherent agent/project profile from individual preference and fact memories.
+
+Output a concise profile (200-300 words max) organized by:
+- **Stack & Tools**: Languages, frameworks, package managers, etc.
+- **Code Style**: Formatting, patterns, naming conventions
+- **Workflow**: Testing, deployment, git practices
+- **Communication**: Response style, verbosity, formatting preferences
+- **Key Facts**: Architecture decisions, constraints, team conventions
+
+Only include sections that have relevant data. Be specific and actionable.
+Output in markdown format.`;
+var init_profile_synthesizer = __esm(() => {
+  init_memories();
+});
+
+// src/db/tool-events.ts
+function parseToolEventRow(row) {
+  return {
+    id: row["id"],
+    tool_name: row["tool_name"],
+    action: row["action"] || null,
+    success: !!row["success"],
+    error_type: row["error_type"] || null,
+    error_message: row["error_message"] || null,
+    tokens_used: row["tokens_used"] ?? null,
+    latency_ms: row["latency_ms"] ?? null,
+    context: row["context"] || null,
+    lesson: row["lesson"] || null,
+    when_to_use: row["when_to_use"] || null,
+    agent_id: row["agent_id"] || null,
+    project_id: row["project_id"] || null,
+    session_id: row["session_id"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    created_at: row["created_at"]
+  };
+}
+function saveToolEvent(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const metadataJson = JSON.stringify(input.metadata || {});
+  d.run(`INSERT INTO tool_events (id, tool_name, action, success, error_type, error_message, tokens_used, latency_ms, context, lesson, when_to_use, agent_id, project_id, session_id, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.tool_name,
+    input.action || null,
+    input.success ? 1 : 0,
+    input.error_type || null,
+    input.error_message || null,
+    input.tokens_used ?? null,
+    input.latency_ms ?? null,
+    input.context || null,
+    input.lesson || null,
+    input.when_to_use || null,
+    input.agent_id || null,
+    input.project_id || null,
+    input.session_id || null,
+    metadataJson,
+    timestamp
+  ]);
+  return getToolEvent(id, d);
+}
+function getToolEvent(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM tool_events WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return parseToolEventRow(row);
+}
+function getToolEvents(filters, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filters.tool_name) {
+    conditions.push("tool_name = ?");
+    params.push(filters.tool_name);
+  }
+  if (filters.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(filters.agent_id);
+  }
+  if (filters.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filters.project_id);
+  }
+  if (filters.success !== undefined) {
+    conditions.push("success = ?");
+    params.push(filters.success ? 1 : 0);
+  }
+  if (filters.from_date) {
+    conditions.push("created_at >= ?");
+    params.push(filters.from_date);
+  }
+  if (filters.to_date) {
+    conditions.push("created_at <= ?");
+    params.push(filters.to_date);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filters.limit || 50;
+  const offset = filters.offset || 0;
+  const rows = d.query(`SELECT * FROM tool_events ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+  return rows.map(parseToolEventRow);
+}
+function getToolStats(tool_name, project_id, db) {
+  const d = db || getDatabase();
+  let where = "WHERE tool_name = ?";
+  const params = [tool_name];
+  if (project_id) {
+    where += " AND project_id = ?";
+    params.push(project_id);
+  }
+  const stats = d.query(`SELECT
+      COUNT(*) as total_calls,
+      SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as success_count,
+      SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as failure_count,
+      AVG(CASE WHEN tokens_used IS NOT NULL THEN tokens_used END) as avg_tokens,
+      AVG(CASE WHEN latency_ms IS NOT NULL THEN latency_ms END) as avg_latency_ms,
+      MAX(created_at) as last_used
+    FROM tool_events ${where}`).get(...params);
+  const total = stats["total_calls"] || 0;
+  const successCount = stats["success_count"] || 0;
+  const errorRows = d.query(`SELECT error_type, COUNT(*) as count
+     FROM tool_events ${where} AND error_type IS NOT NULL
+     GROUP BY error_type ORDER BY count DESC LIMIT 5`).all(...params);
+  return {
+    tool_name,
+    total_calls: total,
+    success_count: successCount,
+    failure_count: stats["failure_count"] || 0,
+    success_rate: total > 0 ? successCount / total : 0,
+    avg_tokens: stats["avg_tokens"] ?? null,
+    avg_latency_ms: stats["avg_latency_ms"] ?? null,
+    common_errors: errorRows,
+    last_used: stats["last_used"] || ""
+  };
+}
+function getToolLessons(tool_name, project_id, limit, db) {
+  const d = db || getDatabase();
+  let where = "WHERE tool_name = ? AND lesson IS NOT NULL";
+  const params = [tool_name];
+  if (project_id) {
+    where += " AND project_id = ?";
+    params.push(project_id);
+  }
+  const rows = d.query(`SELECT lesson, when_to_use, created_at FROM tool_events ${where} ORDER BY created_at DESC LIMIT ?`).all(...params, limit || 20);
+  return rows;
+}
+var init_tool_events = __esm(() => {
+  init_database();
+});
+
 // src/db/webhook_hooks.ts
 function parseRow(row) {
   return {
@@ -4053,80 +4407,265 @@ var init_synthesis = __esm(() => {
   init_database();
 });
 
-// src/lib/built-in-hooks.ts
-var exports_built_in_hooks = {};
-__export(exports_built_in_hooks, {
-  reloadWebhooks: () => reloadWebhooks,
-  loadWebhooksFromDb: () => loadWebhooksFromDb
+// src/lib/when-to-use-generator.ts
+var exports_when_to_use_generator = {};
+__export(exports_when_to_use_generator, {
+  generateWhenToUse: () => generateWhenToUse,
+  autoGenerateWhenToUse: () => autoGenerateWhenToUse
 });
-async function getAutoMemory() {
-  if (!_processConversationTurn) {
-    const mod = await Promise.resolve().then(() => (init_auto_memory(), exports_auto_memory));
-    _processConversationTurn = mod.processConversationTurn;
+async function generateWhenToUse(key, value, category, tags) {
+  if (process.env["MEMENTOS_AUTO_WHEN_TO_USE"] !== "true")
+    return null;
+  const apiKey = process.env["ANTHROPIC_API_KEY"];
+  if (!apiKey)
+    return null;
+  try {
+    const userMessage = `Key: "${key}"
+Value: "${value}"
+Category: ${category}
+Tags: ${tags.join(", ") || "none"}
+
+Generate the when_to_use activation context (1-2 sentences):`;
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "claude-haiku-4-5-20251001",
+        max_tokens: 150,
+        system: SYSTEM_PROMPT,
+        messages: [{ role: "user", content: userMessage }]
+      })
+    });
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    const text = data.content?.[0]?.text?.trim();
+    return text || null;
+  } catch {
+    return null;
   }
-  return _processConversationTurn;
 }
-function loadWebhooksFromDb() {
-  if (_webhooksLoaded)
+async function autoGenerateWhenToUse(ctx) {
+  if (ctx.memory.when_to_use)
+    return;
+  if (process.env["MEMENTOS_AUTO_WHEN_TO_USE"] !== "true")
     return;
-  _webhooksLoaded = true;
   try {
-    const webhooks = listWebhookHooks({ enabled: true });
-    for (const wh of webhooks) {
-      hookRegistry.register({
-        type: wh.type,
-        blocking: wh.blocking,
-        priority: wh.priority,
-        agentId: wh.agentId,
-        projectId: wh.projectId,
-        description: wh.description ?? `Webhook: ${wh.handlerUrl}`,
-        handler: makeWebhookHandler(wh.id, wh.handlerUrl)
-      });
-    }
-    if (webhooks.length > 0) {
-      console.log(`[hooks] Loaded ${webhooks.length} webhook(s) from DB`);
+    const whenToUse = await generateWhenToUse(ctx.memory.key, ctx.memory.value, ctx.memory.category, ctx.memory.tags);
+    if (whenToUse) {
+      const db = getDatabase();
+      db.run("UPDATE memories SET when_to_use = ? WHERE id = ? AND when_to_use IS NULL", [whenToUse, ctx.memory.id]);
     }
-  } catch (err) {
-    console.error("[hooks] Failed to load webhooks from DB:", err);
-  }
+  } catch {}
 }
-function makeWebhookHandler(webhookId, url) {
-  return async (context) => {
-    try {
-      const res = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(context),
-        signal: AbortSignal.timeout(1e4)
-      });
-      recordWebhookInvocation(webhookId, res.ok);
-    } catch {
-      recordWebhookInvocation(webhookId, false);
+var SYSTEM_PROMPT = `You generate activation contexts for memory records. Given a memory's key, value, category, and tags, output a 1-2 sentence "when to use" description that describes the SITUATION or CONDITION under which an AI agent should retrieve this memory.
+
+Rules:
+- Start with "When" or "If"
+- Describe the situation, not the content
+- Be specific enough to avoid false matches but general enough to catch relevant scenarios
+- Focus on the task/action the agent would be doing, not what the memory contains
+
+Examples:
+- Key: "preferred-language", Value: "Always use TypeScript, never JavaScript" \u2192 "When choosing a programming language for a new file or project"
+- Key: "db-migration-order", Value: "Always run migrations before deploying" \u2192 "When deploying or updating database schema"
+- Key: "bash-chain-bug", Value: "Bash tool mangles && chains" \u2192 "When chaining commands with && in the Bash tool"`;
+var init_when_to_use_generator = __esm(() => {
+  init_database();
+});
+
+// src/lib/contradiction.ts
+var exports_contradiction = {};
+__export(exports_contradiction, {
+  invalidateFact: () => invalidateFact,
+  detectContradiction: () => detectContradiction
+});
+function invalidateFact(oldMemoryId, newMemoryId, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  d.run("UPDATE memories SET valid_until = ?, updated_at = ? WHERE id = ?", [timestamp, timestamp, oldMemoryId]);
+  if (newMemoryId) {
+    const row = d.query("SELECT metadata FROM memories WHERE id = ?").get(newMemoryId);
+    if (row) {
+      const metadata = JSON.parse(row.metadata || "{}");
+      metadata.supersedes_id = oldMemoryId;
+      d.run("UPDATE memories SET metadata = ?, updated_at = ? WHERE id = ?", [JSON.stringify(metadata), timestamp, newMemoryId]);
     }
+  }
+  return {
+    invalidated_memory_id: oldMemoryId,
+    new_memory_id: newMemoryId || null,
+    valid_until: timestamp,
+    supersedes_id: oldMemoryId
   };
 }
-function reloadWebhooks() {
-  _webhooksLoaded = false;
-  loadWebhooksFromDb();
+function heuristicContradictionScore(newValue, existingValue, newKey, existingKey) {
+  if (newKey !== existingKey)
+    return 0;
+  const newLower = newValue.toLowerCase().trim();
+  const existingLower = existingValue.toLowerCase().trim();
+  if (newLower === existingLower)
+    return 0;
+  const newWords = new Set(newLower.split(/\s+/));
+  const existingWords = new Set(existingLower.split(/\s+/));
+  let overlap = 0;
+  for (const w of newWords) {
+    if (existingWords.has(w))
+      overlap++;
+  }
+  const totalUnique = new Set([...newWords, ...existingWords]).size;
+  const overlapRatio = totalUnique > 0 ? overlap / totalUnique : 0;
+  if (overlapRatio < 0.3)
+    return 0.7;
+  if (overlapRatio < 0.5)
+    return 0.4;
+  return 0.1;
 }
-var _processConversationTurn = null, _webhooksLoaded = false;
-var init_built_in_hooks = __esm(() => {
-  init_hooks();
-  init_webhook_hooks();
-  hookRegistry.register({
-    type: "PostMemorySave",
-    blocking: false,
-    builtin: true,
-    priority: 100,
-    description: "Trigger async LLM entity extraction when a memory is saved",
-    handler: async (ctx) => {
-      if (ctx.wasUpdated)
-        return;
-      const processConversationTurn2 = await getAutoMemory();
-      processConversationTurn2(`${ctx.memory.key}: ${ctx.memory.value}`, {
-        agentId: ctx.agentId,
-        projectId: ctx.projectId,
-        sessionId: ctx.sessionId
+async function llmContradictionCheck(_newValue, _existingValue, _key) {
+  const provider = providerRegistry.getAvailable();
+  if (!provider) {
+    return { contradicts: false, confidence: 0, reasoning: "No LLM provider available" };
+  }
+  try {
+    return { contradicts: false, confidence: 0, reasoning: "LLM check skipped \u2014 using heuristic only" };
+  } catch {
+    return { contradicts: false, confidence: 0, reasoning: "LLM check failed" };
+  }
+}
+async function detectContradiction(newKey, newValue, options = {}, db) {
+  const d = db || getDatabase();
+  const { scope, project_id, min_importance = 7, use_llm = false } = options;
+  const conditions = ["key = ?", "status = 'active'", "importance >= ?"];
+  const params = [newKey, min_importance];
+  if (scope) {
+    conditions.push("scope = ?");
+    params.push(scope);
+  }
+  if (project_id) {
+    conditions.push("project_id = ?");
+    params.push(project_id);
+  }
+  conditions.push("(valid_until IS NULL OR valid_until > datetime('now'))");
+  const sql = `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY importance DESC LIMIT 10`;
+  const rows = d.query(sql).all(...params);
+  if (rows.length === 0) {
+    return { contradicts: false, conflicting_memory: null, confidence: 0, reasoning: "No existing memories with this key" };
+  }
+  let bestContradiction = {
+    contradicts: false,
+    conflicting_memory: null,
+    confidence: 0,
+    reasoning: "No contradiction detected"
+  };
+  for (const row of rows) {
+    const existing = parseMemoryRow(row);
+    const heuristicScore = heuristicContradictionScore(newValue, existing.value, newKey, existing.key);
+    if (heuristicScore > bestContradiction.confidence) {
+      bestContradiction = {
+        contradicts: heuristicScore >= 0.5,
+        conflicting_memory: existing,
+        confidence: heuristicScore,
+        reasoning: heuristicScore >= 0.7 ? `New value for "${newKey}" significantly differs from existing high-importance memory (importance ${existing.importance})` : heuristicScore >= 0.5 ? `New value for "${newKey}" partially conflicts with existing memory (importance ${existing.importance})` : `Minor difference detected for "${newKey}"`
+      };
+    }
+  }
+  if (use_llm && bestContradiction.confidence >= 0.3 && bestContradiction.confidence < 0.7 && bestContradiction.conflicting_memory) {
+    const llmResult = await llmContradictionCheck(newValue, bestContradiction.conflicting_memory.value, newKey);
+    if (llmResult.confidence > bestContradiction.confidence) {
+      bestContradiction = {
+        ...bestContradiction,
+        contradicts: llmResult.contradicts,
+        confidence: llmResult.confidence,
+        reasoning: llmResult.reasoning
+      };
+    }
+  }
+  return bestContradiction;
+}
+var init_contradiction = __esm(() => {
+  init_database();
+  init_memories();
+  init_registry();
+});
+
+// src/lib/built-in-hooks.ts
+var exports_built_in_hooks = {};
+__export(exports_built_in_hooks, {
+  reloadWebhooks: () => reloadWebhooks,
+  loadWebhooksFromDb: () => loadWebhooksFromDb
+});
+async function getAutoMemory() {
+  if (!_processConversationTurn) {
+    const mod = await Promise.resolve().then(() => (init_auto_memory(), exports_auto_memory));
+    _processConversationTurn = mod.processConversationTurn;
+  }
+  return _processConversationTurn;
+}
+function loadWebhooksFromDb() {
+  if (_webhooksLoaded)
+    return;
+  _webhooksLoaded = true;
+  try {
+    const webhooks = listWebhookHooks({ enabled: true });
+    for (const wh of webhooks) {
+      hookRegistry.register({
+        type: wh.type,
+        blocking: wh.blocking,
+        priority: wh.priority,
+        agentId: wh.agentId,
+        projectId: wh.projectId,
+        description: wh.description ?? `Webhook: ${wh.handlerUrl}`,
+        handler: makeWebhookHandler(wh.id, wh.handlerUrl)
+      });
+    }
+    if (webhooks.length > 0) {
+      console.log(`[hooks] Loaded ${webhooks.length} webhook(s) from DB`);
+    }
+  } catch (err) {
+    console.error("[hooks] Failed to load webhooks from DB:", err);
+  }
+}
+function makeWebhookHandler(webhookId, url) {
+  return async (context) => {
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(context),
+        signal: AbortSignal.timeout(1e4)
+      });
+      recordWebhookInvocation(webhookId, res.ok);
+    } catch {
+      recordWebhookInvocation(webhookId, false);
+    }
+  };
+}
+function reloadWebhooks() {
+  _webhooksLoaded = false;
+  loadWebhooksFromDb();
+}
+var _processConversationTurn = null, _webhooksLoaded = false;
+var init_built_in_hooks = __esm(() => {
+  init_hooks();
+  init_webhook_hooks();
+  hookRegistry.register({
+    type: "PostMemorySave",
+    blocking: false,
+    builtin: true,
+    priority: 100,
+    description: "Trigger async LLM entity extraction when a memory is saved",
+    handler: async (ctx) => {
+      if (ctx.wasUpdated)
+        return;
+      const processConversationTurn2 = await getAutoMemory();
+      processConversationTurn2(`${ctx.memory.key}: ${ctx.memory.value}`, {
+        agentId: ctx.agentId,
+        projectId: ctx.projectId,
+        sessionId: ctx.sessionId
       });
     }
   });
@@ -4179,10 +4718,76 @@ var init_built_in_hooks = __esm(() => {
     description: "Generate and store vector embedding for semantic memory search",
     handler: async (ctx) => {
       const { indexMemoryEmbedding: indexMemoryEmbedding2 } = await Promise.resolve().then(() => (init_memories(), exports_memories));
-      const text = [ctx.memory.value, ctx.memory.summary].filter(Boolean).join(" ");
+      const text = ctx.memory.when_to_use || [ctx.memory.value, ctx.memory.summary].filter(Boolean).join(" ");
       indexMemoryEmbedding2(ctx.memory.id, text);
     }
   });
+  hookRegistry.register({
+    type: "PostMemorySave",
+    blocking: false,
+    builtin: true,
+    priority: 60,
+    description: "Auto-generate when_to_use activation context via LLM if missing",
+    handler: async (ctx) => {
+      const { autoGenerateWhenToUse: autoGenerateWhenToUse2 } = await Promise.resolve().then(() => (init_when_to_use_generator(), exports_when_to_use_generator));
+      await autoGenerateWhenToUse2(ctx);
+    }
+  });
+  hookRegistry.register({
+    type: "PostMemorySave",
+    blocking: false,
+    builtin: true,
+    priority: 65,
+    description: "Mark synthesized profile as stale when a preference or fact memory is saved",
+    handler: async (ctx) => {
+      const category = ctx.memory?.category;
+      if (category !== "preference" && category !== "fact")
+        return;
+      try {
+        const { markProfileStale: markProfileStale2 } = await Promise.resolve().then(() => (init_profile_synthesizer(), exports_profile_synthesizer));
+        markProfileStale2(ctx.projectId, ctx.agentId);
+      } catch {}
+    }
+  });
+  hookRegistry.register({
+    type: "PostMemorySave",
+    blocking: false,
+    builtin: true,
+    priority: 70,
+    description: "Auto-decay importance of existing memories contradicted by the newly saved memory",
+    handler: async (ctx) => {
+      if (ctx.wasUpdated)
+        return;
+      const memory = ctx.memory;
+      if (memory.category !== "fact" && memory.category !== "knowledge")
+        return;
+      try {
+        const { detectContradiction: detectContradiction2 } = await Promise.resolve().then(() => (init_contradiction(), exports_contradiction));
+        const { updateMemory: updateMemory2, getMemory: getMemory2 } = await Promise.resolve().then(() => (init_memories(), exports_memories));
+        const result = await detectContradiction2(memory.key, memory.value, {
+          scope: memory.scope,
+          project_id: ctx.projectId,
+          min_importance: 1
+        });
+        if (!result.contradicts || !result.conflicting_memory)
+          return;
+        const conflicting = result.conflicting_memory;
+        if (conflicting.id === memory.id)
+          return;
+        const fresh = getMemory2(conflicting.id);
+        if (!fresh || fresh.status !== "active")
+          return;
+        const halvedImportance = Math.max(1, Math.floor(fresh.importance / 2));
+        const metadata = { ...fresh.metadata || {}, contradicted_by: memory.id };
+        updateMemory2(fresh.id, {
+          importance: halvedImportance,
+          flag: "contradicted",
+          metadata,
+          version: fresh.version
+        });
+      } catch {}
+    }
+  });
   hookRegistry.register({
     type: "PostMemoryInject",
     blocking: false,
@@ -4236,156 +4841,42 @@ var init_memory_broadcast = __esm(() => {
   CONVERSATIONS_API = process.env.CONVERSATIONS_API_URL || "http://localhost:7020";
 });
 
-// src/lib/contradiction.ts
-var exports_contradiction = {};
-__export(exports_contradiction, {
-  invalidateFact: () => invalidateFact,
-  detectContradiction: () => detectContradiction
+// src/db/audit.ts
+var exports_audit = {};
+__export(exports_audit, {
+  getMemoryAuditTrail: () => getMemoryAuditTrail,
+  getAuditStats: () => getAuditStats,
+  exportAuditLog: () => exportAuditLog
 });
-function invalidateFact(oldMemoryId, newMemoryId, db) {
-  const d = db || getDatabase();
-  const timestamp = now();
-  d.run("UPDATE memories SET valid_until = ?, updated_at = ? WHERE id = ?", [timestamp, timestamp, oldMemoryId]);
-  if (newMemoryId) {
-    const row = d.query("SELECT metadata FROM memories WHERE id = ?").get(newMemoryId);
-    if (row) {
-      const metadata = JSON.parse(row.metadata || "{}");
-      metadata.supersedes_id = oldMemoryId;
-      d.run("UPDATE memories SET metadata = ?, updated_at = ? WHERE id = ?", [JSON.stringify(metadata), timestamp, newMemoryId]);
-    }
-  }
+function parseAuditRow(row) {
   return {
-    invalidated_memory_id: oldMemoryId,
-    new_memory_id: newMemoryId || null,
-    valid_until: timestamp,
-    supersedes_id: oldMemoryId
+    id: row["id"],
+    memory_id: row["memory_id"],
+    memory_key: row["memory_key"] || null,
+    operation: row["operation"],
+    agent_id: row["agent_id"] || null,
+    old_value_hash: row["old_value_hash"] || null,
+    new_value_hash: row["new_value_hash"] || null,
+    changes: JSON.parse(row["changes"] || "{}"),
+    created_at: row["created_at"]
   };
 }
-function heuristicContradictionScore(newValue, existingValue, newKey, existingKey) {
-  if (newKey !== existingKey)
-    return 0;
-  const newLower = newValue.toLowerCase().trim();
-  const existingLower = existingValue.toLowerCase().trim();
-  if (newLower === existingLower)
-    return 0;
-  const newWords = new Set(newLower.split(/\s+/));
-  const existingWords = new Set(existingLower.split(/\s+/));
-  let overlap = 0;
-  for (const w of newWords) {
-    if (existingWords.has(w))
-      overlap++;
-  }
-  const totalUnique = new Set([...newWords, ...existingWords]).size;
-  const overlapRatio = totalUnique > 0 ? overlap / totalUnique : 0;
-  if (overlapRatio < 0.3)
-    return 0.7;
-  if (overlapRatio < 0.5)
-    return 0.4;
-  return 0.1;
+function getMemoryAuditTrail(memoryId, limit = 50, db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM memory_audit_log WHERE memory_id = ? ORDER BY created_at DESC LIMIT ?").all(memoryId, limit);
+  return rows.map(parseAuditRow);
 }
-async function llmContradictionCheck(_newValue, _existingValue, _key) {
-  const provider = providerRegistry.getAvailable();
-  if (!provider) {
-    return { contradicts: false, confidence: 0, reasoning: "No LLM provider available" };
+function exportAuditLog(options = {}, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (options.since) {
+    conditions.push("created_at >= ?");
+    params.push(options.since);
   }
-  try {
-    return { contradicts: false, confidence: 0, reasoning: "LLM check skipped \u2014 using heuristic only" };
-  } catch {
-    return { contradicts: false, confidence: 0, reasoning: "LLM check failed" };
-  }
-}
-async function detectContradiction(newKey, newValue, options = {}, db) {
-  const d = db || getDatabase();
-  const { scope, project_id, min_importance = 7, use_llm = false } = options;
-  const conditions = ["key = ?", "status = 'active'", "importance >= ?"];
-  const params = [newKey, min_importance];
-  if (scope) {
-    conditions.push("scope = ?");
-    params.push(scope);
-  }
-  if (project_id) {
-    conditions.push("project_id = ?");
-    params.push(project_id);
-  }
-  conditions.push("(valid_until IS NULL OR valid_until > datetime('now'))");
-  const sql = `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY importance DESC LIMIT 10`;
-  const rows = d.query(sql).all(...params);
-  if (rows.length === 0) {
-    return { contradicts: false, conflicting_memory: null, confidence: 0, reasoning: "No existing memories with this key" };
-  }
-  let bestContradiction = {
-    contradicts: false,
-    conflicting_memory: null,
-    confidence: 0,
-    reasoning: "No contradiction detected"
-  };
-  for (const row of rows) {
-    const existing = parseMemoryRow(row);
-    const heuristicScore = heuristicContradictionScore(newValue, existing.value, newKey, existing.key);
-    if (heuristicScore > bestContradiction.confidence) {
-      bestContradiction = {
-        contradicts: heuristicScore >= 0.5,
-        conflicting_memory: existing,
-        confidence: heuristicScore,
-        reasoning: heuristicScore >= 0.7 ? `New value for "${newKey}" significantly differs from existing high-importance memory (importance ${existing.importance})` : heuristicScore >= 0.5 ? `New value for "${newKey}" partially conflicts with existing memory (importance ${existing.importance})` : `Minor difference detected for "${newKey}"`
-      };
-    }
-  }
-  if (use_llm && bestContradiction.confidence >= 0.3 && bestContradiction.confidence < 0.7 && bestContradiction.conflicting_memory) {
-    const llmResult = await llmContradictionCheck(newValue, bestContradiction.conflicting_memory.value, newKey);
-    if (llmResult.confidence > bestContradiction.confidence) {
-      bestContradiction = {
-        ...bestContradiction,
-        contradicts: llmResult.contradicts,
-        confidence: llmResult.confidence,
-        reasoning: llmResult.reasoning
-      };
-    }
-  }
-  return bestContradiction;
-}
-var init_contradiction = __esm(() => {
-  init_database();
-  init_memories();
-  init_registry();
-});
-
-// src/db/audit.ts
-var exports_audit = {};
-__export(exports_audit, {
-  getMemoryAuditTrail: () => getMemoryAuditTrail,
-  getAuditStats: () => getAuditStats,
-  exportAuditLog: () => exportAuditLog
-});
-function parseAuditRow(row) {
-  return {
-    id: row["id"],
-    memory_id: row["memory_id"],
-    memory_key: row["memory_key"] || null,
-    operation: row["operation"],
-    agent_id: row["agent_id"] || null,
-    old_value_hash: row["old_value_hash"] || null,
-    new_value_hash: row["new_value_hash"] || null,
-    changes: JSON.parse(row["changes"] || "{}"),
-    created_at: row["created_at"]
-  };
-}
-function getMemoryAuditTrail(memoryId, limit = 50, db) {
-  const d = db || getDatabase();
-  const rows = d.query("SELECT * FROM memory_audit_log WHERE memory_id = ? ORDER BY created_at DESC LIMIT ?").all(memoryId, limit);
-  return rows.map(parseAuditRow);
-}
-function exportAuditLog(options = {}, db) {
-  const d = db || getDatabase();
-  const conditions = [];
-  const params = [];
-  if (options.since) {
-    conditions.push("created_at >= ?");
-    params.push(options.since);
-  }
-  if (options.until) {
-    conditions.push("created_at <= ?");
-    params.push(options.until);
+  if (options.until) {
+    conditions.push("created_at <= ?");
+    params.push(options.until);
   }
   if (options.operation) {
     conditions.push("operation = ?");
@@ -4560,55 +5051,712 @@ var init_export_v1 = __esm(() => {
   init_database();
 });
 
-// src/lib/context.ts
-var exports_context = {};
-__export(exports_context, {
-  formatLayeredContext: () => formatLayeredContext,
-  assembleContext: () => assembleContext
-});
-function assembleContext(options = {}, db) {
-  const { project_id, agent_id, scope, max_per_section = 10 } = options;
-  const baseFilter = {
-    project_id,
-    agent_id,
-    scope
-  };
-  const sections = [];
-  const coreFacts = listMemories({ ...baseFilter, category: ["fact", "preference"], min_importance: 8, limit: max_per_section }, db);
-  if (coreFacts.length > 0) {
-    sections.push({ title: "Core Facts", memories: coreFacts });
+// src/lib/config.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync as readdirSync3, writeFileSync, unlinkSync } from "fs";
+import { homedir } from "os";
+import { basename as basename3, dirname as dirname5, join as join6, resolve as resolve4 } from "path";
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = result[key];
+    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(targetVal, sourceVal);
+    } else {
+      result[key] = sourceVal;
+    }
   }
-  const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
-  const allRecent = listMemories({ ...baseFilter, limit: max_per_section * 3 }, db).filter((m) => m.created_at > oneDayAgo || m.accessed_at && m.accessed_at > oneDayAgo);
-  const recentSlice = allRecent.slice(0, max_per_section);
-  if (recentSlice.length > 0) {
-    sections.push({ title: "Recent History", memories: recentSlice });
+  return result;
+}
+function isValidScope(value) {
+  return VALID_SCOPES.includes(value);
+}
+function isValidCategory(value) {
+  return VALID_CATEGORIES.includes(value);
+}
+function loadConfig() {
+  const configPath = join6(homedir(), ".mementos", "config.json");
+  let fileConfig = {};
+  if (existsSync6(configPath)) {
+    try {
+      const raw = readFileSync3(configPath, "utf-8");
+      fileConfig = JSON.parse(raw);
+    } catch {}
   }
-  if (options.query) {
-    const knowledge = listMemories({ ...baseFilter, category: "knowledge", search: options.query, limit: max_per_section }, db);
-    if (knowledge.length > 0) {
-      sections.push({ title: "Relevant Knowledge", memories: knowledge });
+  const merged = deepMerge(DEFAULT_CONFIG2, fileConfig);
+  const envScope = process.env["MEMENTOS_DEFAULT_SCOPE"];
+  if (envScope && isValidScope(envScope)) {
+    merged.default_scope = envScope;
+  }
+  const envCategory = process.env["MEMENTOS_DEFAULT_CATEGORY"];
+  if (envCategory && isValidCategory(envCategory)) {
+    merged.default_category = envCategory;
+  }
+  const envImportance = process.env["MEMENTOS_DEFAULT_IMPORTANCE"];
+  if (envImportance) {
+    const parsed = parseInt(envImportance, 10);
+    if (!Number.isNaN(parsed) && parsed >= 1 && parsed <= 10) {
+      merged.default_importance = parsed;
     }
   }
-  const decisions = listMemories({ ...baseFilter, category: "fact", limit: max_per_section }, db);
-  const coreFactIds = new Set(coreFacts.map((m) => m.id));
-  const newDecisions = decisions.filter((m) => !coreFactIds.has(m.id));
-  if (newDecisions.length > 0) {
-    sections.push({ title: "Active Decisions", memories: newDecisions.slice(0, max_per_section) });
+  return merged;
+}
+var DEFAULT_CONFIG2, VALID_SCOPES, VALID_CATEGORIES;
+var init_config = __esm(() => {
+  DEFAULT_CONFIG2 = {
+    default_scope: "private",
+    default_category: "knowledge",
+    default_importance: 5,
+    max_entries: 1000,
+    max_entries_per_scope: {
+      global: 500,
+      shared: 300,
+      private: 200,
+      working: 100
+    },
+    injection: {
+      max_tokens: 500,
+      min_importance: 5,
+      categories: ["preference", "fact"],
+      refresh_interval: 5
+    },
+    extraction: {
+      enabled: true,
+      min_confidence: 0.5
+    },
+    sync_agents: ["claude", "codex", "gemini"],
+    auto_cleanup: {
+      enabled: true,
+      expired_check_interval: 3600,
+      unused_archive_days: 7,
+      stale_deprioritize_days: 14
+    }
+  };
+  VALID_SCOPES = ["global", "shared", "private", "working"];
+  VALID_CATEGORIES = [
+    "preference",
+    "fact",
+    "knowledge",
+    "history"
+  ];
+});
+
+// src/lib/injector.ts
+var exports_injector = {};
+__export(exports_injector, {
+  smartInject: () => smartInject,
+  MemoryInjector: () => MemoryInjector
+});
+
+class MemoryInjector {
+  config;
+  injectedIds = new Set;
+  constructor(config) {
+    this.config = config || loadConfig();
   }
-  const seen = new Set;
-  for (const section of sections) {
-    section.memories = section.memories.filter((m) => {
+  getInjectionContext(options = {}) {
+    const maxTokens = options.max_tokens || this.config.injection.max_tokens;
+    const minImportance = options.min_importance || this.config.injection.min_importance;
+    const categories = options.categories || this.config.injection.categories;
+    const db = options.db;
+    const allMemories = [];
+    const globalMems = listMemories({
+      scope: "global",
+      category: categories,
+      min_importance: minImportance,
+      status: "active",
+      limit: 100
+    }, db);
+    allMemories.push(...globalMems);
+    if (options.project_id) {
+      const sharedMems = listMemories({
+        scope: "shared",
+        category: categories,
+        min_importance: minImportance,
+        status: "active",
+        project_id: options.project_id,
+        limit: 100
+      }, db);
+      allMemories.push(...sharedMems);
+    }
+    if (options.agent_id) {
+      const privateMems = listMemories({
+        scope: "private",
+        category: categories,
+        min_importance: minImportance,
+        status: "active",
+        agent_id: options.agent_id,
+        limit: 100
+      }, db);
+      allMemories.push(...privateMems);
+    }
+    if (options.session_id || options.agent_id) {
+      const workingMems = listMemories({
+        scope: "working",
+        status: "active",
+        ...options.session_id ? { session_id: options.session_id } : {},
+        ...options.agent_id ? { agent_id: options.agent_id } : {},
+        ...options.project_id ? { project_id: options.project_id } : {},
+        limit: 100
+      }, db);
+      allMemories.push(...workingMems);
+    }
+    const seen = new Set;
+    const unique = allMemories.filter((m) => {
       if (seen.has(m.id))
         return false;
       seen.add(m.id);
       return true;
     });
+    if (unique.length === 0) {
+      return "";
+    }
+    const totalCharBudget = maxTokens * 4;
+    const footer = "Tip: Use memory_search for deeper lookup on specific topics.";
+    const footerChars = footer.length;
+    const keyBudget = Math.floor((totalCharBudget - footerChars) * 0.67);
+    const recentBudget = Math.floor((totalCharBudget - footerChars) * 0.33);
+    const keyRanked = [...unique].sort((a, b) => {
+      if (a.pinned !== b.pinned)
+        return a.pinned ? -1 : 1;
+      if (b.importance !== a.importance)
+        return b.importance - a.importance;
+      return new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime();
+    });
+    const keyLines = [];
+    const keyIds = new Set;
+    let keyChars = 0;
+    for (const m of keyRanked) {
+      if (this.injectedIds.has(m.id))
+        continue;
+      const line = `- [${m.scope}/${m.category}] ${m.key}: ${m.value}`;
+      if (keyChars + line.length > keyBudget)
+        break;
+      keyLines.push(line);
+      keyIds.add(m.id);
+      keyChars += line.length;
+    }
+    const recentRanked = [...unique].sort((a, b) => {
+      const aTime = a.accessed_at ? new Date(a.accessed_at).getTime() : 0;
+      const bTime = b.accessed_at ? new Date(b.accessed_at).getTime() : 0;
+      return bTime - aTime;
+    });
+    const recentLines = [];
+    let recentChars = 0;
+    const maxRecent = 5;
+    for (const m of recentRanked) {
+      if (recentLines.length >= maxRecent)
+        break;
+      if (keyIds.has(m.id))
+        continue;
+      if (this.injectedIds.has(m.id))
+        continue;
+      const line = `- [${m.scope}/${m.category}] ${m.key}: ${m.value}`;
+      if (recentChars + line.length > recentBudget)
+        break;
+      recentLines.push(line);
+      recentChars += line.length;
+    }
+    if (keyLines.length === 0 && recentLines.length === 0) {
+      return "";
+    }
+    const allInjectedMemoryIds = [
+      ...keyIds,
+      ...recentLines.map((_, i) => {
+        let idx = 0;
+        for (const m of recentRanked) {
+          if (keyIds.has(m.id) || this.injectedIds.has(m.id))
+            continue;
+          if (idx === i)
+            return m.id;
+          idx++;
+        }
+        return "";
+      })
+    ].filter(Boolean);
+    for (const id of allInjectedMemoryIds) {
+      this.injectedIds.add(id);
+      touchMemory(id, db);
+    }
+    const sections = [];
+    if (keyLines.length > 0) {
+      sections.push(`## Key Memories
+${keyLines.join(`
+`)}`);
+    }
+    if (recentLines.length > 0) {
+      sections.push(`## Recent Context
+${recentLines.join(`
+`)}`);
+    }
+    sections.push(footer);
+    return `<agent-memories>
+${sections.join(`
+
+`)}
+</agent-memories>`;
   }
-  const allMemories = sections.flatMap((s) => s.memories);
-  const tokenEstimate = allMemories.reduce((acc, m) => acc + Math.ceil((m.key.length + m.value.length) / 4), 0);
-  return {
-    sections: sections.filter((s) => s.memories.length > 0),
+  async getSmartInjectionContext(options = {}) {
+    if (!options.query) {
+      return this.getInjectionContext(options);
+    }
+    const maxTokens = options.max_tokens || this.config.injection.max_tokens;
+    const minImportance = options.min_importance || this.config.injection.min_importance;
+    const categories = options.categories || this.config.injection.categories;
+    const db = options.db;
+    const allMemories = [];
+    const globalMems = listMemories({
+      scope: "global",
+      category: categories,
+      min_importance: minImportance,
+      status: "active",
+      limit: 100
+    }, db);
+    allMemories.push(...globalMems);
+    if (options.project_id) {
+      const sharedMems = listMemories({
+        scope: "shared",
+        category: categories,
+        min_importance: minImportance,
+        status: "active",
+        project_id: options.project_id,
+        limit: 100
+      }, db);
+      allMemories.push(...sharedMems);
+    }
+    if (options.agent_id) {
+      const privateMems = listMemories({
+        scope: "private",
+        category: categories,
+        min_importance: minImportance,
+        status: "active",
+        agent_id: options.agent_id,
+        limit: 100
+      }, db);
+      allMemories.push(...privateMems);
+    }
+    if (options.session_id || options.agent_id) {
+      const workingMems = listMemories({
+        scope: "working",
+        status: "active",
+        ...options.session_id ? { session_id: options.session_id } : {},
+        ...options.agent_id ? { agent_id: options.agent_id } : {},
+        ...options.project_id ? { project_id: options.project_id } : {},
+        limit: 100
+      }, db);
+      allMemories.push(...workingMems);
+    }
+    const seen = new Set;
+    const unique = allMemories.filter((m) => {
+      if (seen.has(m.id))
+        return false;
+      seen.add(m.id);
+      return true;
+    });
+    if (unique.length === 0) {
+      return "";
+    }
+    const { embedding: queryEmbedding } = await generateEmbedding(options.query);
+    const d = db || (await Promise.resolve().then(() => (init_database(), exports_database))).getDatabase();
+    const embeddingRows = d.prepare(`SELECT memory_id, embedding FROM memory_embeddings WHERE memory_id IN (${unique.map(() => "?").join(",")})`).all(...unique.map((m) => m.id));
+    const embeddingMap = new Map;
+    for (const row of embeddingRows) {
+      try {
+        embeddingMap.set(row.memory_id, deserializeEmbedding(row.embedding));
+      } catch {}
+    }
+    if (embeddingMap.size === 0) {
+      return this.getInjectionContext(options);
+    }
+    const nowMs = Date.now();
+    const oldestMs = Math.min(...unique.map((m) => new Date(m.updated_at).getTime()));
+    const timeRange = nowMs - oldestMs || 1;
+    const scored = unique.filter((m) => !this.injectedIds.has(m.id)).map((m) => {
+      const memEmbedding = embeddingMap.get(m.id);
+      const similarity = memEmbedding ? cosineSimilarity(queryEmbedding, memEmbedding) : 0;
+      const importanceScore = m.importance / 10;
+      const recencyScore = (new Date(m.updated_at).getTime() - oldestMs) / timeRange;
+      const pinBonus = m.pinned ? 0.5 : 0;
+      const score = similarity * 0.4 + importanceScore * 0.3 + recencyScore * 0.3 + pinBonus;
+      return { memory: m, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    const totalCharBudget = maxTokens * 4;
+    const footer = "Tip: Use memory_search for deeper lookup on specific topics.";
+    const footerChars = footer.length;
+    const contentBudget = totalCharBudget - footerChars;
+    const lines = [];
+    const injectedIds = [];
+    let totalChars = 0;
+    for (const { memory: m } of scored) {
+      const line = `- [${m.scope}/${m.category}] ${m.key}: ${m.value}`;
+      if (totalChars + line.length > contentBudget)
+        break;
+      lines.push(line);
+      injectedIds.push(m.id);
+      totalChars += line.length;
+    }
+    if (lines.length === 0) {
+      return "";
+    }
+    for (const id of injectedIds) {
+      this.injectedIds.add(id);
+      touchMemory(id, db);
+    }
+    const sections = [];
+    sections.push(`## Relevant Memories
+${lines.join(`
+`)}`);
+    sections.push(footer);
+    return `<agent-memories>
+${sections.join(`
+
+`)}
+</agent-memories>`;
+  }
+  resetDedup() {
+    this.injectedIds.clear();
+  }
+  getInjectedCount() {
+    return this.injectedIds.size;
+  }
+}
+function detectToolMentions(taskContext) {
+  const tools = new Set;
+  const mcpToolPattern = /\b(memory_\w+|entity_\w+|graph_\w+|relation_\w+|session_\w+|webhook_\w+|hook_\w+)\b/gi;
+  let match;
+  while ((match = mcpToolPattern.exec(taskContext)) !== null) {
+    tools.add(match[1].toLowerCase());
+  }
+  const cliPattern = /\b(git|npm|bun|curl|docker|kubectl|mementos)\b/gi;
+  while ((match = cliPattern.exec(taskContext)) !== null) {
+    tools.add(match[1].toLowerCase());
+  }
+  return Array.from(tools);
+}
+function hasToolContext(taskContext) {
+  return TOOL_KEYWORD_PATTERNS.some((p) => p.test(taskContext));
+}
+function categoryToSection(category, key) {
+  if (key.startsWith("_profile_"))
+    return "Profile";
+  switch (category) {
+    case "fact":
+      return "Core Facts";
+    case "procedural":
+      return "Procedures";
+    case "preference":
+      return "Preferences";
+    case "history":
+      return "Recent History";
+    case "knowledge":
+      return "Core Facts";
+    case "resource":
+      return "Core Facts";
+    default:
+      return "Core Facts";
+  }
+}
+function collectVisibleMemories(options, db) {
+  const allMemories = [];
+  const minImportance = options.min_importance ?? 1;
+  allMemories.push(...listMemories({ scope: "global", min_importance: minImportance, status: "active", limit: 100 }, db));
+  if (options.project_id) {
+    allMemories.push(...listMemories({
+      scope: "shared",
+      min_importance: minImportance,
+      status: "active",
+      project_id: options.project_id,
+      limit: 100
+    }, db));
+  }
+  if (options.agent_id) {
+    allMemories.push(...listMemories({
+      scope: "private",
+      min_importance: minImportance,
+      status: "active",
+      agent_id: options.agent_id,
+      limit: 100
+    }, db));
+  }
+  if (options.session_id || options.agent_id) {
+    allMemories.push(...listMemories({
+      scope: "working",
+      status: "active",
+      ...options.session_id ? { session_id: options.session_id } : {},
+      ...options.agent_id ? { agent_id: options.agent_id } : {},
+      ...options.project_id ? { project_id: options.project_id } : {},
+      limit: 100
+    }, db));
+  }
+  const seen = new Set;
+  return allMemories.filter((m) => {
+    if (seen.has(m.id))
+      return false;
+    seen.add(m.id);
+    return true;
+  });
+}
+function formatMemoryLine(m) {
+  const value = m.value.length > 200 ? m.value.slice(0, 197) + "..." : m.value;
+  return `- **${m.key}**: ${value}`;
+}
+async function smartInject(options) {
+  const config = loadConfig();
+  const maxTokens = options.max_tokens || config.injection.max_tokens;
+  const minImportance = options.min_importance ?? config.injection.min_importance;
+  const db = options.db;
+  const taskContext = options.task_context;
+  const totalCharBudget = maxTokens * 4;
+  let profileText = null;
+  let profileFromCache = false;
+  try {
+    const profileResult = await synthesizeProfile({
+      project_id: options.project_id,
+      agent_id: options.agent_id,
+      scope: options.project_id ? "project" : options.agent_id ? "agent" : "global",
+      force_refresh: options.force_profile_refresh
+    });
+    if (profileResult) {
+      profileText = profileResult.profile;
+      profileFromCache = profileResult.from_cache;
+    }
+  } catch {}
+  const candidates = collectVisibleMemories({
+    project_id: options.project_id,
+    agent_id: options.agent_id,
+    session_id: options.session_id,
+    min_importance: minImportance
+  }, db);
+  const activationMap = new Map;
+  try {
+    const semanticResults = await semanticSearch(taskContext, {
+      threshold: 0.25,
+      limit: 50,
+      project_id: options.project_id,
+      agent_id: options.agent_id
+    }, db);
+    for (const result of semanticResults) {
+      activationMap.set(result.memory.id, result.score);
+    }
+  } catch {}
+  const detectedTools = detectToolMentions(taskContext);
+  const includeToolGuides = hasToolContext(taskContext) || detectedTools.length > 0;
+  const toolGuides = [];
+  if (includeToolGuides) {
+    for (const toolName of detectedTools.slice(0, 5)) {
+      try {
+        const stats = getToolStats(toolName, options.project_id, db);
+        const lessons = getToolLessons(toolName, options.project_id, 5, db);
+        if (stats.total_calls > 0 || lessons.length > 0) {
+          const statsLine = stats.total_calls > 0 ? `${stats.total_calls} calls, ${Math.round(stats.success_rate * 100)}% success` + (stats.avg_latency_ms ? `, ~${Math.round(stats.avg_latency_ms)}ms avg` : "") : "no usage data";
+          const lessonLines = lessons.map((l) => `  - ${l.lesson}${l.when_to_use ? ` (when: ${l.when_to_use})` : ""}`);
+          toolGuides.push({ tool_name: toolName, stats_line: statsLine, lessons: lessonLines });
+        }
+      } catch {}
+    }
+  }
+  const scored = candidates.map((m) => {
+    const decay = computeDecayScore(m);
+    const activation = activationMap.get(m.id) ?? 0;
+    const normalizedImportance = m.importance / 10;
+    const pinBonus = m.pinned ? 1 : 0;
+    const normalizedDecay = Math.min(decay / 10, 1);
+    const score = activation * 0.35 + normalizedDecay * 0.35 + normalizedImportance * 0.2 + pinBonus * 0.1;
+    return { memory: m, score, activation, decay };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  const footer = "Tip: Use memory_search for deeper lookup on specific topics.";
+  const headerOverhead = 200;
+  const availableBudget = totalCharBudget - footer.length - headerOverhead;
+  const profileBudget = profileText ? Math.floor(availableBudget * 0.15) : 0;
+  const toolGuideBudget = toolGuides.length > 0 ? Math.floor(availableBudget * 0.15) : 0;
+  const memoryBudget = availableBudget - profileBudget - toolGuideBudget;
+  const sectionWeights = {
+    Profile: 0,
+    "Core Facts": 0.3,
+    "Tool Guides": 0,
+    Procedures: 0.25,
+    Preferences: 0.25,
+    "Recent History": 0.2
+  };
+  const sectionBuckets = new Map;
+  for (const s of scored) {
+    if (s.memory.key.startsWith("_profile_"))
+      continue;
+    if (profileText && s.memory.category === "preference")
+      continue;
+    const section = categoryToSection(s.memory.category, s.memory.key);
+    if (section === "Profile")
+      continue;
+    if (!sectionBuckets.has(section)) {
+      sectionBuckets.set(section, []);
+    }
+    sectionBuckets.get(section).push(s);
+  }
+  const sectionOutput = new Map;
+  const injectedIds = [];
+  let totalMemoryCount = 0;
+  const memorySections = ["Core Facts", "Procedures", "Preferences", "Recent History"];
+  for (const sectionName of memorySections) {
+    const bucket = sectionBuckets.get(sectionName) || [];
+    if (bucket.length === 0)
+      continue;
+    const weight = sectionWeights[sectionName];
+    const budget = Math.floor(memoryBudget * weight);
+    const lines = [];
+    let chars = 0;
+    for (const { memory: m } of bucket) {
+      const line = formatMemoryLine(m);
+      if (chars + line.length > budget)
+        break;
+      lines.push(line);
+      injectedIds.push(m.id);
+      chars += line.length;
+      totalMemoryCount++;
+    }
+    if (lines.length > 0) {
+      sectionOutput.set(sectionName, lines);
+    }
+  }
+  const outputSections = [];
+  if (profileText) {
+    const trimmedProfile = profileText.length > profileBudget ? profileText.slice(0, profileBudget - 3) + "..." : profileText;
+    outputSections.push(`## Profile
+${trimmedProfile}`);
+  }
+  if (sectionOutput.has("Core Facts")) {
+    outputSections.push(`## Core Facts
+${sectionOutput.get("Core Facts").join(`
+`)}`);
+  }
+  if (toolGuides.length > 0) {
+    const toolLines = [];
+    let toolChars = 0;
+    for (const guide of toolGuides) {
+      const header = `- **${guide.tool_name}**: ${guide.stats_line}`;
+      if (toolChars + header.length > toolGuideBudget)
+        break;
+      toolLines.push(header);
+      toolChars += header.length;
+      for (const lesson of guide.lessons) {
+        if (toolChars + lesson.length > toolGuideBudget)
+          break;
+        toolLines.push(lesson);
+        toolChars += lesson.length;
+      }
+    }
+    if (toolLines.length > 0) {
+      outputSections.push(`## Tool Guides
+${toolLines.join(`
+`)}`);
+    }
+  }
+  if (sectionOutput.has("Procedures")) {
+    outputSections.push(`## Procedures
+${sectionOutput.get("Procedures").join(`
+`)}`);
+  }
+  if (sectionOutput.has("Preferences")) {
+    outputSections.push(`## Preferences
+${sectionOutput.get("Preferences").join(`
+`)}`);
+  }
+  if (sectionOutput.has("Recent History")) {
+    outputSections.push(`## Recent History
+${sectionOutput.get("Recent History").join(`
+`)}`);
+  }
+  if (outputSections.length === 0) {
+    return {
+      output: "",
+      token_estimate: 0,
+      memory_count: 0,
+      profile_from_cache: profileFromCache,
+      detected_tools: detectedTools
+    };
+  }
+  outputSections.push(footer);
+  for (const id of injectedIds) {
+    touchMemory(id, db);
+  }
+  const output = `<agent-memories>
+${outputSections.join(`
+
+`)}
+</agent-memories>`;
+  const tokenEstimate = Math.ceil(output.length / 4);
+  return {
+    output,
+    token_estimate: tokenEstimate,
+    memory_count: totalMemoryCount,
+    profile_from_cache: profileFromCache,
+    detected_tools: detectedTools
+  };
+}
+var TOOL_KEYWORD_PATTERNS;
+var init_injector = __esm(() => {
+  init_memories();
+  init_config();
+  init_profile_synthesizer();
+  init_tool_events();
+  TOOL_KEYWORD_PATTERNS = [
+    /\b(mcp|tool|command|cli|server|endpoint|api)\b/i,
+    /\b(memory_\w+|entity_\w+|graph_\w+|relation_\w+)\b/i,
+    /\b(git|npm|bun|curl|docker|kubectl)\b/i,
+    /\bmementos[\s-]?\w*/i
+  ];
+});
+
+// src/lib/context.ts
+var exports_context = {};
+__export(exports_context, {
+  formatLayeredContext: () => formatLayeredContext,
+  assembleContext: () => assembleContext
+});
+function assembleContext(options = {}, db) {
+  const { project_id, agent_id, scope, max_per_section = 10 } = options;
+  const baseFilter = {
+    project_id,
+    agent_id,
+    scope
+  };
+  const sections = [];
+  const coreFacts = listMemories({ ...baseFilter, category: ["fact", "preference"], min_importance: 8, limit: max_per_section }, db);
+  if (coreFacts.length > 0) {
+    sections.push({ title: "Core Facts", memories: coreFacts });
+  }
+  const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+  const allRecent = listMemories({ ...baseFilter, limit: max_per_section * 3 }, db).filter((m) => m.created_at > oneDayAgo || m.accessed_at && m.accessed_at > oneDayAgo);
+  const recentSlice = allRecent.slice(0, max_per_section);
+  if (recentSlice.length > 0) {
+    sections.push({ title: "Recent History", memories: recentSlice });
+  }
+  if (options.query) {
+    const knowledge = listMemories({ ...baseFilter, category: "knowledge", search: options.query, limit: max_per_section }, db);
+    if (knowledge.length > 0) {
+      sections.push({ title: "Relevant Knowledge", memories: knowledge });
+    }
+  }
+  const decisions = listMemories({ ...baseFilter, category: "fact", limit: max_per_section }, db);
+  const coreFactIds = new Set(coreFacts.map((m) => m.id));
+  const newDecisions = decisions.filter((m) => !coreFactIds.has(m.id));
+  if (newDecisions.length > 0) {
+    sections.push({ title: "Active Decisions", memories: newDecisions.slice(0, max_per_section) });
+  }
+  const seen = new Set;
+  for (const section of sections) {
+    section.memories = section.memories.filter((m) => {
+      if (seen.has(m.id))
+        return false;
+      seen.add(m.id);
+      return true;
+    });
+  }
+  const allMemories = sections.flatMap((s) => s.memories);
+  const tokenEstimate = allMemories.reduce((acc, m) => acc + Math.ceil((m.key.length + m.value.length) / 4), 0);
+  return {
+    sections: sections.filter((s) => s.memories.length > 0),
     total_memories: allMemories.length,
     token_estimate: tokenEstimate
   };
@@ -4787,96 +5935,6 @@ var init_acl = __esm(() => {
   init_database();
 });
 
-// src/lib/config.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync, unlinkSync } from "fs";
-import { homedir } from "os";
-import { basename as basename3, dirname as dirname4, join as join4, resolve as resolve4 } from "path";
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    const sourceVal = source[key];
-    const targetVal = result[key];
-    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
-      result[key] = deepMerge(targetVal, sourceVal);
-    } else {
-      result[key] = sourceVal;
-    }
-  }
-  return result;
-}
-function isValidScope(value) {
-  return VALID_SCOPES.includes(value);
-}
-function isValidCategory(value) {
-  return VALID_CATEGORIES.includes(value);
-}
-function loadConfig() {
-  const configPath = join4(homedir(), ".mementos", "config.json");
-  let fileConfig = {};
-  if (existsSync4(configPath)) {
-    try {
-      const raw = readFileSync2(configPath, "utf-8");
-      fileConfig = JSON.parse(raw);
-    } catch {}
-  }
-  const merged = deepMerge(DEFAULT_CONFIG, fileConfig);
-  const envScope = process.env["MEMENTOS_DEFAULT_SCOPE"];
-  if (envScope && isValidScope(envScope)) {
-    merged.default_scope = envScope;
-  }
-  const envCategory = process.env["MEMENTOS_DEFAULT_CATEGORY"];
-  if (envCategory && isValidCategory(envCategory)) {
-    merged.default_category = envCategory;
-  }
-  const envImportance = process.env["MEMENTOS_DEFAULT_IMPORTANCE"];
-  if (envImportance) {
-    const parsed = parseInt(envImportance, 10);
-    if (!Number.isNaN(parsed) && parsed >= 1 && parsed <= 10) {
-      merged.default_importance = parsed;
-    }
-  }
-  return merged;
-}
-var DEFAULT_CONFIG, VALID_SCOPES, VALID_CATEGORIES;
-var init_config = __esm(() => {
-  DEFAULT_CONFIG = {
-    default_scope: "private",
-    default_category: "knowledge",
-    default_importance: 5,
-    max_entries: 1000,
-    max_entries_per_scope: {
-      global: 500,
-      shared: 300,
-      private: 200,
-      working: 100
-    },
-    injection: {
-      max_tokens: 500,
-      min_importance: 5,
-      categories: ["preference", "fact"],
-      refresh_interval: 5
-    },
-    extraction: {
-      enabled: true,
-      min_confidence: 0.5
-    },
-    sync_agents: ["claude", "codex", "gemini"],
-    auto_cleanup: {
-      enabled: true,
-      expired_check_interval: 3600,
-      unused_archive_days: 7,
-      stale_deprioritize_days: 14
-    }
-  };
-  VALID_SCOPES = ["global", "shared", "private", "working"];
-  VALID_CATEGORIES = [
-    "preference",
-    "fact",
-    "knowledge",
-    "history"
-  ];
-});
-
 // src/lib/retention.ts
 var exports_retention = {};
 __export(exports_retention, {
@@ -9612,6 +10670,8 @@ async function buildFileDependencyGraph(opts, db) {
 }
 
 // src/mcp/index.ts
+init_profile_synthesizer();
+init_tool_events();
 init_built_in_hooks();
 init_webhook_hooks();
 
@@ -10641,6 +11701,207 @@ init_database();
 // src/lib/session-processor.ts
 init_memories();
 init_registry();
+
+// src/lib/tool-lesson-extractor.ts
+init_tool_events();
+init_memories();
+var SYSTEM_PROMPT2 = `You are a tool usage analyst. Given a session transcript containing tool calls and their results, extract actionable lessons about tool usage.
+
+For each tool lesson, output a JSON array of objects with these fields:
+- tool_name: name of the tool
+- lesson: the insight (1-2 sentences)
+- when_to_use: activation context \u2014 when should an agent recall this lesson (start with "When" or "If")
+- success: boolean \u2014 was the tool call that taught this lesson successful?
+- error_type: if failed, one of: timeout, permission, not_found, syntax, rate_limit, other (or null if success)
+
+Focus on:
+1. Successful patterns: what worked and why
+2. Failure lessons: what went wrong and how to avoid it
+3. Parameter insights: optimal settings discovered
+4. Alternative tools: when one tool is better than another
+5. Error recovery: what to do when a specific error occurs
+
+Only extract genuinely useful, non-obvious lessons. Skip trivial observations.
+Output ONLY the JSON array, no markdown or explanation.`;
+async function extractToolLessons(transcript, options) {
+  const apiKey = process.env["ANTHROPIC_API_KEY"];
+  if (!apiKey)
+    return [];
+  try {
+    const truncated = transcript.length > 8000 ? transcript.slice(0, 8000) + `
+[...truncated]` : transcript;
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "claude-haiku-4-5-20251001",
+        max_tokens: 1500,
+        system: SYSTEM_PROMPT2,
+        messages: [{ role: "user", content: `Extract tool lessons from this session transcript:
+
+${truncated}` }]
+      })
+    });
+    if (!response.ok)
+      return [];
+    const data = await response.json();
+    const text = data.content?.[0]?.text?.trim();
+    if (!text)
+      return [];
+    const lessons = JSON.parse(text);
+    if (!Array.isArray(lessons))
+      return [];
+    for (const lesson of lessons) {
+      if (!lesson.tool_name || !lesson.lesson)
+        continue;
+      try {
+        saveToolEvent({
+          tool_name: lesson.tool_name,
+          success: lesson.success,
+          error_type: lesson.error_type || undefined,
+          lesson: lesson.lesson,
+          when_to_use: lesson.when_to_use,
+          context: "extracted from session transcript",
+          agent_id: options?.agent_id,
+          project_id: options?.project_id,
+          session_id: options?.session_id
+        });
+      } catch {}
+      try {
+        createMemory({
+          key: `tool-lesson-${lesson.tool_name}-${Date.now()}`,
+          value: lesson.lesson,
+          category: "knowledge",
+          scope: "shared",
+          importance: 7,
+          source: "auto",
+          tags: ["tool-memory", lesson.tool_name, "auto-extracted"],
+          when_to_use: lesson.when_to_use,
+          agent_id: options?.agent_id,
+          project_id: options?.project_id,
+          session_id: options?.session_id
+        });
+      } catch {}
+    }
+    return lessons;
+  } catch {
+    return [];
+  }
+}
+
+// src/lib/procedural-extractor.ts
+init_memories();
+init_database();
+var SYSTEM_PROMPT3 = `You extract procedural knowledge from session transcripts \u2014 workflows, step sequences, and problem-solution patterns.
+
+For each procedure found, output a JSON array of objects:
+{
+  "title": "short name for the workflow",
+  "steps": [
+    {"action": "what to do", "when_to_use": "activation context for this step"},
+    {"action": "next step", "when_to_use": "activation context"}
+  ],
+  "failure_patterns": ["what to avoid and why"],
+  "when_to_use": "overall activation context for the whole procedure"
+}
+
+Focus on:
+1. Multi-step workflows that were completed successfully
+2. Step sequences where order matters
+3. Failure \u2192 recovery patterns (what went wrong, how it was fixed)
+4. Problem-solution pairs (when X happens, do Y)
+
+Only extract non-trivial procedures (3+ steps or genuinely useful patterns).
+Output ONLY the JSON array.`;
+async function extractProcedures(transcript, options) {
+  const apiKey = process.env["ANTHROPIC_API_KEY"];
+  if (!apiKey)
+    return [];
+  try {
+    const truncated = transcript.length > 8000 ? transcript.slice(0, 8000) + `
+[...truncated]` : transcript;
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "claude-haiku-4-5-20251001",
+        max_tokens: 2000,
+        system: SYSTEM_PROMPT3,
+        messages: [{ role: "user", content: `Extract procedures from this session:
+
+${truncated}` }]
+      })
+    });
+    if (!response.ok)
+      return [];
+    const data = await response.json();
+    const text = data.content?.[0]?.text?.trim();
+    if (!text)
+      return [];
+    const procedures = JSON.parse(text);
+    if (!Array.isArray(procedures))
+      return [];
+    for (const proc of procedures) {
+      if (!proc.title || !proc.steps?.length)
+        continue;
+      const sequenceGroup = `proc-${shortUuid()}`;
+      for (let i = 0;i < proc.steps.length; i++) {
+        const step = proc.steps[i];
+        if (!step)
+          continue;
+        try {
+          createMemory({
+            key: `${sequenceGroup}-step-${i + 1}`,
+            value: step.action,
+            category: "procedural",
+            scope: "shared",
+            importance: 7,
+            source: "auto",
+            tags: ["procedure", "auto-extracted", proc.title.toLowerCase().replace(/\s+/g, "-")],
+            when_to_use: step.when_to_use || proc.when_to_use,
+            sequence_group: sequenceGroup,
+            sequence_order: i + 1,
+            agent_id: options?.agent_id,
+            project_id: options?.project_id,
+            session_id: options?.session_id
+          });
+        } catch {}
+      }
+      for (const pattern of proc.failure_patterns || []) {
+        try {
+          createMemory({
+            key: `${sequenceGroup}-warning-${shortUuid()}`,
+            value: `WARNING: ${pattern}`,
+            category: "procedural",
+            scope: "shared",
+            importance: 8,
+            source: "auto",
+            tags: ["procedure", "failure-pattern", "auto-extracted"],
+            when_to_use: proc.when_to_use,
+            sequence_group: sequenceGroup,
+            sequence_order: 999,
+            agent_id: options?.agent_id,
+            project_id: options?.project_id,
+            session_id: options?.session_id
+          });
+        } catch {}
+      }
+    }
+    return procedures;
+  } catch {
+    return [];
+  }
+}
+
+// src/lib/session-processor.ts
 var SESSION_EXTRACTION_USER_TEMPLATE = (chunk, sessionId) => `Extract memories from this session chunk (session: ${sessionId}):
 
 ${chunk}
@@ -10802,6 +12063,20 @@ async function processSessionJob(jobId, db) {
     }
   }
   result.memoriesExtracted = totalMemories;
+  try {
+    await extractToolLessons(job.transcript, {
+      agent_id: job.agent_id ?? undefined,
+      project_id: job.project_id ?? undefined,
+      session_id: job.session_id
+    });
+  } catch {}
+  try {
+    await extractProcedures(job.transcript, {
+      agent_id: job.agent_id ?? undefined,
+      project_id: job.project_id ?? undefined,
+      session_id: job.session_id
+    });
+  } catch {}
   try {
     if (result.errors.length > 0 && result.chunksProcessed === 0) {
       updateSessionJob(jobId, {
@@ -10862,17 +12137,1430 @@ async function _processNext() {
     }
   }
 }
-
+
+// src/lib/session-watcher.ts
+import { watch, existsSync as existsSync4, statSync as statSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
+import { readdirSync as readdirSync2 } from "fs";
+function encodeCwd(cwd) {
+  return cwd.replace(/\//g, "-");
+}
+function getProjectsDir() {
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join4(home, ".claude", "projects");
+}
+function findActiveSession(projectDir) {
+  if (!existsSync4(projectDir))
+    return null;
+  const files = readdirSync2(projectDir).filter((f) => f.endsWith(".jsonl")).map((f) => ({
+    name: f,
+    path: join4(projectDir, f),
+    mtime: statSync2(join4(projectDir, f)).mtimeMs
+  })).sort((a, b) => b.mtime - a.mtime);
+  return files[0]?.path || null;
+}
+var _watcher = null;
+var _lastOffset = 0;
+var _watchedFile = null;
+var _callback = null;
+var _pollInterval = null;
+function processNewLines(filePath, callback) {
+  try {
+    const stat = statSync2(filePath);
+    if (stat.size <= _lastOffset)
+      return;
+    const content = readFileSync2(filePath, "utf-8");
+    const newContent = content.slice(_lastOffset);
+    _lastOffset = stat.size;
+    const lines = newContent.split(`
+`).filter((l) => l.trim());
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        const msg = parsed?.message;
+        if (!msg)
+          continue;
+        const sessionMsg = {
+          role: msg.role || "user",
+          content: msg.content || "",
+          timestamp: new Date().toISOString()
+        };
+        if (Array.isArray(msg.content)) {
+          const toolUses = msg.content.filter((c) => c.type === "tool_use").map((c) => ({ name: c.name, input: c.input }));
+          if (toolUses.length > 0) {
+            sessionMsg.tool_use = toolUses;
+          }
+        }
+        callback(sessionMsg);
+      } catch {}
+    }
+  } catch {}
+}
+function startSessionWatcher(cwd, callback) {
+  stopSessionWatcher();
+  const projectDir = join4(getProjectsDir(), encodeCwd(cwd));
+  const sessionFile = findActiveSession(projectDir);
+  if (!sessionFile) {
+    return { sessionFile: null };
+  }
+  _watchedFile = sessionFile;
+  _callback = callback;
+  _lastOffset = statSync2(sessionFile).size;
+  try {
+    _watcher = watch(sessionFile, () => {
+      if (_callback && _watchedFile) {
+        processNewLines(_watchedFile, _callback);
+      }
+    });
+  } catch {}
+  _pollInterval = setInterval(() => {
+    if (_callback && _watchedFile) {
+      processNewLines(_watchedFile, _callback);
+    }
+  }, 2000);
+  return { sessionFile };
+}
+function stopSessionWatcher() {
+  if (_watcher) {
+    _watcher.close();
+    _watcher = null;
+  }
+  if (_pollInterval) {
+    clearInterval(_pollInterval);
+    _pollInterval = null;
+  }
+  _watchedFile = null;
+  _callback = null;
+  _lastOffset = 0;
+}
+function getWatcherStatus() {
+  return {
+    active: _watcher !== null || _pollInterval !== null,
+    watching_file: _watchedFile,
+    last_offset: _lastOffset
+  };
+}
+
+// src/lib/context-extractor.ts
+var _recentContexts = [];
+var MAX_RECENT = 5;
+function wordSimilarity(a, b) {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  if (wordsA.size === 0 || wordsB.size === 0)
+    return 0;
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w))
+      intersection++;
+  }
+  const union = new Set([...wordsA, ...wordsB]).size;
+  return union > 0 ? intersection / union : 0;
+}
+function isDuplicate2(text) {
+  for (const recent of _recentContexts) {
+    if (wordSimilarity(text, recent) > 0.9)
+      return true;
+  }
+  return false;
+}
+function addToRecent(text) {
+  _recentContexts.push(text);
+  if (_recentContexts.length > MAX_RECENT) {
+    _recentContexts.shift();
+  }
+}
+var TOOL_NAMES = new Set([
+  "bash",
+  "read",
+  "write",
+  "edit",
+  "glob",
+  "grep",
+  "agent",
+  "memory_save",
+  "memory_recall",
+  "memory_search",
+  "memory_inject",
+  "memory_context",
+  "memory_profile",
+  "memory_save_tool_event",
+  "git",
+  "npm",
+  "bun",
+  "docker",
+  "kubectl",
+  "curl"
+]);
+function detectTools(text) {
+  const found = [];
+  const lower = text.toLowerCase();
+  for (const tool of TOOL_NAMES) {
+    if (lower.includes(tool))
+      found.push(tool);
+  }
+  return found;
+}
+function extractContext(message) {
+  let contextText = "";
+  let source = "user";
+  let isSignificant = false;
+  if (message.role === "user") {
+    if (typeof message.content === "string") {
+      contextText = message.content;
+    } else if (Array.isArray(message.content)) {
+      contextText = message.content.filter((c) => c.type === "text").map((c) => c.text || "").join(" ");
+    }
+    source = "user";
+    isSignificant = contextText.length > 10;
+  } else if (message.role === "assistant") {
+    if (message.tool_use && message.tool_use.length > 0) {
+      const parts = message.tool_use.map((tu) => {
+        const inputSummary = tu.input ? Object.entries(tu.input).filter(([k]) => ["command", "pattern", "query", "file_path", "description", "prompt", "key", "value"].includes(k)).map(([k, v]) => `${k}=${String(v).slice(0, 100)}`).join(", ") : "";
+        return `${tu.name}(${inputSummary})`;
+      });
+      contextText = parts.join("; ");
+      source = "tool_use";
+      isSignificant = false;
+    } else if (typeof message.content === "string") {
+      contextText = message.content.slice(0, 500);
+      source = "assistant";
+      isSignificant = false;
+    } else if (Array.isArray(message.content)) {
+      contextText = message.content.filter((c) => c.type === "text").map((c) => (c.text || "").slice(0, 200)).join(" ");
+      source = "assistant";
+      isSignificant = false;
+    }
+  }
+  const errorPatterns = ["error", "failed", "exception", "enoent", "permission denied", "not found", "timeout"];
+  if (errorPatterns.some((p) => contextText.toLowerCase().includes(p))) {
+    isSignificant = true;
+  }
+  if (isSignificant && isDuplicate2(contextText)) {
+    isSignificant = false;
+  }
+  if (isSignificant) {
+    addToRecent(contextText);
+  }
+  return {
+    context_text: contextText,
+    tools_mentioned: detectTools(contextText),
+    is_significant: isSignificant,
+    source
+  };
+}
+function resetContext() {
+  _recentContexts.length = 0;
+}
+
+// src/lib/activation-matcher.ts
+init_memories();
+var _recentlyPushed = new Map;
+var DEDUP_WINDOW_MS = 5 * 60 * 1000;
+function cleanRecentlyPushed() {
+  const cutoff = Date.now() - DEDUP_WINDOW_MS;
+  for (const [id, ts] of _recentlyPushed) {
+    if (ts < cutoff)
+      _recentlyPushed.delete(id);
+  }
+}
+function markAsPushed(memoryIds) {
+  const now2 = Date.now();
+  for (const id of memoryIds) {
+    _recentlyPushed.set(id, now2);
+  }
+}
+async function findActivatedMemories(contextText, options) {
+  if (!contextText || contextText.length < 10)
+    return [];
+  const minSimilarity = options?.min_similarity || 0.4;
+  const maxResults = options?.max_results || 5;
+  try {
+    const results = await semanticSearch(contextText, {
+      threshold: minSimilarity,
+      limit: maxResults * 2,
+      project_id: options?.project_id,
+      agent_id: options?.agent_id
+    });
+    if (!results || results.length === 0) {
+      return fallbackKeywordMatch(contextText, options);
+    }
+    cleanRecentlyPushed();
+    let filtered = results.map((r) => r.memory).filter((m) => !_recentlyPushed.has(m.id)).filter((m) => m.status === "active");
+    filtered = filtered.map((m) => ({
+      memory: m,
+      score: computeDecayScore({
+        importance: m.importance,
+        access_count: m.access_count,
+        accessed_at: m.accessed_at,
+        created_at: m.created_at,
+        pinned: m.pinned
+      })
+    })).sort((a, b) => b.score - a.score).slice(0, maxResults).map((r) => r.memory);
+    return filtered;
+  } catch {
+    return fallbackKeywordMatch(contextText, options);
+  }
+}
+function fallbackKeywordMatch(contextText, options) {
+  try {
+    const allMemories = listMemories({
+      project_id: options?.project_id,
+      status: "active",
+      limit: 100
+    });
+    const contextWords = new Set(contextText.toLowerCase().split(/\s+/).filter((w) => w.length > 3));
+    const scored = allMemories.filter((m) => m.when_to_use).filter((m) => !_recentlyPushed.has(m.id)).map((m) => {
+      const wtuWords = m.when_to_use.toLowerCase().split(/\s+/);
+      const overlap = wtuWords.filter((w) => contextWords.has(w)).length;
+      return { memory: m, score: overlap };
+    }).filter((r) => r.score > 0).sort((a, b) => b.score - a.score).slice(0, options?.max_results || 5);
+    return scored.map((r) => r.memory);
+  } catch {
+    return [];
+  }
+}
+function resetRecentlyPushed() {
+  _recentlyPushed.clear();
+}
+function getRecentlyPushedCount() {
+  cleanRecentlyPushed();
+  return _recentlyPushed.size;
+}
+
+// src/lib/session-registry.ts
+import { Database as Database2 } from "bun:sqlite";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname4, join as join5 } from "path";
+var DB_PATH = join5(process.env["HOME"] || process.env["USERPROFILE"] || "~", ".open-sessions-registry.db");
+var _db2 = null;
+function getDb() {
+  if (_db2)
+    return _db2;
+  const dir = dirname4(DB_PATH);
+  if (!existsSync5(dir))
+    mkdirSync2(dir, { recursive: true });
+  _db2 = new Database2(DB_PATH, { create: true });
+  _db2.run("PRAGMA journal_mode = WAL");
+  _db2.run("PRAGMA busy_timeout = 3000");
+  _db2.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      pid INTEGER NOT NULL,
+      cwd TEXT NOT NULL,
+      git_root TEXT,
+      agent_name TEXT,
+      project_name TEXT,
+      tty TEXT,
+      mcp_server TEXT NOT NULL,
+      metadata TEXT DEFAULT '{}',
+      registered_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_pid_mcp
+      ON sessions(pid, mcp_server);
+    CREATE INDEX IF NOT EXISTS idx_sessions_project
+      ON sessions(project_name);
+    CREATE INDEX IF NOT EXISTS idx_sessions_agent
+      ON sessions(agent_name);
+    CREATE INDEX IF NOT EXISTS idx_sessions_git_root
+      ON sessions(git_root);
+  `);
+  return _db2;
+}
+function generateId() {
+  return crypto.randomUUID().slice(0, 8);
+}
+function now2() {
+  return new Date().toISOString();
+}
+function parseRow2(row) {
+  return {
+    id: row["id"],
+    pid: row["pid"],
+    cwd: row["cwd"],
+    git_root: row["git_root"] || null,
+    agent_name: row["agent_name"] || null,
+    project_name: row["project_name"] || null,
+    tty: row["tty"] || null,
+    mcp_server: row["mcp_server"],
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    registered_at: row["registered_at"],
+    last_seen_at: row["last_seen_at"]
+  };
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function registerSession(opts) {
+  const db = getDb();
+  const pid = process.pid;
+  const cwd = opts.cwd || process.cwd();
+  const id = generateId();
+  const timestamp = now2();
+  const existing = db.query("SELECT id FROM sessions WHERE pid = ? AND mcp_server = ?").get(pid, opts.mcp_server);
+  if (existing) {
+    db.run(`UPDATE sessions SET agent_name = ?, project_name = ?, cwd = ?,
+       git_root = ?, tty = ?, metadata = ?, last_seen_at = ? WHERE id = ?`, [
+      opts.agent_name || null,
+      opts.project_name || null,
+      cwd,
+      opts.git_root || null,
+      opts.tty || null,
+      JSON.stringify(opts.metadata || {}),
+      timestamp,
+      existing.id
+    ]);
+    return getSession(existing.id);
+  }
+  db.run(`INSERT INTO sessions (id, pid, cwd, git_root, agent_name, project_name, tty, mcp_server, metadata, registered_at, last_seen_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    pid,
+    cwd,
+    opts.git_root || null,
+    opts.agent_name || null,
+    opts.project_name || null,
+    opts.tty || null,
+    opts.mcp_server,
+    JSON.stringify(opts.metadata || {}),
+    timestamp,
+    timestamp
+  ]);
+  return getSession(id);
+}
+function heartbeatSession(id) {
+  const db = getDb();
+  db.run("UPDATE sessions SET last_seen_at = ? WHERE id = ?", [now2(), id]);
+}
+function unregisterSession(id) {
+  const db = getDb();
+  db.run("DELETE FROM sessions WHERE id = ?", [id]);
+}
+function getSession(id) {
+  const db = getDb();
+  const row = db.query("SELECT * FROM sessions WHERE id = ?").get(id);
+  return row ? parseRow2(row) : null;
+}
+function cleanStaleSessions() {
+  const db = getDb();
+  const rows = db.query("SELECT id, pid FROM sessions").all();
+  let cleaned = 0;
+  for (const row of rows) {
+    if (!isProcessAlive(row.pid)) {
+      db.run("DELETE FROM sessions WHERE id = ?", [row.id]);
+      cleaned++;
+    }
+  }
+  return cleaned;
+}
+
+// src/lib/channel-pusher.ts
+var _serverRef = null;
+function setServerRef(server) {
+  _serverRef = server;
+}
+async function pushMemoryNotification(memories, context, type = "auto-inject") {
+  if (!_serverRef)
+    return false;
+  if (memories.length === 0)
+    return false;
+  const formatted = formatMemories(memories, context, type);
+  try {
+    const server = _serverRef.server || _serverRef;
+    await server.notification({
+      method: "notifications/claude/channel",
+      params: {
+        content: formatted,
+        meta: {
+          source: "mementos",
+          type,
+          memory_count: memories.length,
+          context: context.slice(0, 200)
+        }
+      }
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+async function pushRawNotification(text, type = "info") {
+  if (!_serverRef)
+    return false;
+  try {
+    const server = _serverRef.server || _serverRef;
+    await server.notification({
+      method: "notifications/claude/channel",
+      params: {
+        content: text,
+        meta: { source: "mementos", type }
+      }
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function formatMemories(memories, context, type) {
+  const header = type === "session-briefing" ? "\uD83D\uDCCB Mementos Session Briefing" : `\u26A1 Mementos activated (${context.slice(0, 100)})`;
+  const lines = memories.map((m) => {
+    const importance = m.importance >= 8 ? "\u2757" : "";
+    const flag = m.flag ? ` \u26A0\uFE0F ${m.flag}` : "";
+    return `\u2022 [${m.category}] ${m.key}: ${m.value.slice(0, 200)}${m.value.length > 200 ? "..." : ""} (importance: ${m.importance})${importance}${flag}`;
+  });
+  const footer = memories.length > 3 ? `
+Use memory_recall(key="...") for full details on any of these.` : "";
+  return `${header}
+
+${lines.join(`
+`)}${footer}`;
+}
+function formatBriefing(sections) {
+  const parts = [];
+  parts.push(`\uD83D\uDCCB Mementos Session Briefing${sections.projectName ? ` \u2014 project: ${sections.projectName}` : ""}`);
+  if (sections.profile) {
+    parts.push(`
+## Profile
+${sections.profile}`);
+  }
+  if (sections.memories && sections.memories.length > 0) {
+    parts.push(`
+## Key Memories (${sections.memories.length})`);
+    for (const m of sections.memories) {
+      parts.push(`\u2022 [${m.category}] ${m.key}: ${m.value.slice(0, 150)}${m.value.length > 150 ? "..." : ""}`);
+    }
+  }
+  if (sections.lastSession) {
+    parts.push(`
+## Last Session
+${sections.lastSession}`);
+  }
+  if (sections.flagged && sections.flagged.length > 0) {
+    parts.push(`
+## Needs Attention`);
+    for (const m of sections.flagged) {
+      parts.push(`\u26A0\uFE0F [${m.flag}] ${m.key}: ${m.value.slice(0, 150)}`);
+    }
+  }
+  parts.push(`
+Use memory_recall, memory_search, or memory_inject for more details.`);
+  return parts.join(`
+`);
+}
+
+// src/lib/session-start-briefing.ts
+init_memories();
+async function pushSessionBriefing(options) {
+  if (!options.project_id)
+    return false;
+  try {
+    let profile = null;
+    try {
+      const { synthesizeProfile: synthesizeProfile2 } = await Promise.resolve().then(() => (init_profile_synthesizer(), exports_profile_synthesizer));
+      const result = await synthesizeProfile2({
+        project_id: options.project_id,
+        scope: "project"
+      });
+      if (result)
+        profile = result.profile;
+    } catch {}
+    const pinnedMemories = listMemories({
+      project_id: options.project_id,
+      pinned: true,
+      status: "active",
+      limit: 5
+    });
+    const topMemories = listMemories({
+      project_id: options.project_id,
+      status: "active",
+      min_importance: 7,
+      limit: 10
+    });
+    const seenIds = new Set;
+    const memories = [];
+    for (const m of [...pinnedMemories, ...topMemories]) {
+      if (!seenIds.has(m.id) && !m.key.startsWith("_profile_")) {
+        seenIds.add(m.id);
+        memories.push(m);
+        if (memories.length >= 10)
+          break;
+      }
+    }
+    let lastSession = null;
+    try {
+      const sessionMemories = listMemories({
+        project_id: options.project_id,
+        category: "history",
+        status: "active",
+        limit: 5
+      });
+      const summary = sessionMemories.find((m) => m.key.includes("summary"));
+      if (summary)
+        lastSession = summary.value;
+    } catch {}
+    const allMemories = listMemories({
+      project_id: options.project_id,
+      status: "active",
+      limit: 100
+    });
+    const flagged = allMemories.filter((m) => m.flag && m.flag !== "");
+    if (!profile && memories.length === 0 && !lastSession && flagged.length === 0) {
+      return false;
+    }
+    const briefingText = formatBriefing({
+      profile: profile || undefined,
+      memories: memories.length > 0 ? memories : undefined,
+      lastSession: lastSession || undefined,
+      flagged: flagged.length > 0 ? flagged : undefined,
+      projectName: options.project_name
+    });
+    return await pushRawNotification(briefingText, "session-briefing");
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/auto-inject-orchestrator.ts
+var DEFAULT_CONFIG = {
+  enabled: true,
+  throttle_ms: 30000,
+  debounce_ms: 2000,
+  max_pushes_per_5min: 5,
+  min_similarity: 0.4,
+  session_briefing: true
+};
+var _config = { ...DEFAULT_CONFIG };
+var _running = false;
+var _sessionId = null;
+var _heartbeatInterval = null;
+var _debounceTimer = null;
+var _lastPushTime = 0;
+var _pushCount5min = [];
+var _pendingMessages = [];
+var _pushHistory = [];
+var MAX_HISTORY = 20;
+async function processMessages() {
+  if (!_running || !_config.enabled)
+    return;
+  const now3 = Date.now();
+  if (now3 - _lastPushTime < _config.throttle_ms)
+    return;
+  _pushCount5min = _pushCount5min.filter((p) => now3 - p.ts < 5 * 60 * 1000);
+  if (_pushCount5min.length >= _config.max_pushes_per_5min)
+    return;
+  let bestContext = null;
+  for (const msg of _pendingMessages) {
+    const extracted = extractContext(msg);
+    if (extracted.is_significant && extracted.context_text.length > 10) {
+      bestContext = { context_text: extracted.context_text, tools_mentioned: extracted.tools_mentioned };
+    }
+  }
+  _pendingMessages = [];
+  if (!bestContext)
+    return;
+  try {
+    const memories = await findActivatedMemories(bestContext.context_text, {
+      min_similarity: _config.min_similarity,
+      max_results: 5
+    });
+    if (memories.length === 0)
+      return;
+    const pushed = await pushMemoryNotification(memories, bestContext.context_text);
+    if (pushed) {
+      markAsPushed(memories.map((m) => m.id));
+      _lastPushTime = Date.now();
+      _pushCount5min.push({ ts: Date.now() });
+      _pushHistory.unshift({
+        timestamp: new Date().toISOString(),
+        context: bestContext.context_text.slice(0, 200),
+        memory_count: memories.length
+      });
+      if (_pushHistory.length > MAX_HISTORY)
+        _pushHistory.pop();
+    }
+  } catch {}
+}
+function onNewMessage(message) {
+  if (!_running || !_config.enabled)
+    return;
+  _pendingMessages.push(message);
+  if (_debounceTimer)
+    clearTimeout(_debounceTimer);
+  _debounceTimer = setTimeout(() => {
+    processMessages();
+  }, _config.debounce_ms);
+}
+async function startAutoInject(options) {
+  const envEnabled = process.env["MEMENTOS_AUTO_INJECT"] === "true";
+  if (!envEnabled && !options.config?.enabled) {
+    return { started: false, session_id: null, watcher_file: null, briefing_pushed: false };
+  }
+  _config = { ...DEFAULT_CONFIG, ...options.config };
+  if (envEnabled)
+    _config.enabled = true;
+  setServerRef(options.server);
+  const cwd = options.cwd || process.cwd();
+  const session = registerSession({
+    mcp_server: "mementos",
+    agent_name: options.agent_name,
+    project_name: options.project_name,
+    cwd,
+    git_root: options.git_root
+  });
+  _sessionId = session.id;
+  _heartbeatInterval = setInterval(() => {
+    if (_sessionId)
+      heartbeatSession(_sessionId);
+    cleanStaleSessions();
+  }, 15000);
+  let briefingPushed = false;
+  if (_config.session_briefing) {
+    try {
+      briefingPushed = await pushSessionBriefing({
+        project_id: options.project_id,
+        project_name: options.project_name,
+        agent_id: options.agent_id
+      });
+    } catch {}
+  }
+  const { sessionFile } = startSessionWatcher(cwd, onNewMessage);
+  _running = true;
+  return {
+    started: true,
+    session_id: _sessionId,
+    watcher_file: sessionFile,
+    briefing_pushed: briefingPushed
+  };
+}
+function stopAutoInject() {
+  _running = false;
+  if (_debounceTimer) {
+    clearTimeout(_debounceTimer);
+    _debounceTimer = null;
+  }
+  if (_heartbeatInterval) {
+    clearInterval(_heartbeatInterval);
+    _heartbeatInterval = null;
+  }
+  stopSessionWatcher();
+  resetContext();
+  resetRecentlyPushed();
+  if (_sessionId) {
+    try {
+      unregisterSession(_sessionId);
+    } catch {}
+    _sessionId = null;
+  }
+  _pendingMessages = [];
+}
+function getAutoInjectConfig() {
+  return { ..._config };
+}
+function updateAutoInjectConfig(updates) {
+  _config = { ..._config, ...updates };
+  return { ..._config };
+}
+function getAutoInjectStatus() {
+  const now3 = Date.now();
+  const recent5min = _pushCount5min.filter((p) => now3 - p.ts < 5 * 60 * 1000);
+  const nextAvailable = Math.max(0, _config.throttle_ms - (now3 - _lastPushTime));
+  return {
+    running: _running,
+    config: { ..._config },
+    session_id: _sessionId,
+    watcher: getWatcherStatus(),
+    pushes: {
+      total: _pushHistory.length,
+      last_5min: recent5min.length,
+      recently_pushed_memories: getRecentlyPushedCount(),
+      next_available_in_ms: nextAvailable
+    },
+    history: [..._pushHistory]
+  };
+}
+
+// src/lib/asmr/fact-agent.ts
+init_memories();
+function escapeFts5Token(token) {
+  return `"${token.replace(/"/g, '""')}"`;
+}
+function hasFts5Table2(db) {
+  try {
+    const row = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'").get();
+    return !!row;
+  } catch {
+    return false;
+  }
+}
+function buildScopeFilter(opts) {
+  const conditions = [
+    "m.status = 'active'",
+    "(m.expires_at IS NULL OR m.expires_at >= datetime('now'))",
+    "m.category IN ('preference', 'fact', 'knowledge')"
+  ];
+  const params = [];
+  if (opts.project_id) {
+    conditions.push("m.project_id = ?");
+    params.push(opts.project_id);
+  }
+  if (opts.agent_id) {
+    conditions.push("m.agent_id = ?");
+    params.push(opts.agent_id);
+  }
+  return { conditions, params };
+}
+function scoreFactMemory(memory, queryLower) {
+  const keyLower = memory.key.toLowerCase();
+  const valueLower = memory.value.toLowerCase();
+  let score = 0;
+  let matchField = "value";
+  if (keyLower === queryLower) {
+    score = 10;
+    matchField = "key (exact)";
+  } else if (keyLower.includes(queryLower)) {
+    score = 7;
+    matchField = "key (partial)";
+  } else if (valueLower.includes(queryLower)) {
+    score = 3;
+    matchField = "value";
+  }
+  if (score === 0) {
+    const tokens = queryLower.split(/\s+/).filter(Boolean);
+    if (tokens.length > 1) {
+      let tokenHits = 0;
+      for (const token of tokens) {
+        if (keyLower.includes(token))
+          tokenHits += 2;
+        else if (valueLower.includes(token))
+          tokenHits += 1;
+      }
+      if (tokenHits > 0) {
+        score = tokenHits / tokens.length * 5;
+        matchField = "tokens";
+      }
+    }
+  }
+  if (memory.pinned)
+    score *= 1.3;
+  const effectiveImportance = computeDecayScore(memory);
+  score = score * effectiveImportance / 10;
+  if (memory.importance >= 7)
+    score *= 1.2;
+  return { score, matchField };
+}
+async function runFactAgent(db, query, opts) {
+  const queryLower = query.toLowerCase().trim();
+  if (!queryLower)
+    return { memories: [], reasoning: "Empty query" };
+  const { conditions, params } = buildScopeFilter(opts);
+  const limit = (opts.max_results ?? 20) * 2;
+  let rows;
+  if (hasFts5Table2(db)) {
+    const tokens = queryLower.split(/\s+/).filter(Boolean);
+    const ftsQuery = tokens.map(escapeFts5Token).join(" ");
+    try {
+      const ftsCondition = `m.rowid IN (SELECT f.rowid FROM memories_fts f WHERE memories_fts MATCH ?)`;
+      const sql = `SELECT m.* FROM memories m WHERE ${ftsCondition} AND ${conditions.join(" AND ")} LIMIT ?`;
+      rows = db.query(sql).all(ftsQuery, ...params, limit);
+    } catch {
+      rows = [];
+    }
+  } else {
+    rows = [];
+  }
+  if (rows.length === 0) {
+    const likePattern = `%${queryLower}%`;
+    const likeSql = `SELECT m.* FROM memories m WHERE (m.key LIKE ? OR m.value LIKE ?) AND ${conditions.join(" AND ")} LIMIT ?`;
+    rows = db.query(likeSql).all(likePattern, likePattern, ...params, limit);
+  }
+  const results = [];
+  for (const row of rows) {
+    const memory = parseMemoryRow(row);
+    const { score, matchField } = scoreFactMemory(memory, queryLower);
+    if (score <= 0)
+      continue;
+    results.push({
+      memory,
+      score,
+      source_agent: "facts",
+      reasoning: `Direct fact match on ${matchField}`,
+      verbatim_excerpt: memory.value
+    });
+  }
+  results.sort((a, b) => b.score - a.score);
+  const trimmed = results.slice(0, opts.max_results ?? 20);
+  return {
+    memories: trimmed,
+    reasoning: `Fact agent searched ${rows.length} candidate memories, returned ${trimmed.length} factual matches`
+  };
+}
+
+// src/lib/asmr/context-agent.ts
+init_memories();
+init_entities();
+init_entity_memories();
+function deduplicateCandidates(candidates) {
+  const seen = new Map;
+  for (const c of candidates) {
+    const existing = seen.get(c.memory.id);
+    if (!existing) {
+      seen.set(c.memory.id, c);
+    } else {
+      const existingTotal = existing.semanticScore + existing.entityLinkStrength;
+      const currentTotal = c.semanticScore + c.entityLinkStrength;
+      if (currentTotal > existingTotal) {
+        seen.set(c.memory.id, c);
+      }
+    }
+  }
+  return Array.from(seen.values());
+}
+async function runContextAgent(db, query, opts) {
+  const queryLower = query.toLowerCase().trim();
+  if (!queryLower)
+    return { memories: [], reasoning: "Empty query" };
+  const maxResults = opts.max_results ?? 20;
+  const candidates = [];
+  let semanticCount = 0;
+  let entityQueryCount = 0;
+  try {
+    const semanticResults = await semanticSearch(query, {
+      threshold: 0.3,
+      limit: maxResults * 2,
+      project_id: opts.project_id,
+      agent_id: opts.agent_id
+    }, db);
+    for (const sr of semanticResults) {
+      candidates.push({
+        memory: sr.memory,
+        semanticScore: sr.score,
+        entityLinkStrength: 0,
+        entityName: null,
+        entityRelation: null
+      });
+    }
+    semanticCount = semanticResults.length;
+  } catch {}
+  const topSemantic = candidates.slice(0, 10);
+  const entityMemoryIds = new Set;
+  for (const candidate of topSemantic) {
+    try {
+      const entities = getEntitiesForMemory(candidate.memory.id, db);
+      for (const entity of entities) {
+        const linkedMemories = getMemoriesForEntity(entity.id, db);
+        for (const mem of linkedMemories) {
+          if (entityMemoryIds.has(mem.id))
+            continue;
+          entityMemoryIds.add(mem.id);
+          candidates.push({
+            memory: mem,
+            semanticScore: 0,
+            entityLinkStrength: 1,
+            entityName: entity.name,
+            entityRelation: entity.type
+          });
+        }
+      }
+    } catch {}
+  }
+  try {
+    const matchingEntities = listEntities({ search: query, limit: 10, project_id: opts.project_id }, db);
+    const exactEntity = getEntityByName(query, undefined, opts.project_id, db);
+    if (exactEntity && !matchingEntities.find((e) => e.id === exactEntity.id)) {
+      matchingEntities.unshift(exactEntity);
+    }
+    for (const entity of matchingEntities) {
+      entityQueryCount++;
+      const linkedMemories = getMemoriesForEntity(entity.id, db);
+      for (const mem of linkedMemories) {
+        if (entityMemoryIds.has(mem.id))
+          continue;
+        entityMemoryIds.add(mem.id);
+        const nameMatch = entity.name.toLowerCase() === queryLower ? 1 : 0.7;
+        candidates.push({
+          memory: mem,
+          semanticScore: 0,
+          entityLinkStrength: nameMatch,
+          entityName: entity.name,
+          entityRelation: entity.type
+        });
+      }
+    }
+  } catch {}
+  const unique = deduplicateCandidates(candidates);
+  const results = [];
+  for (const c of unique) {
+    if (opts.project_id && c.memory.project_id && c.memory.project_id !== opts.project_id)
+      continue;
+    if (c.memory.status !== "active")
+      continue;
+    const effectiveImportance = computeDecayScore(c.memory) / 10;
+    const score = c.semanticScore * 0.4 + c.entityLinkStrength * 0.3 + effectiveImportance * 0.3;
+    let reasoning;
+    if (c.entityName) {
+      reasoning = `Found via entity ${c.entityName} (relation: ${c.entityRelation})`;
+    } else {
+      reasoning = `Semantic similarity match (score: ${c.semanticScore.toFixed(3)})`;
+    }
+    results.push({
+      memory: c.memory,
+      score,
+      source_agent: "context",
+      reasoning,
+      verbatim_excerpt: c.memory.value
+    });
+  }
+  results.sort((a, b) => b.score - a.score);
+  const trimmed = results.slice(0, maxResults);
+  return {
+    memories: trimmed,
+    reasoning: `Context agent found ${semanticCount} semantic matches, traversed ${entityQueryCount} entities, returned ${trimmed.length} contextual results`
+  };
+}
+
+// src/lib/asmr/temporal-agent.ts
+init_memories();
+function hasFts5Table3(db) {
+  try {
+    const row = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'").get();
+    return !!row;
+  } catch {
+    return false;
+  }
+}
+function escapeFts5Token2(token) {
+  return `"${token.replace(/"/g, '""')}"`;
+}
+function queryRelevance(memory, queryLower) {
+  const keyLower = memory.key.toLowerCase();
+  const valueLower = memory.value.toLowerCase();
+  if (keyLower === queryLower)
+    return 1;
+  if (keyLower.includes(queryLower))
+    return 0.8;
+  if (valueLower.includes(queryLower))
+    return 0.5;
+  const tokens = queryLower.split(/\s+/).filter(Boolean);
+  if (tokens.length > 1) {
+    let hits = 0;
+    for (const t of tokens) {
+      if (keyLower.includes(t) || valueLower.includes(t))
+        hits++;
+    }
+    return hits / tokens.length * 0.6;
+  }
+  return 0.1;
+}
+function formatDate(iso) {
+  if (!iso)
+    return "unknown";
+  return iso.slice(0, 10);
+}
+async function runTemporalAgent(db, query, opts) {
+  const queryLower = query.toLowerCase().trim();
+  if (!queryLower)
+    return { memories: [], reasoning: "Empty query" };
+  const maxResults = opts.max_results ?? 20;
+  const limit = maxResults * 3;
+  const conditions = [
+    "(m.expires_at IS NULL OR m.expires_at >= datetime('now'))"
+  ];
+  const params = [];
+  if (opts.project_id) {
+    conditions.push("m.project_id = ?");
+    params.push(opts.project_id);
+  }
+  if (opts.agent_id) {
+    conditions.push("m.agent_id = ?");
+    params.push(opts.agent_id);
+  }
+  let temporalRows = [];
+  const temporalCondition = "(m.valid_from IS NOT NULL OR m.valid_until IS NOT NULL)";
+  if (hasFts5Table3(db)) {
+    const tokens = queryLower.split(/\s+/).filter(Boolean);
+    const ftsQuery = tokens.map(escapeFts5Token2).join(" ");
+    try {
+      const ftsCondition = `m.rowid IN (SELECT f.rowid FROM memories_fts f WHERE memories_fts MATCH ?)`;
+      const sql = `SELECT m.* FROM memories m WHERE ${ftsCondition} AND ${temporalCondition} AND ${conditions.join(" AND ")} ORDER BY m.valid_from DESC NULLS LAST LIMIT ?`;
+      temporalRows = db.query(sql).all(ftsQuery, ...params, limit);
+    } catch {
+      temporalRows = [];
+    }
+  }
+  if (temporalRows.length === 0) {
+    const likePattern = `%${queryLower}%`;
+    const sql = `SELECT m.* FROM memories m WHERE (m.key LIKE ? OR m.value LIKE ?) AND ${temporalCondition} AND ${conditions.join(" AND ")} ORDER BY m.valid_from DESC NULLS LAST LIMIT ?`;
+    temporalRows = db.query(sql).all(likePattern, likePattern, ...params, limit);
+  }
+  let supersededRows = [];
+  try {
+    const likePattern = `%${queryLower}%`;
+    const sql = `SELECT m.* FROM memories m WHERE (m.key LIKE ? OR m.value LIKE ?) AND (m.status = 'archived' OR m.valid_until IS NOT NULL) ${conditions.length > 0 ? "AND " + conditions.join(" AND ") : ""} ORDER BY m.updated_at DESC LIMIT ?`;
+    supersededRows = db.query(sql).all(likePattern, likePattern, ...params, limit);
+  } catch {}
+  const seen = new Map;
+  const allRows = [...temporalRows, ...supersededRows];
+  for (const row of allRows) {
+    const memory = parseMemoryRow(row);
+    if (!seen.has(memory.id)) {
+      seen.set(memory.id, memory);
+    }
+  }
+  const memories = Array.from(seen.values());
+  const timeline = [];
+  const results = [];
+  for (const memory of memories) {
+    const hasTemporal = memory.valid_from !== null || memory.valid_until !== null;
+    const isSuperseded = memory.status === "archived";
+    const relevance = queryRelevance(memory, queryLower);
+    let versions = [];
+    let newerVersionNote = "";
+    try {
+      versions = getMemoryVersions(memory.id, db);
+      if (versions.length > 1) {
+        const latest = versions[versions.length - 1];
+        if (latest.version > memory.version) {
+          newerVersionNote = `, superseded at version ${latest.version}`;
+        }
+      }
+    } catch {}
+    if (hasTemporal || isSuperseded) {
+      const from = formatDate(memory.valid_from);
+      const until = formatDate(memory.valid_until);
+      const status = isSuperseded ? " [superseded]" : "";
+      timeline.push(`${from} - ${until}: ${memory.key}${status}`);
+    }
+    const recencyMs = memory.valid_from ? Date.now() - new Date(memory.valid_from).getTime() : Date.now() - new Date(memory.created_at).getTime();
+    const daysSince = recencyMs / (1000 * 60 * 60 * 24);
+    const recencyScore = Math.max(0, 1 - daysSince / 365);
+    const temporalBonus = hasTemporal ? 1 : 0.3;
+    const effectiveImportance = computeDecayScore(memory) / 10;
+    const score = recencyScore * 0.4 + relevance * 0.3 + temporalBonus * 0.3;
+    const finalScore = score * effectiveImportance;
+    let reasoning;
+    if (isSuperseded) {
+      reasoning = `Superseded memory from ${formatDate(memory.valid_from)}${newerVersionNote}`;
+    } else if (memory.valid_until && new Date(memory.valid_until) < new Date) {
+      reasoning = `Expired temporal fact (valid ${formatDate(memory.valid_from)} to ${formatDate(memory.valid_until)})${newerVersionNote}`;
+    } else if (hasTemporal) {
+      reasoning = `Current as of ${formatDate(memory.valid_from)}${newerVersionNote}`;
+    } else {
+      reasoning = `Historical record from ${formatDate(memory.created_at)}${newerVersionNote}`;
+    }
+    results.push({
+      memory,
+      score: finalScore,
+      source_agent: "temporal",
+      reasoning,
+      verbatim_excerpt: memory.value
+    });
+  }
+  timeline.sort();
+  results.sort((a, b) => b.score - a.score);
+  const trimmed = results.slice(0, maxResults);
+  return {
+    memories: trimmed,
+    reasoning: `Temporal agent found ${temporalRows.length} temporal memories and ${supersededRows.length} superseded records, built ${timeline.length}-entry timeline`
+  };
+}
+
+// src/lib/asmr/orchestrator.ts
+var DEFAULT_MAX_RESULTS = 20;
+function mergeResults(agentResults) {
+  const byId = new Map;
+  for (const { agent, result } of agentResults) {
+    for (const mem of result.memories) {
+      const existing = byId.get(mem.memory.id);
+      if (!existing) {
+        byId.set(mem.memory.id, {
+          best: mem,
+          sources: new Set([agent]),
+          maxScore: mem.score
+        });
+      } else {
+        existing.sources.add(agent);
+        if (mem.score > existing.maxScore) {
+          existing.best = mem;
+          existing.maxScore = mem.score;
+        }
+      }
+    }
+  }
+  const merged = [];
+  for (const [, entry] of byId) {
+    const multiAgentBoost = entry.sources.size > 1 ? 1.5 : 1;
+    merged.push({
+      ...entry.best,
+      score: entry.maxScore * multiAgentBoost
+    });
+  }
+  merged.sort((a, b) => b.score - a.score);
+  return merged;
+}
+function extractFacts(factResult) {
+  const facts = [];
+  const seen = new Set;
+  for (const mem of factResult.memories) {
+    const statement = `${mem.memory.key}: ${mem.memory.value}`;
+    if (!seen.has(mem.memory.id)) {
+      seen.add(mem.memory.id);
+      facts.push(statement);
+    }
+  }
+  return facts;
+}
+function extractTimeline(temporalResult) {
+  const entries = [];
+  const seen = new Set;
+  for (const mem of temporalResult.memories) {
+    if (seen.has(mem.memory.id))
+      continue;
+    seen.add(mem.memory.id);
+    const date = mem.memory.valid_from ?? mem.memory.created_at;
+    const status = mem.memory.status === "archived" ? " [superseded]" : "";
+    entries.push({
+      date,
+      label: `${date.slice(0, 10)}: ${mem.memory.key}${status}`
+    });
+  }
+  entries.sort((a, b) => a.date.localeCompare(b.date));
+  return entries.map((e) => e.label);
+}
+async function asmrRecall(db, query, opts) {
+  const options = {
+    max_results: DEFAULT_MAX_RESULTS,
+    include_reasoning: true,
+    ...opts
+  };
+  const start = performance.now();
+  const [factResult, contextResult, temporalResult] = await Promise.all([
+    runFactAgent(db, query, options),
+    runContextAgent(db, query, options),
+    runTemporalAgent(db, query, options)
+  ]);
+  const agentResults = [
+    { agent: "facts", result: factResult },
+    { agent: "context", result: contextResult },
+    { agent: "temporal", result: temporalResult }
+  ];
+  const merged = mergeResults(agentResults);
+  const trimmed = merged.slice(0, options.max_results ?? DEFAULT_MAX_RESULTS);
+  const facts = extractFacts(factResult);
+  const timeline = extractTimeline(temporalResult);
+  const agentsUsed = [];
+  if (factResult.memories.length > 0)
+    agentsUsed.push("facts");
+  if (contextResult.memories.length > 0)
+    agentsUsed.push("context");
+  if (temporalResult.memories.length > 0)
+    agentsUsed.push("temporal");
+  const reasoningParts = [
+    factResult.reasoning,
+    contextResult.reasoning,
+    temporalResult.reasoning
+  ].filter(Boolean);
+  const duration = Math.round(performance.now() - start);
+  return {
+    memories: trimmed,
+    facts,
+    timeline,
+    reasoning: reasoningParts.join(". "),
+    agents_used: agentsUsed,
+    duration_ms: duration
+  };
+}
+// src/lib/asmr/ensemble.ts
+var DEFAULT_MODEL = "gpt-4.1-mini";
+var ESCALATION_MODEL = "gpt-4.1";
+var CONSENSUS_THRESHOLD = 0.7;
+var VARIANT_PROMPTS = [
+  "Focus on the most recent and up-to-date facts. If there are contradictions, prefer the newer information.",
+  "Focus on factual accuracy. Only use information explicitly stated in the memories. Do not infer.",
+  "Focus on relationships and connections between entities. Consider how different facts relate to each other.",
+  "Focus on the chronological timeline. Consider when events happened and how the situation evolved over time.",
+  "Synthesize all available information into a comprehensive answer. Consider all perspectives and resolve contradictions.",
+  "Focus on preferences and personal information. Prioritize what the user has explicitly stated they prefer or want.",
+  "Be skeptical. Look for contradictions, outdated information, or facts that might no longer be true.",
+  "Focus on the most frequently mentioned and highly-rated facts. These are likely the most important."
+];
+function buildContext(result) {
+  const sections = [];
+  if (result.facts.length > 0) {
+    sections.push(`Known Facts:
+` + result.facts.map((f) => `- ${f}`).join(`
+`));
+  }
+  if (result.timeline.length > 0) {
+    sections.push(`Timeline:
+` + result.timeline.map((t) => `- ${t}`).join(`
+`));
+  }
+  const memories = result.memories.slice(0, 30);
+  if (memories.length > 0) {
+    sections.push(`Memory Excerpts:
+` + memories.map((m) => `[${m.source_agent}] ${m.memory.key}: ${m.verbatim_excerpt.slice(0, 500)}`).join(`
+
+`));
+  }
+  return sections.join(`
+
+---
+
+`);
+}
+async function callLLM(systemPrompt, userPrompt, model) {
+  const apiKey = process.env["OPENAI_API_KEY"] ?? process.env["LLM_API_KEY"];
+  if (!apiKey)
+    throw new Error("No API key for ensemble LLM calls");
+  const baseUrl = process.env["LLM_BASE_URL"] ?? "https://api.openai.com/v1";
+  const res = await fetch(`${baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ],
+      temperature: 0.3,
+      max_tokens: 1024
+    }),
+    signal: AbortSignal.timeout(30000)
+  });
+  if (!res.ok)
+    throw new Error(`LLM API ${res.status}`);
+  const data = await res.json();
+  return data.choices[0]?.message?.content ?? "";
+}
+function findMajority(answers) {
+  if (answers.length === 0)
+    return null;
+  const normalized = answers.map((a) => a.toLowerCase().trim().replace(/[.!?]+$/, ""));
+  const counts = new Map;
+  for (let i = 0;i < normalized.length; i++) {
+    const key = normalized[i];
+    const existing = counts.get(key);
+    if (existing) {
+      existing.count++;
+    } else {
+      counts.set(key, { original: answers[i], count: 1 });
+    }
+  }
+  let best = null;
+  for (const entry of counts.values()) {
+    if (!best || entry.count > best.count) {
+      best = entry;
+    }
+  }
+  return best ? { answer: best.original, count: best.count, total: answers.length } : null;
+}
+async function ensembleAnswer(context, query, opts) {
+  const numVariants = Math.min(opts?.variants ?? 5, VARIANT_PROMPTS.length);
+  const model = opts?.model ?? DEFAULT_MODEL;
+  const escalationModel = opts?.escalation_model ?? ESCALATION_MODEL;
+  const threshold = opts?.consensus_threshold ?? CONSENSUS_THRESHOLD;
+  const contextStr = buildContext(context);
+  if (!contextStr.trim()) {
+    return {
+      answer: "No relevant information found in memory.",
+      confidence: 0,
+      reasoning: "No context available from ASMR search agents.",
+      variants_used: 0,
+      consensus_reached: false,
+      escalated: false
+    };
+  }
+  const variantPromises = VARIANT_PROMPTS.slice(0, numVariants).map((variantInstruction) => callLLM(`You are a memory retrieval assistant. Answer the user's question based ONLY on the provided context.
+
+${variantInstruction}
+
+Context:
+${contextStr}`, query, model).catch(() => null));
+  const results = await Promise.all(variantPromises);
+  const answers = results.filter((r) => r !== null && r.trim().length > 0);
+  if (answers.length === 0) {
+    return {
+      answer: "Unable to generate an answer from the available context.",
+      confidence: 0,
+      reasoning: "All variant prompts failed.",
+      variants_used: numVariants,
+      consensus_reached: false,
+      escalated: false
+    };
+  }
+  const majority = findMajority(answers);
+  if (majority && majority.count / majority.total >= threshold) {
+    return {
+      answer: majority.answer,
+      confidence: majority.count / majority.total,
+      reasoning: `${majority.count}/${majority.total} variants agreed on this answer.`,
+      variants_used: numVariants,
+      consensus_reached: true,
+      escalated: false
+    };
+  }
+  try {
+    const escalationPrompt = `Multiple analysis variants produced different answers to the question. Review all of them and produce the single best answer.
+
+Question: ${query}
+
+Context:
+${contextStr}
+
+Variant answers:
+${answers.map((a, i) => `Variant ${i + 1}: ${a}`).join(`
+
+`)}
+
+Produce the single most accurate answer based on the context. If there are genuine contradictions in the data, acknowledge them.`;
+    const finalAnswer = await callLLM("You are an expert arbitrator. Given multiple candidate answers and the original context, determine the most accurate answer.", escalationPrompt, escalationModel);
+    return {
+      answer: finalAnswer,
+      confidence: 0.6,
+      reasoning: `No consensus (best: ${majority?.count ?? 0}/${answers.length}). Escalated to ${escalationModel} for conflict resolution.`,
+      variants_used: numVariants,
+      consensus_reached: false,
+      escalated: true
+    };
+  } catch {
+    return {
+      answer: majority?.answer ?? answers[0],
+      confidence: (majority?.count ?? 1) / answers.length,
+      reasoning: `No consensus, escalation failed. Returning best available answer (${majority?.count ?? 1}/${answers.length} agreement).`,
+      variants_used: numVariants,
+      consensus_reached: false,
+      escalated: false
+    };
+  }
+}
 // src/mcp/index.ts
 init_auto_memory();
 init_registry();
 import { createRequire } from "module";
 var _require = createRequire(import.meta.url);
 var _pkg = _require("../../package.json");
+var mcpServer = null;
 var server = new McpServer({
   name: "mementos",
   version: _pkg.version
+}, {
+  capabilities: {
+    experimental: { "claude/channel": {} }
+  },
+  instructions: `Mementos is the persistent memory layer for AI agents. It stores, searches, and manages memories across sessions and projects.
+
+When running with --dangerously-load-development-channels, mementos will proactively push relevant memories into your conversation via channel notifications. These appear as <channel source="mementos"> tags. They contain memories activated by your current task context \u2014 use them to inform your work. You don't need to call memory_inject when auto-inject is active.`
 });
+mcpServer = server;
 var _autoProjectInitialized = false;
 function ensureAutoProject() {
   if (_autoProjectInitialized)
@@ -10891,8 +13579,20 @@ function formatError(error) {
     return `Duplicate: ${error.message}`;
   if (error instanceof InvalidScopeError)
     return `Invalid scope: ${error.message}`;
-  if (error instanceof Error)
-    return error.message;
+  if (error instanceof Error) {
+    const msg = error.message;
+    if (msg.includes("UNIQUE constraint failed: projects.")) {
+      return `Project already registered at this path. Use list_projects to find it.`;
+    }
+    if (msg.includes("UNIQUE constraint failed")) {
+      const table = msg.match(/UNIQUE constraint failed: (\w+)\./)?.[1] ?? "unknown";
+      return `Duplicate entry in ${table}. The record already exists \u2014 use the list or get tool to find it.`;
+    }
+    if (msg.includes("FOREIGN KEY constraint failed")) {
+      return `Referenced record not found. Check that the project_id or agent_id exists.`;
+    }
+    return msg;
+  }
   return String(error);
 }
 function resolveId(partialId, table = "memories") {
@@ -10936,6 +13636,32 @@ function formatMemory(m) {
   return parts.join(`
 `);
 }
+function formatAsmrResult(result, query) {
+  const sections = [];
+  sections.push(`[deep] ASMR recall for "${query}" (${result.duration_ms}ms, agents: ${result.agents_used.join(", ")})`);
+  if (result.memories.length > 0) {
+    const memLines = result.memories.map((m, i) => `${i + 1}. [${m.source_agent}] [score:${m.score.toFixed(3)}] [${m.memory.scope}/${m.memory.category}] ${m.memory.key} = ${m.memory.value.slice(0, 120)}${m.memory.value.length > 120 ? "..." : ""}`);
+    sections.push(`Memories (${result.memories.length}):
+${memLines.join(`
+`)}`);
+  }
+  if (result.facts.length > 0) {
+    sections.push(`Facts:
+${result.facts.map((f) => `- ${f}`).join(`
+`)}`);
+  }
+  if (result.timeline.length > 0) {
+    sections.push(`Timeline:
+${result.timeline.map((t) => `- ${t}`).join(`
+`)}`);
+  }
+  if (result.reasoning) {
+    sections.push(`Reasoning: ${result.reasoning}`);
+  }
+  return sections.join(`
+
+`);
+}
 server.tool("memory_save", "Save/upsert a memory. scope: global=all agents, shared=project, private=single agent, working=transient session scratchpad (auto-expires in 1h, excluded from ALMA synthesis). conflict controls what happens when key already exists.", {
   key: exports_external.string(),
   value: exports_external.string(),
@@ -10952,11 +13678,15 @@ server.tool("memory_save", "Save/upsert a memory. scope: global=all agents, shar
   metadata: exports_external.record(exports_external.unknown()).optional(),
   conflict: exports_external.enum(["merge", "overwrite", "error", "version-fork"]).optional().describe("Conflict strategy: merge=upsert(default), overwrite=same as merge, error=fail if key exists, version-fork=always create new"),
   conflict_strategy: exports_external.enum(["last_writer_wins", "reject"]).optional().describe("Vector clock conflict strategy: last_writer_wins (default) proceeds even if diverged, reject returns error on divergence"),
-  machine_id: exports_external.string().optional().describe("Machine ID (from register_machine). If omitted, auto-detected from current hostname.")
+  machine_id: exports_external.string().optional().describe("Machine ID (from register_machine). If omitted, auto-detected from current hostname."),
+  when_to_use: exports_external.string().optional().describe("Activation context \u2014 describes WHEN this memory should be retrieved. Used for intent-based retrieval. Example: 'when deploying to production' or 'when debugging database issues'. If set, semantic search matches against this instead of the value."),
+  sequence_group: exports_external.string().optional().describe("Chain/sequence group ID \u2014 links memories into an ordered procedural sequence. Use memory_chain_get to retrieve the full chain."),
+  sequence_order: exports_external.coerce.number().optional().describe("Position within the sequence group (1-based). Memories in a chain are returned ordered by this field."),
+  dedup_mode: exports_external.enum(["key", "semantic", "llm"]).optional().default("key").describe("Dedup strategy: 'key' = current key-based (default), 'semantic' = skip if >0.92 embedding similarity to existing memory, 'llm' = ask LLM if content is already covered")
 }, async (args) => {
   try {
     ensureAutoProject();
-    const { conflict, ...restArgs } = args;
+    const { conflict, dedup_mode, ...restArgs } = args;
     const input = { ...restArgs };
     if (restArgs.ttl_ms !== undefined) {
       input.ttl_ms = parseDuration(restArgs.ttl_ms);
@@ -10987,6 +13717,89 @@ server.tool("memory_save", "Save/upsert a memory. scope: global=all agents, shar
         }
       } catch {}
     }
+    if (dedup_mode === "semantic") {
+      try {
+        const textToEmbed = input.when_to_use || input.value;
+        const results = await semanticSearch(textToEmbed, {
+          threshold: 0.3,
+          limit: 5,
+          scope: input.scope,
+          agent_id: input.agent_id,
+          project_id: input.project_id
+        });
+        const SEMANTIC_THRESHOLD = 0.92;
+        for (const result of results) {
+          if (result.score >= SEMANTIC_THRESHOLD) {
+            return { content: [{ type: "text", text: `Skipped: content similar to existing memory ${result.memory.id.slice(0, 8)} (similarity: ${result.score.toFixed(2)})` }] };
+          }
+        }
+      } catch {}
+    }
+    if (dedup_mode === "llm") {
+      try {
+        const textToEmbed = input.when_to_use || input.value;
+        const candidates = await semanticSearch(textToEmbed, {
+          threshold: 0.3,
+          limit: 5,
+          scope: input.scope,
+          agent_id: input.agent_id,
+          project_id: input.project_id
+        });
+        if (candidates.length > 0) {
+          const anthropicKey = process.env["ANTHROPIC_API_KEY"];
+          if (anthropicKey) {
+            const existingList = candidates.map((c, i) => `[${i + 1}] key="${c.memory.key}" value="${c.memory.value}" (similarity: ${c.score.toFixed(2)})`).join(`
+`);
+            const llmPrompt = `New memory to save:
+key="${input.key}"
+value="${input.value}"
+
+Existing similar memories:
+${existingList}
+
+Is the new memory already covered by these existing memories? Reply with JSON only:
+{"action": "skip" | "merge" | "add", "reason": "string", "merge_text": "string if action=merge \u2014 the merged content combining new and existing"}`;
+            const llmRes = await fetch("https://api.anthropic.com/v1/messages", {
+              method: "POST",
+              headers: {
+                "x-api-key": anthropicKey,
+                "anthropic-version": "2023-06-01",
+                "content-type": "application/json"
+              },
+              body: JSON.stringify({
+                model: "claude-haiku-4-5-20251001",
+                max_tokens: 300,
+                system: "You are a deduplication assistant. Given a new memory and existing similar memories, decide: skip (already covered), merge (combine with existing), or add (genuinely new). Reply with JSON only.",
+                messages: [{ role: "user", content: llmPrompt }]
+              }),
+              signal: AbortSignal.timeout(15000)
+            });
+            if (llmRes.ok) {
+              const llmData = await llmRes.json();
+              const llmText = llmData.content?.[0]?.text?.trim() ?? "";
+              const jsonMatch = llmText.match(/\{[\s\S]*\}/);
+              if (jsonMatch) {
+                const decision = JSON.parse(jsonMatch[0]);
+                if (decision.action === "skip") {
+                  return { content: [{ type: "text", text: `Skipped (LLM dedup): ${decision.reason}` }] };
+                }
+                if (decision.action === "merge" && decision.merge_text && candidates[0]) {
+                  const target = candidates[0].memory;
+                  try {
+                    updateMemory(target.id, { value: decision.merge_text, version: target.version });
+                    return { content: [{ type: "text", text: JSON.stringify({
+                      merged_into: target.id.slice(0, 8),
+                      key: target.key,
+                      reason: decision.reason
+                    }) }] };
+                  } catch {}
+                }
+              }
+            }
+          }
+        }
+      } catch {}
+    }
     const memory = createMemory(input, dedupeMode);
     if (input.agent_id) {
       try {
@@ -11034,7 +13847,21 @@ server.tool("memory_recall", "Recall a memory by key. Returns the best matching
       touchMemory(memory.id);
       if (args.agent_id)
         touchAgent(args.agent_id);
-      return { content: [{ type: "text", text: formatMemory(memory) }] };
+      let text = formatMemory(memory);
+      if (memory.sequence_group) {
+        try {
+          const db = getDatabase();
+          const chainRows = db.prepare("SELECT * FROM memories WHERE sequence_group = ? AND status = 'active' ORDER BY sequence_order ASC").all(memory.sequence_group);
+          if (chainRows.length > 1) {
+            const steps = chainRows.map(parseMemoryRow);
+            const chainLine = steps.map((s) => `[${s.sequence_order ?? "?"}] ${s.key}`).join(" \u2192 ");
+            text += `
+
+Chain context: ${chainLine}`;
+          }
+        } catch {}
+      }
+      return { content: [{ type: "text", text }] };
     }
     const results = searchMemories(args.key, {
       scope: args.scope,
@@ -11172,7 +13999,8 @@ server.tool("memory_update", "Update a memory's metadata (value, importance, tag
   status: exports_external.enum(["active", "archived", "expired"]).optional(),
   metadata: exports_external.record(exports_external.unknown()).optional(),
   expires_at: exports_external.string().nullable().optional(),
-  version: exports_external.coerce.number().optional()
+  version: exports_external.coerce.number().optional(),
+  when_to_use: exports_external.string().optional().describe("Update the activation context for this memory")
 }, async (args) => {
   try {
     const id = resolveId(args.id);
@@ -11437,6 +14265,34 @@ server.tool("memory_diff", "Show what changed between two versions of a memory.
     return { content: [{ type: "text", text: formatError(e) }], isError: true };
   }
 });
+server.tool("memory_chain_get", "Retrieve an ordered memory chain/sequence by group ID. Returns all steps in order.", {
+  sequence_group: exports_external.string().describe("The chain/sequence group ID to retrieve"),
+  project_id: exports_external.string().optional()
+}, async (args) => {
+  try {
+    ensureAutoProject();
+    const db = getDatabase();
+    let effectiveProjectId = args.project_id;
+    const conditions = ["sequence_group = ?", "status = 'active'"];
+    const params = [args.sequence_group];
+    if (effectiveProjectId) {
+      conditions.push("project_id = ?");
+      params.push(effectiveProjectId);
+    }
+    const rows = db.prepare(`SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY sequence_order ASC`).all(...params);
+    if (rows.length === 0) {
+      return { content: [{ type: "text", text: `No chain found for sequence_group: "${args.sequence_group}"` }] };
+    }
+    const memories = rows.map(parseMemoryRow);
+    const chainSteps = memories.map((m, i) => `[Step ${m.sequence_order ?? i + 1}] ${m.key}: ${m.value}`).join(`
+`);
+    const header = `Chain "${args.sequence_group}" (${memories.length} steps):
+`;
+    return { content: [{ type: "text", text: header + chainSteps }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
 server.tool("memory_search", "Search memories by keyword across key, value, summary, and tags", {
   query: exports_external.string(),
   scope: exports_external.enum(["global", "shared", "private", "working"]).optional(),
@@ -11490,10 +14346,10 @@ server.tool("memory_search_semantic", "Semantic (meaning-based) memory search us
     ensureAutoProject();
     if (args.index_missing) {
       const db = getDatabase();
-      const unindexed = db.prepare(`SELECT id, value, summary FROM memories
+      const unindexed = db.prepare(`SELECT id, value, summary, when_to_use FROM memories
            WHERE status = 'active' AND id NOT IN (SELECT memory_id FROM memory_embeddings)
            LIMIT 100`).all();
-      await Promise.all(unindexed.map((m) => indexMemoryEmbedding(m.id, [m.value, m.summary].filter(Boolean).join(" "))));
+      await Promise.all(unindexed.map((m) => indexMemoryEmbedding(m.id, m.when_to_use || [m.value, m.summary].filter(Boolean).join(" "))));
     }
     let effectiveProjectId = args.project_id;
     if (!args.project_id && args.agent_id) {
@@ -11595,6 +14451,91 @@ ${lines.join(`
     return { content: [{ type: "text", text: formatError(e) }], isError: true };
   }
 });
+server.tool("memory_recall_deep", "Deep memory recall using ASMR (Agentic Search and Memory Retrieval) \u2014 runs 3 parallel search agents (facts, context, temporal) for high-accuracy retrieval with optional ensemble answering", {
+  query: exports_external.string().describe("Natural language query"),
+  mode: exports_external.enum(["fast", "deep", "auto"]).default("deep").describe("fast=FTS+semantic, deep=ASMR 3-agent, auto=fast then escalate"),
+  max_results: exports_external.coerce.number().default(20),
+  ensemble: exports_external.coerce.boolean().default(false).describe("Use ensemble answering with majority voting"),
+  project_id: exports_external.string().optional()
+}, async (args) => {
+  try {
+    ensureAutoProject();
+    const db = getDatabase();
+    const FAST_SCORE_THRESHOLD = 0.6;
+    if (args.mode === "fast") {
+      const results = await hybridSearch(args.query, {
+        filter: { project_id: args.project_id, limit: args.max_results },
+        limit: args.max_results
+      });
+      if (results.length === 0) {
+        return { content: [{ type: "text", text: `No memories found for "${args.query}" via fast search.` }] };
+      }
+      const lines = results.map((r, i) => `${i + 1}. [score:${r.score.toFixed(3)}] [${r.memory.scope}/${r.memory.category}] ${r.memory.key} = ${r.memory.value.slice(0, 120)}${r.memory.value.length > 120 ? "..." : ""}`);
+      return { content: [{ type: "text", text: `[fast] ${results.length} result(s) for "${args.query}":
+${lines.join(`
+`)}` }] };
+    }
+    if (args.mode === "deep") {
+      const asmrResult2 = await asmrRecall(db, args.query, {
+        max_results: args.max_results,
+        project_id: args.project_id
+      });
+      let text2 = formatAsmrResult(asmrResult2, args.query);
+      if (args.ensemble) {
+        try {
+          const answer = await ensembleAnswer(asmrResult2, args.query);
+          text2 += `
+
+--- Ensemble Answer (confidence: ${(answer.confidence * 100).toFixed(0)}%, consensus: ${answer.consensus_reached ? "yes" : "no"}, escalated: ${answer.escalated ? "yes" : "no"}) ---
+${answer.answer}
+
+Reasoning: ${answer.reasoning}`;
+        } catch (ensErr) {
+          text2 += `
+
+[Ensemble failed: ${ensErr instanceof Error ? ensErr.message : "unknown error"}]`;
+        }
+      }
+      return { content: [{ type: "text", text: text2 }] };
+    }
+    const fastResults = await hybridSearch(args.query, {
+      filter: { project_id: args.project_id, limit: args.max_results },
+      limit: args.max_results
+    });
+    const topScore = fastResults.length > 0 ? fastResults[0].score : 0;
+    if (topScore >= FAST_SCORE_THRESHOLD && fastResults.length >= 3) {
+      const lines = fastResults.map((r, i) => `${i + 1}. [score:${r.score.toFixed(3)}] [${r.memory.scope}/${r.memory.category}] ${r.memory.key} = ${r.memory.value.slice(0, 120)}${r.memory.value.length > 120 ? "..." : ""}`);
+      return { content: [{ type: "text", text: `[auto/fast] ${fastResults.length} result(s) for "${args.query}" (top score ${topScore.toFixed(3)} >= threshold):
+${lines.join(`
+`)}` }] };
+    }
+    const asmrResult = await asmrRecall(db, args.query, {
+      max_results: args.max_results,
+      project_id: args.project_id
+    });
+    let text = `[auto/escalated] Fast search top score ${topScore.toFixed(3)} < ${FAST_SCORE_THRESHOLD} threshold \u2014 escalated to ASMR deep recall.
+
+${formatAsmrResult(asmrResult, args.query)}`;
+    if (args.ensemble) {
+      try {
+        const answer = await ensembleAnswer(asmrResult, args.query);
+        text += `
+
+--- Ensemble Answer (confidence: ${(answer.confidence * 100).toFixed(0)}%, consensus: ${answer.consensus_reached ? "yes" : "no"}, escalated: ${answer.escalated ? "yes" : "no"}) ---
+${answer.answer}
+
+Reasoning: ${answer.reasoning}`;
+      } catch (ensErr) {
+        text += `
+
+[Ensemble failed: ${ensErr instanceof Error ? ensErr.message : "unknown error"}]`;
+      }
+    }
+    return { content: [{ type: "text", text }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
 server.tool("memory_check_contradiction", "Check if a new memory would contradict existing high-importance facts. Call before saving to detect conflicts. Returns contradiction details if found.", {
   key: exports_external.string().describe("Memory key to check"),
   value: exports_external.string().describe("New value to check for contradictions"),
@@ -11900,9 +14841,23 @@ server.tool("memory_inject", "Get memory context for system prompt injection. Se
   format: exports_external.enum(["xml", "markdown", "compact", "json"]).optional(),
   raw: exports_external.boolean().optional(),
   strategy: exports_external.enum(["default", "smart"]).optional().describe("Injection strategy: 'default' uses importance+recency, 'smart' uses embedding similarity+importance+recency"),
-  query: exports_external.string().optional().describe("Query for smart injection relevance scoring. Required when strategy='smart'.")
+  query: exports_external.string().optional().describe("Query for smart injection relevance scoring. Required when strategy='smart'."),
+  task_context: exports_external.string().optional().describe("What the agent is about to do. When provided, activates intent-based retrieval \u2014 matches against when_to_use fields for situationally relevant memories."),
+  mode: exports_external.enum(["full", "hints"]).optional().default("full").describe("'full' = inject complete memory content (default), 'hints' = inject lightweight topic summary with counts, saving 60-70% tokens. Agent uses memory_recall to pull details as needed.")
 }, async (args) => {
   try {
+    if (args.strategy === "smart" && args.task_context && args.mode !== "hints") {
+      const { smartInject: smartInject2 } = await Promise.resolve().then(() => (init_injector(), exports_injector));
+      const result = await smartInject2({
+        task_context: args.task_context,
+        project_id: args.project_id,
+        agent_id: args.agent_id,
+        session_id: args.session_id,
+        max_tokens: args.max_tokens,
+        min_importance: args.min_importance
+      });
+      return { content: [{ type: "text", text: result.output }] };
+    }
     const maxTokens = args.max_tokens || 500;
     const minImportance = args.min_importance || 3;
     const categories = args.categories || ["preference", "fact", "knowledge"];
@@ -11956,10 +14911,29 @@ server.tool("memory_inject", "Get memory context for system prompt injection. Se
       seen.add(m.id);
       return true;
     });
+    const activationBoostedIds = new Set;
+    if (args.task_context) {
+      try {
+        const activationResults = await semanticSearch(args.task_context, {
+          threshold: 0.3,
+          limit: 20,
+          scope: undefined,
+          agent_id: args.agent_id,
+          project_id: args.project_id
+        });
+        for (const r of activationResults) {
+          activationBoostedIds.add(r.memory.id);
+          if (!seen.has(r.memory.id)) {
+            seen.add(r.memory.id);
+            unique.push(r.memory);
+          }
+        }
+      } catch {}
+    }
     if (args.strategy === "smart" && args.query) {
       const { generateEmbedding: genEmb, cosineSimilarity: cosSim, deserializeEmbedding: deserEmb } = await Promise.resolve().then(() => exports_embeddings);
-      const { getDatabase: getDb } = await Promise.resolve().then(() => (init_database(), exports_database));
-      const d = getDb();
+      const { getDatabase: getDb2 } = await Promise.resolve().then(() => (init_database(), exports_database));
+      const d = getDb2();
       const { embedding: queryEmbedding } = await genEmb(args.query);
       const embeddingMap = new Map;
       if (unique.length > 0) {
@@ -11978,7 +14952,7 @@ server.tool("memory_inject", "Get memory context for system prompt injection. Se
         for (const m of unique) {
           const memEmb = embeddingMap.get(m.id);
           const similarity = memEmb ? cosSim(queryEmbedding, memEmb) : 0;
-          const importanceScore = m.importance / 10;
+          const importanceScore = (m.importance + (activationBoostedIds.has(m.id) ? 3 : 0)) / 10;
           const recencyScore = (new Date(m.updated_at).getTime() - oldestMs) / timeRange;
           const pinBonus = m.pinned ? 0.5 : 0;
           scores.set(m.id, similarity * 0.4 + importanceScore * 0.3 + recencyScore * 0.3 + pinBonus);
@@ -11986,18 +14960,83 @@ server.tool("memory_inject", "Get memory context for system prompt injection. Se
         unique.sort((a, b) => (scores.get(b.id) || 0) - (scores.get(a.id) || 0));
       } else {
         unique.sort((a, b) => {
-          if (b.importance !== a.importance)
-            return b.importance - a.importance;
+          const aImp = a.importance + (activationBoostedIds.has(a.id) ? 3 : 0);
+          const bImp = b.importance + (activationBoostedIds.has(b.id) ? 3 : 0);
+          if (bImp !== aImp)
+            return bImp - aImp;
           return new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime();
         });
       }
     } else {
       unique.sort((a, b) => {
-        if (b.importance !== a.importance)
-          return b.importance - a.importance;
+        const aImp = a.importance + (activationBoostedIds.has(a.id) ? 3 : 0);
+        const bImp = b.importance + (activationBoostedIds.has(b.id) ? 3 : 0);
+        if (bImp !== aImp)
+          return bImp - aImp;
         return new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime();
       });
     }
+    if (args.mode === "hints") {
+      let extractTopics = function(memories, maxTopics = 8) {
+        const wordCounts = new Map;
+        for (const m of memories) {
+          const keyWords = m.key.split(/[-_\s]+/).filter((w) => w.length > 2 && !stopWords.has(w.toLowerCase()));
+          for (const w of keyWords) {
+            const lower = w.toLowerCase();
+            wordCounts.set(lower, (wordCounts.get(lower) || 0) + 1);
+          }
+          if (m.tags) {
+            const tags = Array.isArray(m.tags) ? m.tags : typeof m.tags === "string" ? m.tags.split(",") : [];
+            for (const t of tags) {
+              const tag = t.trim().toLowerCase();
+              if (tag.length > 2 && !stopWords.has(tag)) {
+                wordCounts.set(tag, (wordCounts.get(tag) || 0) + 1);
+              }
+            }
+          }
+        }
+        return Array.from(wordCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, maxTopics).map(([word]) => word);
+      };
+      if (unique.length === 0) {
+        return { content: [{ type: "text", text: "No relevant memories found." }] };
+      }
+      const groups = new Map;
+      for (const m of unique) {
+        const cat = m.category || "knowledge";
+        if (!groups.has(cat))
+          groups.set(cat, []);
+        groups.get(cat).push(m);
+      }
+      const stopWords = new Set(["the", "a", "an", "is", "in", "on", "at", "to", "for", "of", "and", "or", "with", "my", "this", "that"]);
+      const categoryLabels = {
+        fact: "Facts",
+        preference: "Preferences",
+        knowledge: "Knowledge",
+        history: "History",
+        procedural: "Procedures",
+        resource: "Resources"
+      };
+      const hintLines = ["You have relevant memories available:"];
+      const categoryOrder = ["fact", "knowledge", "preference", "procedural", "history", "resource"];
+      for (const cat of categoryOrder) {
+        const mems = groups.get(cat);
+        if (!mems || mems.length === 0)
+          continue;
+        const label = categoryLabels[cat] || cat;
+        const topics = extractTopics(mems);
+        hintLines.push(`- ${label} (${mems.length}): ${topics.join(", ")}`);
+      }
+      for (const [cat, mems] of groups) {
+        if (categoryOrder.includes(cat))
+          continue;
+        const topics = extractTopics(mems);
+        hintLines.push(`- ${cat} (${mems.length}): ${topics.join(", ")}`);
+      }
+      hintLines.push("");
+      hintLines.push('Use memory_recall(key="...") to access any of these. Use memory_search(query="...") for broader searches.');
+      return { content: [{ type: "text", text: hintLines.join(`
+`) }] };
+    }
     const fmt = args.format ?? (args.raw ? "compact" : "xml");
     const preCtx = {
       memories: unique,
@@ -12624,9 +15663,21 @@ server.tool("memory_context", "Get memories relevant to current context. Uses ti
   scope: exports_external.enum(["global", "shared", "private", "working"]).optional(),
   limit: exports_external.coerce.number().optional(),
   decay_halflife_days: exports_external.coerce.number().optional().describe("Importance half-life in days (default: 90). Lower = more weight on recent memories."),
-  no_decay: exports_external.coerce.boolean().optional().describe("Set true to disable decay and sort purely by importance.")
+  no_decay: exports_external.coerce.boolean().optional().describe("Set true to disable decay and sort purely by importance."),
+  task_context: exports_external.string().optional().describe("What the agent is about to do. When provided, activates intent-based retrieval \u2014 matches against when_to_use fields for situationally relevant memories."),
+  strategy: exports_external.enum(["default", "smart"]).optional().default("default").describe("Injection strategy: 'default' = decay-scored, 'smart' = activation-matched + layered + tool-aware (requires task_context)")
 }, async (args) => {
   try {
+    if (args.strategy === "smart" && args.task_context) {
+      const { smartInject: smartInject2 } = await Promise.resolve().then(() => (init_injector(), exports_injector));
+      const result = await smartInject2({
+        task_context: args.task_context,
+        project_id: args.project_id,
+        agent_id: args.agent_id,
+        max_tokens: args.limit ? args.limit * 20 : undefined
+      });
+      return { content: [{ type: "text", text: result.output }] };
+    }
     const filter = {
       scope: args.scope,
       agent_id: args.agent_id,
@@ -12635,18 +15686,39 @@ server.tool("memory_context", "Get memories relevant to current context. Uses ti
       limit: (args.limit || 30) * 2
     };
     const memories = listMemories(filter);
+    const activationBoostedIds = new Set;
+    if (args.task_context) {
+      try {
+        const activationResults = await semanticSearch(args.task_context, {
+          threshold: 0.3,
+          limit: 20,
+          scope: args.scope,
+          agent_id: args.agent_id,
+          project_id: args.project_id
+        });
+        const seenIds = new Set(memories.map((m) => m.id));
+        for (const r of activationResults) {
+          activationBoostedIds.add(r.memory.id);
+          if (!seenIds.has(r.memory.id)) {
+            seenIds.add(r.memory.id);
+            memories.push(r.memory);
+          }
+        }
+      } catch {}
+    }
     if (memories.length === 0) {
       return { content: [{ type: "text", text: "No memories in current context." }] };
     }
     const halflifeDays = args.decay_halflife_days ?? 90;
-    const now2 = Date.now();
+    const now3 = Date.now();
     const scored = memories.map((m) => {
-      let effectiveScore = m.importance;
+      const activationBoost = activationBoostedIds.has(m.id) ? 3 : 0;
+      let effectiveScore = m.importance + activationBoost;
       if (!args.no_decay && !m.pinned) {
-        const ageMs = now2 - new Date(m.updated_at).getTime();
-        const ageDays = ageMs / (1000 * 60 * 60 * 24);
+        const ageMs = now3 - new Date(m.updated_at).getTime();
+        const ageDays = ageMs / 86400000;
         const decayFactor = Math.pow(0.5, ageDays / halflifeDays);
-        effectiveScore = m.importance * decayFactor;
+        effectiveScore = (m.importance + activationBoost) * decayFactor;
       }
       if (m.flag)
         effectiveScore = Math.max(effectiveScore, 11);
@@ -12692,6 +15764,25 @@ ${ctx.total_memories} memories, ~${ctx.token_estimate} tokens` }] };
     return { content: [{ type: "text", text: formatError(e) }], isError: true };
   }
 });
+server.tool("memory_profile", "Synthesize a coherent profile from preference and fact memories using LLM. Cached for 24h, auto-refreshed when preferences change. Returns markdown profile.", {
+  project_id: exports_external.string().optional(),
+  agent_id: exports_external.string().optional(),
+  scope: exports_external.enum(["agent", "project", "global"]).optional().default("project"),
+  force_refresh: exports_external.boolean().optional().default(false).describe("Force re-synthesis even if cached profile exists")
+}, async (args) => {
+  try {
+    ensureAutoProject();
+    const result = await synthesizeProfile(args);
+    if (!result) {
+      return { content: [{ type: "text", text: "No preference or fact memories found to synthesize a profile from." }] };
+    }
+    return { content: [{ type: "text", text: `${result.from_cache ? "[cached] " : "[synthesized] "}(${result.memory_count} memories)
+
+${result.profile}` }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
 function resolveEntityParam(nameOrId, type) {
   const byName = getEntityByName(nameOrId, type);
   if (byName)
@@ -13043,6 +16134,95 @@ server.tool("build_file_dep_graph", "Scan a codebase directory and build a file
     return { content: [{ type: "text", text: formatError(e) }], isError: true };
   }
 });
+server.tool("memory_tool_insights", "Get usage stats, lessons learned, and recommendations for MCP tools. Helps agents avoid past mistakes and reuse successful patterns.", {
+  tool_name: exports_external.string().optional().describe("Specific tool to get insights for. If omitted, returns insights for all tools."),
+  task_context: exports_external.string().optional().describe("What the agent is about to do \u2014 used to find relevant tool lessons via semantic match"),
+  project_id: exports_external.string().optional(),
+  agent_id: exports_external.string().optional(),
+  limit: exports_external.coerce.number().optional().default(10).describe("Max lessons to return per tool")
+}, async (args) => {
+  try {
+    const db = getDatabase();
+    const projId = args.project_id ? resolvePartialId(db, "projects", args.project_id) ?? args.project_id : undefined;
+    const limit = args.limit ?? 10;
+    let toolNames;
+    if (args.tool_name) {
+      toolNames = [args.tool_name];
+    } else {
+      const filters = { limit: 200 };
+      if (projId)
+        filters.project_id = projId;
+      if (args.agent_id)
+        filters.agent_id = args.agent_id;
+      const events = getToolEvents(filters);
+      toolNames = [...new Set(events.map((e) => e.tool_name))];
+    }
+    if (toolNames.length === 0) {
+      return { content: [{ type: "text", text: "No tool events recorded yet." }] };
+    }
+    const sections = [];
+    for (const tn of toolNames) {
+      const stats = getToolStats(tn, projId);
+      const lessons = getToolLessons(tn, projId, limit);
+      const successPct = stats.total_calls > 0 ? Math.round(stats.success_rate * 100) : 0;
+      const avgTok = stats.avg_tokens != null ? Math.round(stats.avg_tokens) : "?";
+      const avgLat = stats.avg_latency_ms != null ? (stats.avg_latency_ms / 1000).toFixed(1) : "?";
+      let section = `## Tool: ${tn}
+Stats: ${stats.total_calls} calls | ${successPct}% success | avg ${avgTok} tokens | avg ${avgLat}s`;
+      if (stats.common_errors.length > 0) {
+        const errParts = stats.common_errors.map((e) => `${e.error_type} (${e.count})`);
+        section += `
+Common errors: ${errParts.join(", ")}`;
+      }
+      if (lessons.length > 0) {
+        const dos = [];
+        const donts = [];
+        for (const l of lessons) {
+          const ctx = (l.when_to_use || "").toLowerCase();
+          if (ctx.includes("fail") || ctx.includes("error") || ctx.includes("avoid") || ctx.includes("don't") || ctx.includes("never")) {
+            donts.push(l.lesson);
+          } else {
+            dos.push(l.lesson);
+          }
+        }
+        if (dos.length > 0 || donts.length > 0) {
+          section += `
+
+### Recommendations`;
+          for (const d of dos.slice(0, 5))
+            section += `
+\u2705 DO: ${d}`;
+          for (const d of donts.slice(0, 5))
+            section += `
+\u274C DON'T: ${d}`;
+        }
+        section += `
+
+### Lessons (newest first)`;
+        for (const l of lessons) {
+          const when = l.when_to_use ? ` (when: ${l.when_to_use})` : "";
+          section += `
+- ${l.lesson}${when}`;
+        }
+      }
+      sections.push(section);
+    }
+    let header = "";
+    if (args.task_context) {
+      header = `> Context: "${args.task_context}"
+> Showing insights filtered for relevance.
+
+`;
+    }
+    return { content: [{ type: "text", text: header + sections.join(`
+
+---
+
+`) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
 var FULL_SCHEMAS = {
   memory_save: {
     description: "Save/upsert a memory. Creates new or merges with existing key.",
@@ -13060,7 +16240,10 @@ var FULL_SCHEMAS = {
       session_id: { type: "string", description: "Session UUID" },
       ttl_ms: { type: "string|number", description: "Time-to-live e.g. '7d', '2h', or ms integer" },
       source: { type: "string", description: "Origin of the memory", enum: ["user", "agent", "system", "auto", "imported"] },
-      metadata: { type: "object", description: "Arbitrary JSON metadata" }
+      metadata: { type: "object", description: "Arbitrary JSON metadata" },
+      when_to_use: { type: "string", description: "Activation context \u2014 describes WHEN this memory should be retrieved. Used for intent-based retrieval. Example: 'when deploying to production'" },
+      sequence_group: { type: "string", description: "Chain/sequence group ID \u2014 links memories into an ordered procedural sequence" },
+      sequence_order: { type: "number", description: "Position within the sequence group (1-based)" }
     },
     example: '{"key":"preferred-language","value":"TypeScript","scope":"global","importance":8,"tags":["language","preference"]}'
   },
@@ -13092,6 +16275,15 @@ var FULL_SCHEMAS = {
     },
     example: '{"key":"preferred-language","scope":"global"}'
   },
+  memory_chain_get: {
+    description: "Retrieve an ordered memory chain/sequence by group ID. Returns all steps in procedural order.",
+    category: "memory",
+    params: {
+      sequence_group: { type: "string", description: "The chain/sequence group ID to retrieve", required: true },
+      project_id: { type: "string", description: "Project UUID filter" }
+    },
+    example: '{"sequence_group":"deploy-to-production"}'
+  },
   memory_list: {
     description: "List memories with optional filters. Returns compact lines by default.",
     category: "memory",
@@ -13127,7 +16319,8 @@ var FULL_SCHEMAS = {
       pinned: { type: "boolean", description: "Pin/unpin the memory" },
       status: { type: "string", description: "New status", enum: ["active", "archived", "expired"] },
       metadata: { type: "object", description: "New metadata (replaces existing)" },
-      expires_at: { type: "string", description: "New expiry ISO timestamp (null to clear)" }
+      expires_at: { type: "string", description: "New expiry ISO timestamp (null to clear)" },
+      when_to_use: { type: "string", description: "Update the activation context for this memory" }
     },
     example: '{"id":"abc123","version":1,"importance":9,"tags":["correction","important"]}'
   },
@@ -13217,6 +16410,18 @@ var FULL_SCHEMAS = {
     },
     example: '{"query":"database migration","limit":5}'
   },
+  memory_recall_deep: {
+    description: "Deep memory recall using ASMR 3-agent search (facts, context, temporal). Modes: fast (hybrid), deep (ASMR), auto (fast then escalate). Optional ensemble answering.",
+    category: "memory",
+    params: {
+      query: { type: "string", description: "Natural language query", required: true },
+      mode: { type: "string", description: "fast=FTS+semantic, deep=ASMR 3-agent, auto=fast then escalate", enum: ["fast", "deep", "auto"] },
+      max_results: { type: "number", description: "Max results (default 20)" },
+      ensemble: { type: "boolean", description: "Use ensemble answering with majority voting (default false)" },
+      project_id: { type: "string", description: "Project UUID filter" }
+    },
+    example: '{"query":"what is the deployment process","mode":"deep","ensemble":true}'
+  },
   memory_activity: {
     description: "Get daily memory creation counts over N days (max 365). Like 'git log --stat' for memories.",
     category: "memory",
@@ -13255,7 +16460,7 @@ var FULL_SCHEMAS = {
     example: '{"memories":[{"key":"foo","value":"bar","scope":"global","importance":7}]}'
   },
   memory_inject: {
-    description: "Get formatted memory context for system prompt injection. Respects token budget. Use strategy='smart' with a query for embedding-based relevance scoring.",
+    description: "Get formatted memory context for system prompt injection. Respects token budget. Use strategy='smart' with task_context for full activation-matched + layered + tool-aware pipeline. Use mode='hints' for a lightweight topic summary (60-70% fewer tokens) \u2014 agent can then use memory_recall for details on demand.",
     category: "memory",
     params: {
       agent_id: { type: "string", description: "Agent UUID to include private memories" },
@@ -13266,10 +16471,12 @@ var FULL_SCHEMAS = {
       min_importance: { type: "number", description: "Minimum importance (default 3)" },
       format: { type: "string", description: "Output format: xml (default, <agent-memories>), compact (key: value, ~60% smaller), markdown, json", enum: ["xml", "compact", "markdown", "json"] },
       raw: { type: "boolean", description: "Deprecated: use format=compact instead. true=plain lines only" },
-      strategy: { type: "string", description: "Injection strategy: 'default' (importance+recency) or 'smart' (embedding similarity+importance+recency)", enum: ["default", "smart"] },
-      query: { type: "string", description: "Query for smart injection relevance scoring. Required when strategy='smart'." }
+      strategy: { type: "string", description: "Injection strategy: 'default' = decay-scored (importance+recency), 'smart' = full pipeline (activation-matched + layered + tool-aware). Smart requires task_context.", enum: ["default", "smart"] },
+      query: { type: "string", description: "Query for smart injection relevance scoring. Required when strategy='smart'." },
+      task_context: { type: "string", description: "What the agent is about to do. Required for strategy='smart'. Activates intent-based retrieval \u2014 matches against when_to_use fields for situationally relevant memories." },
+      mode: { type: "string", description: "Injection mode: 'full' (default) = inject complete memory content, 'hints' = lightweight topic summary with counts per category, saving 60-70% tokens. In hints mode, use memory_recall(key=...) or memory_search(query=...) to pull details on demand.", enum: ["full", "hints"] }
     },
-    example: '{"project_id":"proj-uuid","max_tokens":300,"min_importance":5,"format":"compact","strategy":"smart","query":"database migrations"}'
+    example: '{"project_id":"proj-uuid","max_tokens":300,"strategy":"smart","task_context":"writing database migration for user table"}'
   },
   session_extract: {
     description: "Auto-create memories from a session summary (title, topics, notes, project). Designed for sessions\u2192mementos integration.",
@@ -13288,15 +16495,28 @@ var FULL_SCHEMAS = {
     example: '{"session_id":"abc123","title":"Fix auth middleware","project":"alumia","key_topics":["jwt","compliance"],"agent_id":"galba-id"}'
   },
   memory_context: {
-    description: "Get active memories for the current context (agent/project/scope).",
+    description: "Get active memories for the current context (agent/project/scope). Supports intent-based retrieval via task_context. Use strategy='smart' for full activation-matched + layered + tool-aware pipeline.",
     category: "memory",
     params: {
       agent_id: { type: "string", description: "Agent UUID filter" },
       project_id: { type: "string", description: "Project UUID filter" },
       scope: { type: "string", description: "Scope filter", enum: ["global", "shared", "private", "working"] },
-      limit: { type: "number", description: "Max results (default 30)" }
+      limit: { type: "number", description: "Max results (default 30)" },
+      task_context: { type: "string", description: "What the agent is about to do. Required for strategy='smart'. Activates intent-based retrieval \u2014 matches against when_to_use fields for situationally relevant memories." },
+      strategy: { type: "string", description: "Injection strategy: 'default' = decay-scored, 'smart' = activation-matched + layered + tool-aware (requires task_context)", enum: ["default", "smart"] }
+    },
+    example: '{"project_id":"proj-uuid","scope":"shared","limit":20,"strategy":"smart","task_context":"deploying to production"}'
+  },
+  memory_profile: {
+    description: "Synthesize a coherent profile from preference and fact memories using LLM. Cached for 24h, auto-refreshed when preferences change.",
+    category: "memory",
+    params: {
+      project_id: { type: "string", description: "Project UUID to scope profile to" },
+      agent_id: { type: "string", description: "Agent UUID to scope profile to" },
+      scope: { type: "string", description: "Profile scope", enum: ["agent", "project", "global"] },
+      force_refresh: { type: "boolean", description: "Force re-synthesis even if cached profile exists (default false)" }
     },
-    example: '{"project_id":"proj-uuid","scope":"shared","limit":20}'
+    example: '{"project_id":"proj-uuid","scope":"project"}'
   },
   register_agent: {
     description: "Register an agent. Idempotent \u2014 same name returns existing agent.",
@@ -13637,6 +16857,68 @@ var FULL_SCHEMAS = {
     },
     example: '{"id":"sub-abc12"}'
   },
+  memory_tool_insights: {
+    description: "Get usage stats, lessons learned, and recommendations for MCP tools. Helps agents avoid past mistakes and reuse successful patterns.",
+    category: "utility",
+    params: {
+      tool_name: { type: "string", description: "Specific tool to get insights for. If omitted, returns insights for all tools." },
+      task_context: { type: "string", description: "What the agent is about to do \u2014 used to find relevant tool lessons via semantic match" },
+      project_id: { type: "string", description: "Project ID filter" },
+      agent_id: { type: "string", description: "Agent ID filter" },
+      limit: { type: "number", description: "Max lessons to return per tool (default: 10)" }
+    },
+    example: '{"tool_name":"bash","limit":5}'
+  },
+  memory_save_tool_event: {
+    description: "Record a tool call event (success/failure, latency, tokens). Optionally saves a lesson as a shared memory.",
+    category: "memory",
+    params: {
+      tool_name: { type: "string", description: "Name of the tool that was called", required: true },
+      action: { type: "string", description: "What was attempted" },
+      success: { type: "boolean", description: "Whether the tool call succeeded", required: true },
+      error_type: { type: "string", description: "Error category if failed", enum: ["timeout", "permission", "not_found", "syntax", "rate_limit", "other"] },
+      error_message: { type: "string", description: "Raw error text if failed" },
+      tokens_used: { type: "number", description: "Tokens consumed by the tool call" },
+      latency_ms: { type: "number", description: "Time taken in milliseconds" },
+      context: { type: "string", description: "What task triggered this tool call" },
+      lesson: { type: "string", description: "Qualitative insight learned from this call" },
+      when_to_use: { type: "string", description: "Activation context for the lesson" },
+      agent_id: { type: "string", description: "Agent ID" },
+      project_id: { type: "string", description: "Project ID" },
+      session_id: { type: "string", description: "Session ID" }
+    },
+    example: '{"tool_name":"bash","action":"npm install","success":false,"error_type":"timeout","lesson":"npm install hangs on large monorepos \u2014 use --prefer-offline","when_to_use":"when installing deps in a monorepo"}'
+  },
+  memory_autoinject_config: {
+    description: "Get or set auto-inject orchestrator config (channel-based proactive memory push). Controls throttle, debounce, rate limits, similarity thresholds.",
+    category: "utility",
+    params: {
+      action: { type: "string", description: "Get or set auto-inject config", enum: ["get", "set"], required: true },
+      throttle_ms: { type: "number", description: "Min ms between pushes (default 30000)" },
+      debounce_ms: { type: "number", description: "Wait ms after last message before processing (default 2000)" },
+      max_pushes_per_5min: { type: "number", description: "Rate limit per 5-minute window (default 5)" },
+      min_similarity: { type: "number", description: "Minimum activation match threshold 0-1 (default 0.4)" },
+      enabled: { type: "boolean", description: "Enable/disable auto-inject" },
+      session_briefing: { type: "boolean", description: "Push session-start briefing (default true)" }
+    },
+    example: '{"action":"set","throttle_ms":15000,"min_similarity":0.5}'
+  },
+  memory_autoinject_status: {
+    description: "Get auto-inject orchestrator status: running state, session watcher, push history, rate limit counters, and full config.",
+    category: "utility",
+    params: {},
+    example: "{}"
+  },
+  memory_autoinject_test: {
+    description: "Test what memories would be activated by a given context WITHOUT pushing. Shows what the auto-inject pipeline would match \u2014 useful for tuning min_similarity.",
+    category: "utility",
+    params: {
+      context_text: { type: "string", description: "Simulated context to test activation matching", required: true },
+      project_id: { type: "string", description: "Scope to a specific project" },
+      min_similarity: { type: "number", description: "Minimum similarity threshold (default 0.4)" }
+    },
+    example: '{"context_text":"debugging a SQLite FTS5 index issue","min_similarity":0.3}'
+  },
   search_tools: {
     description: "Search available tools by name or keyword. Returns matching tool names and categories.",
     category: "meta",
@@ -14333,6 +17615,149 @@ server.tool("memory_unsubscribe", "Remove a memory subscription by ID.", {
     return { content: [{ type: "text", text: formatError(e) }], isError: true };
   }
 });
+server.tool("memory_save_tool_event", "Record a tool call event (success/failure, latency, tokens). Optionally saves a lesson as a shared memory.", {
+  tool_name: exports_external.string().describe("Name of the tool that was called (e.g. 'bash', 'read', 'grep')"),
+  action: exports_external.string().optional().describe("What was attempted (e.g. 'npm install', 'git push')"),
+  success: exports_external.boolean().describe("Whether the tool call succeeded"),
+  error_type: exports_external.enum(["timeout", "permission", "not_found", "syntax", "rate_limit", "other"]).optional().describe("Error category if failed"),
+  error_message: exports_external.string().optional().describe("Raw error text if failed"),
+  tokens_used: exports_external.number().optional().describe("Tokens consumed by the tool call"),
+  latency_ms: exports_external.number().optional().describe("Time taken in milliseconds"),
+  context: exports_external.string().optional().describe("What task triggered this tool call"),
+  lesson: exports_external.string().optional().describe("Qualitative insight learned from this call"),
+  when_to_use: exports_external.string().optional().describe("Activation context for the lesson"),
+  agent_id: exports_external.string().optional(),
+  project_id: exports_external.string().optional(),
+  session_id: exports_external.string().optional()
+}, async (args) => {
+  try {
+    const event = saveToolEvent(args);
+    if (args.lesson) {
+      try {
+        createMemory({
+          key: `tool-lesson-${args.tool_name}-${Date.now()}`,
+          value: args.lesson,
+          category: "knowledge",
+          scope: "shared",
+          importance: 7,
+          tags: ["tool-memory", args.tool_name],
+          when_to_use: args.when_to_use,
+          agent_id: args.agent_id,
+          project_id: args.project_id,
+          session_id: args.session_id,
+          source: "auto"
+        });
+      } catch {}
+    }
+    return { content: [{ type: "text", text: JSON.stringify({
+      id: event.id,
+      tool_name: event.tool_name,
+      success: event.success,
+      error_type: event.error_type,
+      lesson_saved: !!args.lesson,
+      created_at: event.created_at
+    }) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
+server.tool("memory_autoinject_config", "Get or set auto-inject orchestrator config (channel-based memory push). Controls throttle, debounce, rate limits, and similarity thresholds for proactive memory injection.", {
+  action: exports_external.enum(["get", "set"]).describe("Get or set auto-inject config"),
+  throttle_ms: exports_external.number().optional().describe("Min ms between pushes (default 30000)"),
+  debounce_ms: exports_external.number().optional().describe("Wait ms after last message before processing (default 2000)"),
+  max_pushes_per_5min: exports_external.number().optional().describe("Rate limit per 5-minute window (default 5)"),
+  min_similarity: exports_external.number().optional().describe("Minimum activation match threshold 0-1 (default 0.4)"),
+  enabled: exports_external.boolean().optional().describe("Enable/disable auto-inject"),
+  session_briefing: exports_external.boolean().optional().describe("Push session-start briefing (default true)")
+}, async (args) => {
+  try {
+    if (args.action === "get") {
+      return { content: [{ type: "text", text: JSON.stringify(getAutoInjectConfig(), null, 2) }] };
+    }
+    const updates = {};
+    if (args.throttle_ms !== undefined)
+      updates.throttle_ms = args.throttle_ms;
+    if (args.debounce_ms !== undefined)
+      updates.debounce_ms = args.debounce_ms;
+    if (args.max_pushes_per_5min !== undefined)
+      updates.max_pushes_per_5min = args.max_pushes_per_5min;
+    if (args.min_similarity !== undefined)
+      updates.min_similarity = args.min_similarity;
+    if (args.enabled !== undefined)
+      updates.enabled = args.enabled;
+    if (args.session_briefing !== undefined)
+      updates.session_briefing = args.session_briefing;
+    const updated = updateAutoInjectConfig(updates);
+    return { content: [{ type: "text", text: JSON.stringify({ updated: true, config: updated }, null, 2) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
+server.tool("memory_autoinject_status", "Get auto-inject orchestrator status: running state, session watcher, push history, rate limit counters, and full config.", {}, async () => {
+  try {
+    const status = getAutoInjectStatus();
+    const lines = [
+      `Running: ${status.running}`,
+      `Session ID: ${status.session_id || "none"}`,
+      `Watcher active: ${status.watcher.active}`,
+      `Watching file: ${status.watcher.watching_file || "none"}`,
+      `Last offset: ${status.watcher.last_offset}`,
+      ``,
+      `Pushes:`,
+      `  Total: ${status.pushes.total}`,
+      `  Last 5 min: ${status.pushes.last_5min}`,
+      `  Recently pushed memories: ${status.pushes.recently_pushed_memories}`,
+      `  Next available in: ${status.pushes.next_available_in_ms}ms`,
+      ``,
+      `Config:`,
+      `  Enabled: ${status.config.enabled}`,
+      `  Throttle: ${status.config.throttle_ms}ms`,
+      `  Debounce: ${status.config.debounce_ms}ms`,
+      `  Max pushes/5min: ${status.config.max_pushes_per_5min}`,
+      `  Min similarity: ${status.config.min_similarity}`,
+      `  Session briefing: ${status.config.session_briefing}`
+    ];
+    if (status.history.length > 0) {
+      lines.push(``, `Recent push history:`);
+      for (const h of status.history) {
+        lines.push(`  [${h.timestamp}] ${h.memory_count} memories \u2014 "${h.context}"`);
+      }
+    }
+    return { content: [{ type: "text", text: lines.join(`
+`) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
+server.tool("memory_autoinject_test", "Test what memories would be activated by a given context WITHOUT pushing. Shows what the auto-inject pipeline would match \u2014 useful for tuning min_similarity.", {
+  context_text: exports_external.string().describe("Simulated context to test activation matching"),
+  project_id: exports_external.string().optional().describe("Scope to a specific project"),
+  min_similarity: exports_external.number().optional().default(0.4).describe("Minimum similarity threshold (default 0.4)")
+}, async (args) => {
+  try {
+    const memories = await findActivatedMemories(args.context_text, {
+      project_id: args.project_id,
+      min_similarity: args.min_similarity
+    });
+    if (memories.length === 0) {
+      return { content: [{ type: "text", text: "No memories matched the given context. Try lowering min_similarity or broadening the context text." }] };
+    }
+    const lines = [`${memories.length} memories would be activated:
+`];
+    for (const m of memories) {
+      lines.push(`- [${m.id.slice(0, 8)}] ${m.key}: ${m.value.slice(0, 200)}${m.value.length > 200 ? "\u2026" : ""}`);
+      if (m.tags.length > 0)
+        lines.push(`  Tags: ${m.tags.join(", ")}`);
+      lines.push(`  Scope: ${m.scope} | Importance: ${m.importance}/10`);
+    }
+    lines.push(`
+Note: DRY RUN \u2014 nothing was pushed.`);
+    return { content: [{ type: "text", text: lines.join(`
+`) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: formatError(e) }], isError: true };
+  }
+});
 async function ensureRestServerRunning() {
   try {
     const res = await fetch("http://127.0.0.1:19428/api/memories?limit=0", {
@@ -14363,8 +17788,26 @@ async function main() {
   loadWebhooksFromDb();
   const transport = new StdioServerTransport;
   await server.connect(transport);
+  const autoProject = detectProject();
+  startAutoInject({
+    server,
+    project_id: autoProject?.id,
+    project_name: autoProject?.name,
+    cwd: process.cwd()
+  }).catch(() => {});
+  process.on("SIGINT", () => {
+    stopAutoInject();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    stopAutoInject();
+    process.exit(0);
+  });
 }
 main().catch((error) => {
   console.error("MCP server error:", error);
   process.exit(1);
 });
+export {
+  mcpServer
+};