@hasna/mementos 0.6.0 → 0.8.0

package/dist/cli/index.js

@@ -2432,6 +2432,94 @@ var init_database = __esm(() => {
   ALTER TABLE memories ADD COLUMN recall_count INTEGER NOT NULL DEFAULT 0;
   CREATE INDEX IF NOT EXISTS idx_memories_recall_count ON memories(recall_count DESC);
   INSERT OR IGNORE INTO _migrations (id) VALUES (9);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS synthesis_events (
+    id TEXT PRIMARY KEY,
+    event_type TEXT NOT NULL CHECK(event_type IN ('recalled','searched','saved','updated','deleted','injected')),
+    memory_id TEXT,
+    agent_id TEXT,
+    project_id TEXT,
+    session_id TEXT,
+    query TEXT,
+    importance_at_time INTEGER,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_synthesis_events_memory ON synthesis_events(memory_id);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_events_project ON synthesis_events(project_id);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_events_type ON synthesis_events(event_type);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_events_created ON synthesis_events(created_at);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (11);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS synthesis_runs (
+    id TEXT PRIMARY KEY,
+    triggered_by TEXT NOT NULL DEFAULT 'manual' CHECK(triggered_by IN ('scheduler','manual','threshold','hook')),
+    project_id TEXT,
+    agent_id TEXT,
+    corpus_size INTEGER NOT NULL DEFAULT 0,
+    proposals_generated INTEGER NOT NULL DEFAULT 0,
+    proposals_accepted INTEGER NOT NULL DEFAULT 0,
+    proposals_rejected INTEGER NOT NULL DEFAULT 0,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','running','completed','failed','rolled_back')),
+    error TEXT,
+    started_at TEXT NOT NULL DEFAULT (datetime('now')),
+    completed_at TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_synthesis_runs_project ON synthesis_runs(project_id);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_runs_status ON synthesis_runs(status);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_runs_started ON synthesis_runs(started_at);
+
+  CREATE TABLE IF NOT EXISTS synthesis_proposals (
+    id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL REFERENCES synthesis_runs(id) ON DELETE CASCADE,
+    proposal_type TEXT NOT NULL CHECK(proposal_type IN ('merge','archive','promote','update_value','add_tag','remove_duplicate')),
+    memory_ids TEXT NOT NULL DEFAULT '[]',
+    target_memory_id TEXT,
+    proposed_changes TEXT NOT NULL DEFAULT '{}',
+    reasoning TEXT,
+    confidence REAL NOT NULL DEFAULT 0.5,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','accepted','rejected','rolled_back')),
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    executed_at TEXT,
+    rollback_data TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_synthesis_proposals_run ON synthesis_proposals(run_id);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_proposals_status ON synthesis_proposals(status);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_proposals_type ON synthesis_proposals(proposal_type);
+
+  CREATE TABLE IF NOT EXISTS synthesis_metrics (
+    id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL REFERENCES synthesis_runs(id) ON DELETE CASCADE,
+    metric_type TEXT NOT NULL,
+    value REAL NOT NULL,
+    baseline REAL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_synthesis_metrics_run ON synthesis_metrics(run_id);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_metrics_type ON synthesis_metrics(metric_type);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (12);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS webhook_hooks (
+    id TEXT PRIMARY KEY,
+    type TEXT NOT NULL,
+    handler_url TEXT NOT NULL,
+    priority INTEGER NOT NULL DEFAULT 50,
+    blocking INTEGER NOT NULL DEFAULT 0,
+    agent_id TEXT,
+    project_id TEXT,
+    description TEXT,
+    enabled INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    invocation_count INTEGER NOT NULL DEFAULT 0,
+    failure_count INTEGER NOT NULL DEFAULT 0
+  );
+  CREATE INDEX IF NOT EXISTS idx_webhook_hooks_type ON webhook_hooks(type);
+  CREATE INDEX IF NOT EXISTS idx_webhook_hooks_enabled ON webhook_hooks(enabled);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (10);
   `
   ];
 });
@@ -2511,6 +2599,93 @@ var init_redact = __esm(() => {
   ];
 });
 
+// src/lib/hooks.ts
+var exports_hooks = {};
+__export(exports_hooks, {
+  hookRegistry: () => hookRegistry
+});
+function generateHookId() {
+  return `hook_${++_idCounter}_${Date.now().toString(36)}`;
+}
+
+class HookRegistry {
+  hooks = new Map;
+  register(reg) {
+    const id = generateHookId();
+    const hook = {
+      ...reg,
+      id,
+      priority: reg.priority ?? 50
+    };
+    this.hooks.set(id, hook);
+    return id;
+  }
+  unregister(hookId) {
+    const hook = this.hooks.get(hookId);
+    if (!hook)
+      return false;
+    if (hook.builtin)
+      return false;
+    this.hooks.delete(hookId);
+    return true;
+  }
+  list(type) {
+    const all = [...this.hooks.values()];
+    if (!type)
+      return all;
+    return all.filter((h) => h.type === type);
+  }
+  async runHooks(type, context) {
+    const matching = this.getMatchingHooks(type, context);
+    if (matching.length === 0)
+      return true;
+    matching.sort((a, b) => a.priority - b.priority);
+    for (const hook of matching) {
+      if (hook.blocking) {
+        try {
+          const result = await hook.handler(context);
+          if (result === false)
+            return false;
+        } catch (err) {
+          console.error(`[hooks] blocking hook ${hook.id} (${type}) threw:`, err);
+        }
+      } else {
+        Promise.resolve().then(() => hook.handler(context)).catch((err) => console.error(`[hooks] non-blocking hook ${hook.id} (${type}) threw:`, err));
+      }
+    }
+    return true;
+  }
+  getMatchingHooks(type, context) {
+    const ctx = context;
+    return [...this.hooks.values()].filter((hook) => {
+      if (hook.type !== type)
+        return false;
+      if (hook.agentId && hook.agentId !== ctx.agentId)
+        return false;
+      if (hook.projectId && hook.projectId !== ctx.projectId)
+        return false;
+      return true;
+    });
+  }
+  stats() {
+    const all = [...this.hooks.values()];
+    const byType = {};
+    for (const hook of all) {
+      byType[hook.type] = (byType[hook.type] ?? 0) + 1;
+    }
+    return {
+      total: all.length,
+      byType,
+      blocking: all.filter((h) => h.blocking).length,
+      nonBlocking: all.filter((h) => !h.blocking).length
+    };
+  }
+}
+var _idCounter = 0, hookRegistry;
+var init_hooks = __esm(() => {
+  hookRegistry = new HookRegistry;
+});
+
 // src/db/entity-memories.ts
 function parseEntityMemoryRow(row) {
   return {
@@ -2566,6 +2741,22 @@ var init_entity_memories = __esm(() => {
 });
 
 // src/db/memories.ts
+var exports_memories = {};
+__export(exports_memories, {
+  updateMemory: () => updateMemory,
+  touchMemory: () => touchMemory,
+  parseMemoryRow: () => parseMemoryRow,
+  listMemories: () => listMemories,
+  incrementRecallCount: () => incrementRecallCount,
+  getMemoryVersions: () => getMemoryVersions,
+  getMemoryByKey: () => getMemoryByKey,
+  getMemory: () => getMemory,
+  getMemoriesByKey: () => getMemoriesByKey,
+  deleteMemory: () => deleteMemory,
+  createMemory: () => createMemory,
+  cleanExpiredMemories: () => cleanExpiredMemories,
+  bulkDeleteMemories: () => bulkDeleteMemories
+});
 function runEntityExtraction(_memory, _projectId, _d) {}
 function parseMemoryRow(row) {
   return {
@@ -2668,9 +2859,15 @@ function createMemory(input, dedupeMode = "merge", db) {
     insertTag.run(id, tag);
   }
   const memory = getMemory(id, d);
-  try {
-    runEntityExtraction(memory, input.project_id, d);
-  } catch {}
+  runEntityExtraction(memory, input.project_id, d);
+  hookRegistry.runHooks("PostMemorySave", {
+    memory,
+    wasUpdated: false,
+    agentId: input.agent_id,
+    projectId: input.project_id,
+    sessionId: input.session_id,
+    timestamp: Date.now()
+  });
   return memory;
 }
 function getMemory(id, db) {
@@ -2894,20 +3091,33 @@ function updateMemory(id, input, db) {
   params.push(id);
   d.run(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`, params);
   const updated = getMemory(id, d);
-  try {
-    if (input.value !== undefined) {
+  if (input.value !== undefined) {
+    try {
       const oldLinks = getEntityMemoryLinks(undefined, updated.id, d);
       for (const link of oldLinks) {
         unlinkEntityFromMemory(link.entity_id, updated.id, d);
       }
-      runEntityExtraction(updated, existing.project_id || undefined, d);
-    }
-  } catch {}
+    } catch {}
+  }
+  hookRegistry.runHooks("PostMemoryUpdate", {
+    memory: updated,
+    previousValue: existing.value,
+    agentId: existing.agent_id ?? undefined,
+    projectId: existing.project_id ?? undefined,
+    sessionId: existing.session_id ?? undefined,
+    timestamp: Date.now()
+  });
   return updated;
 }
 function deleteMemory(id, db) {
   const d = db || getDatabase();
   const result = d.run("DELETE FROM memories WHERE id = ?", [id]);
+  if (result.changes > 0) {
+    hookRegistry.runHooks("PostMemoryDelete", {
+      memoryId: id,
+      timestamp: Date.now()
+    });
+  }
   return result.changes > 0;
 }
 function bulkDeleteMemories(ids, db) {
@@ -2926,6 +3136,20 @@ function touchMemory(id, db) {
   const d = db || getDatabase();
   d.run("UPDATE memories SET access_count = access_count + 1, accessed_at = ? WHERE id = ?", [now(), id]);
 }
+function incrementRecallCount(id, db) {
+  const d = db || getDatabase();
+  try {
+    d.run("UPDATE memories SET recall_count = recall_count + 1, access_count = access_count + 1, accessed_at = ? WHERE id = ?", [now(), id]);
+    const row = d.query("SELECT recall_count, importance FROM memories WHERE id = ?").get(id);
+    if (!row)
+      return;
+    const promotions = Math.floor(row.recall_count / RECALL_PROMOTE_THRESHOLD);
+    if (promotions > 0 && row.importance < 10) {
+      const newImportance = Math.min(10, row.importance + 1);
+      d.run("UPDATE memories SET importance = ? WHERE id = ? AND importance < 10", [newImportance, id]);
+    }
+  } catch {}
+}
 function cleanExpiredMemories(db) {
   const d = db || getDatabase();
   const timestamp = now();
@@ -2958,10 +3182,12 @@ function getMemoryVersions(memoryId, db) {
     return [];
   }
 }
+var RECALL_PROMOTE_THRESHOLD = 3;
 var init_memories = __esm(() => {
   init_types();
   init_database();
   init_redact();
+  init_hooks();
   init_entity_memories();
 });
 
@@ -3012,6 +3238,13 @@ function createEntity(input, db) {
     timestamp,
     timestamp
   ]);
+  hookRegistry.runHooks("PostEntityCreate", {
+    entityId: id,
+    name: input.name,
+    entityType: input.type,
+    projectId: input.project_id,
+    timestamp: Date.now()
+  });
   return getEntity(id, d);
 }
 function getEntity(id, db) {
@@ -3097,6 +3330,7 @@ function mergeEntities(sourceId, targetId, db) {
 var init_entities = __esm(() => {
   init_database();
   init_types();
+  init_hooks();
 });
 
 // src/lib/search.ts
@@ -3696,7 +3930,15 @@ function createRelation(input, db) {
      DO UPDATE SET weight = excluded.weight, metadata = excluded.metadata`, [id, input.source_entity_id, input.target_entity_id, input.relation_type, weight, metadata, timestamp]);
   const row = d.query(`SELECT * FROM relations
        WHERE source_entity_id = ? AND target_entity_id = ? AND relation_type = ?`).get(input.source_entity_id, input.target_entity_id, input.relation_type);
-  return parseRelationRow(row);
+  const relation = parseRelationRow(row);
+  hookRegistry.runHooks("PostRelationCreate", {
+    relationId: relation.id,
+    sourceEntityId: relation.source_entity_id,
+    targetEntityId: relation.target_entity_id,
+    relationType: relation.relation_type,
+    timestamp: Date.now()
+  });
+  return relation;
 }
 function listRelations(filter, db) {
   const d = db || getDatabase();
@@ -3805,6 +4047,7 @@ function findPath(fromEntityId, toEntityId, maxDepth = 5, db) {
 }
 var init_relations = __esm(() => {
   init_database();
+  init_hooks();
 });
 
 // src/lib/poll.ts
@@ -4466,184 +4709,1640 @@ class AutoMemoryQueue {
     }
   }
 }
-var MAX_QUEUE_SIZE = 100, CONCURRENCY = 3, autoMemoryQueue;
-var init_auto_memory_queue = __esm(() => {
-  autoMemoryQueue = new AutoMemoryQueue;
+var MAX_QUEUE_SIZE = 100, CONCURRENCY = 3, autoMemoryQueue;
+var init_auto_memory_queue = __esm(() => {
+  autoMemoryQueue = new AutoMemoryQueue;
+});
+
+// src/lib/auto-memory.ts
+var exports_auto_memory = {};
+__export(exports_auto_memory, {
+  processConversationTurn: () => processConversationTurn,
+  getAutoMemoryStats: () => getAutoMemoryStats,
+  configureAutoMemory: () => configureAutoMemory
+});
+function isDuplicate(content, agentId, projectId) {
+  try {
+    const query = content.split(/\s+/).filter((w) => w.length > 3).slice(0, 10).join(" ");
+    if (!query)
+      return false;
+    const results = searchMemories(query, {
+      agent_id: agentId,
+      project_id: projectId,
+      limit: 3
+    });
+    if (results.length === 0)
+      return false;
+    const contentWords = new Set(content.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+    for (const result of results) {
+      const existingWords = new Set(result.memory.value.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+      if (contentWords.size === 0 || existingWords.size === 0)
+        continue;
+      const intersection = [...contentWords].filter((w) => existingWords.has(w)).length;
+      const union = new Set([...contentWords, ...existingWords]).size;
+      const similarity = intersection / union;
+      if (similarity >= DEDUP_SIMILARITY_THRESHOLD)
+        return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function linkEntitiesToMemory(memoryId, content, _agentId, projectId) {
+  const provider = providerRegistry.getAvailable();
+  if (!provider)
+    return;
+  try {
+    const { entities, relations } = await provider.extractEntities(content);
+    const entityIdMap = new Map;
+    for (const extracted of entities) {
+      if (extracted.confidence < 0.6)
+        continue;
+      try {
+        const existing = getEntityByName(extracted.name);
+        const entityId = existing ? existing.id : createEntity({
+          name: extracted.name,
+          type: extracted.type,
+          project_id: projectId
+        }).id;
+        entityIdMap.set(extracted.name, entityId);
+        linkEntityToMemory(entityId, memoryId, "subject");
+      } catch {}
+    }
+    for (const rel of relations) {
+      const fromId = entityIdMap.get(rel.from);
+      const toId = entityIdMap.get(rel.to);
+      if (!fromId || !toId)
+        continue;
+      try {
+        createRelation({
+          source_entity_id: fromId,
+          target_entity_id: toId,
+          relation_type: rel.type
+        });
+      } catch {}
+    }
+  } catch (err) {
+    console.error("[auto-memory] entity linking failed:", err);
+  }
+}
+async function saveExtractedMemory(extracted, context) {
+  const minImportance = providerRegistry.getConfig().minImportance;
+  if (extracted.importance < minImportance)
+    return null;
+  if (!extracted.content.trim())
+    return null;
+  if (isDuplicate(extracted.content, context.agentId, context.projectId)) {
+    return null;
+  }
+  try {
+    const input = {
+      key: extracted.content.slice(0, 120).replace(/\s+/g, "-").toLowerCase(),
+      value: extracted.content,
+      category: extracted.category,
+      scope: extracted.suggestedScope,
+      importance: extracted.importance,
+      tags: [
+        ...extracted.tags,
+        "auto-extracted",
+        ...context.sessionId ? [`session:${context.sessionId}`] : []
+      ],
+      agent_id: context.agentId,
+      project_id: context.projectId,
+      session_id: context.sessionId,
+      metadata: {
+        reasoning: extracted.reasoning,
+        auto_extracted: true,
+        extracted_at: new Date().toISOString()
+      }
+    };
+    const memory = createMemory(input, "merge");
+    return memory.id;
+  } catch (err) {
+    console.error("[auto-memory] saveExtractedMemory failed:", err);
+    return null;
+  }
+}
+async function processJob(job) {
+  if (!providerRegistry.getConfig().enabled)
+    return;
+  const provider = providerRegistry.getAvailable();
+  if (!provider)
+    return;
+  const context = {
+    agentId: job.agentId,
+    projectId: job.projectId,
+    sessionId: job.sessionId
+  };
+  let extracted = [];
+  try {
+    extracted = await provider.extractMemories(job.turn, context);
+  } catch {
+    const fallbacks = providerRegistry.getFallbacks();
+    for (const fallback of fallbacks) {
+      try {
+        extracted = await fallback.extractMemories(job.turn, context);
+        if (extracted.length > 0)
+          break;
+      } catch {
+        continue;
+      }
+    }
+  }
+  if (extracted.length === 0)
+    return;
+  for (const memory of extracted) {
+    const memoryId = await saveExtractedMemory(memory, context);
+    if (!memoryId)
+      continue;
+    if (providerRegistry.getConfig().autoEntityLink) {
+      linkEntitiesToMemory(memoryId, memory.content, job.agentId, job.projectId);
+    }
+  }
+}
+function processConversationTurn(turn, context, source = "turn") {
+  if (!turn?.trim())
+    return;
+  autoMemoryQueue.enqueue({
+    ...context,
+    turn,
+    timestamp: Date.now(),
+    source
+  });
+}
+function getAutoMemoryStats() {
+  return autoMemoryQueue.getStats();
+}
+function configureAutoMemory(config) {
+  providerRegistry.configure(config);
+}
+var DEDUP_SIMILARITY_THRESHOLD = 0.85;
+var init_auto_memory = __esm(() => {
+  init_memories();
+  init_search();
+  init_entities();
+  init_relations();
+  init_entity_memories();
+  init_registry();
+  init_auto_memory_queue();
+  autoMemoryQueue.setHandler(processJob);
+});
+
+// src/db/webhook_hooks.ts
+var exports_webhook_hooks = {};
+__export(exports_webhook_hooks, {
+  updateWebhookHook: () => updateWebhookHook,
+  recordWebhookInvocation: () => recordWebhookInvocation,
+  listWebhookHooks: () => listWebhookHooks,
+  getWebhookHook: () => getWebhookHook,
+  deleteWebhookHook: () => deleteWebhookHook,
+  createWebhookHook: () => createWebhookHook
+});
+function parseRow(row) {
+  return {
+    id: row["id"],
+    type: row["type"],
+    handlerUrl: row["handler_url"],
+    priority: row["priority"],
+    blocking: Boolean(row["blocking"]),
+    agentId: row["agent_id"] || undefined,
+    projectId: row["project_id"] || undefined,
+    description: row["description"] || undefined,
+    enabled: Boolean(row["enabled"]),
+    createdAt: row["created_at"],
+    invocationCount: row["invocation_count"],
+    failureCount: row["failure_count"]
+  };
+}
+function createWebhookHook(input, db) {
+  const d = db || getDatabase();
+  const id = shortUuid();
+  const timestamp = now();
+  d.run(`INSERT INTO webhook_hooks
+       (id, type, handler_url, priority, blocking, agent_id, project_id, description, enabled, created_at, invocation_count, failure_count)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, 0, 0)`, [
+    id,
+    input.type,
+    input.handlerUrl,
+    input.priority ?? 50,
+    input.blocking ? 1 : 0,
+    input.agentId ?? null,
+    input.projectId ?? null,
+    input.description ?? null,
+    timestamp
+  ]);
+  return getWebhookHook(id, d);
+}
+function getWebhookHook(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM webhook_hooks WHERE id = ?").get(id);
+  return row ? parseRow(row) : null;
+}
+function listWebhookHooks(filter = {}, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter.type) {
+    conditions.push("type = ?");
+    params.push(filter.type);
+  }
+  if (filter.enabled !== undefined) {
+    conditions.push("enabled = ?");
+    params.push(filter.enabled ? 1 : 0);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = d.query(`SELECT * FROM webhook_hooks ${where} ORDER BY priority ASC, created_at ASC`).all(...params);
+  return rows.map(parseRow);
+}
+function updateWebhookHook(id, updates, db) {
+  const d = db || getDatabase();
+  const existing = getWebhookHook(id, d);
+  if (!existing)
+    return null;
+  const sets = [];
+  const params = [];
+  if (updates.enabled !== undefined) {
+    sets.push("enabled = ?");
+    params.push(updates.enabled ? 1 : 0);
+  }
+  if (updates.description !== undefined) {
+    sets.push("description = ?");
+    params.push(updates.description);
+  }
+  if (updates.priority !== undefined) {
+    sets.push("priority = ?");
+    params.push(updates.priority);
+  }
+  if (sets.length > 0) {
+    params.push(id);
+    d.run(`UPDATE webhook_hooks SET ${sets.join(", ")} WHERE id = ?`, params);
+  }
+  return getWebhookHook(id, d);
+}
+function deleteWebhookHook(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM webhook_hooks WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+function recordWebhookInvocation(id, success, db) {
+  const d = db || getDatabase();
+  if (success) {
+    d.run("UPDATE webhook_hooks SET invocation_count = invocation_count + 1 WHERE id = ?", [id]);
+  } else {
+    d.run("UPDATE webhook_hooks SET invocation_count = invocation_count + 1, failure_count = failure_count + 1 WHERE id = ?", [id]);
+  }
+}
+var init_webhook_hooks = __esm(() => {
+  init_database();
+});
+
+// src/db/synthesis.ts
+var exports_synthesis = {};
+__export(exports_synthesis, {
+  updateSynthesisRun: () => updateSynthesisRun,
+  updateProposal: () => updateProposal,
+  recordSynthesisEvent: () => recordSynthesisEvent,
+  listSynthesisRuns: () => listSynthesisRuns,
+  listSynthesisEvents: () => listSynthesisEvents,
+  listProposals: () => listProposals,
+  listMetrics: () => listMetrics,
+  getSynthesisRun: () => getSynthesisRun,
+  getProposal: () => getProposal,
+  createSynthesisRun: () => createSynthesisRun,
+  createProposal: () => createProposal,
+  createMetric: () => createMetric
+});
+function parseRunRow(row) {
+  return {
+    id: row["id"],
+    triggered_by: row["triggered_by"],
+    project_id: row["project_id"] || null,
+    agent_id: row["agent_id"] || null,
+    corpus_size: row["corpus_size"],
+    proposals_generated: row["proposals_generated"],
+    proposals_accepted: row["proposals_accepted"],
+    proposals_rejected: row["proposals_rejected"],
+    status: row["status"],
+    error: row["error"] || null,
+    started_at: row["started_at"],
+    completed_at: row["completed_at"] || null
+  };
+}
+function parseProposalRow(row) {
+  return {
+    id: row["id"],
+    run_id: row["run_id"],
+    proposal_type: row["proposal_type"],
+    memory_ids: JSON.parse(row["memory_ids"] || "[]"),
+    target_memory_id: row["target_memory_id"] || null,
+    proposed_changes: JSON.parse(row["proposed_changes"] || "{}"),
+    reasoning: row["reasoning"] || null,
+    confidence: row["confidence"],
+    status: row["status"],
+    created_at: row["created_at"],
+    executed_at: row["executed_at"] || null,
+    rollback_data: row["rollback_data"] ? JSON.parse(row["rollback_data"]) : null
+  };
+}
+function parseMetricRow(row) {
+  return {
+    id: row["id"],
+    run_id: row["run_id"],
+    metric_type: row["metric_type"],
+    value: row["value"],
+    baseline: row["baseline"] != null ? row["baseline"] : null,
+    created_at: row["created_at"]
+  };
+}
+function parseEventRow(row) {
+  return {
+    id: row["id"],
+    event_type: row["event_type"],
+    memory_id: row["memory_id"] || null,
+    agent_id: row["agent_id"] || null,
+    project_id: row["project_id"] || null,
+    session_id: row["session_id"] || null,
+    query: row["query"] || null,
+    importance_at_time: row["importance_at_time"] != null ? row["importance_at_time"] : null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    created_at: row["created_at"]
+  };
+}
+function createSynthesisRun(input, db) {
+  const d = db || getDatabase();
+  const id = shortUuid();
+  const timestamp = now();
+  d.run(`INSERT INTO synthesis_runs (id, triggered_by, project_id, agent_id, corpus_size, proposals_generated, proposals_accepted, proposals_rejected, status, started_at)
+     VALUES (?, ?, ?, ?, ?, 0, 0, 0, 'pending', ?)`, [
+    id,
+    input.triggered_by,
+    input.project_id ?? null,
+    input.agent_id ?? null,
+    input.corpus_size ?? 0,
+    timestamp
+  ]);
+  return getSynthesisRun(id, d);
+}
+function getSynthesisRun(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM synthesis_runs WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return parseRunRow(row);
+}
+function listSynthesisRuns(filter, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter.project_id !== undefined) {
+    if (filter.project_id === null) {
+      conditions.push("project_id IS NULL");
+    } else {
+      conditions.push("project_id = ?");
+      params.push(filter.project_id);
+    }
+  }
+  if (filter.status) {
+    conditions.push("status = ?");
+    params.push(filter.status);
+  }
+  let sql = "SELECT * FROM synthesis_runs";
+  if (conditions.length > 0) {
+    sql += ` WHERE ${conditions.join(" AND ")}`;
+  }
+  sql += " ORDER BY started_at DESC";
+  if (filter.limit) {
+    sql += " LIMIT ?";
+    params.push(filter.limit);
+  }
+  const rows = d.query(sql).all(...params);
+  return rows.map(parseRunRow);
+}
+function updateSynthesisRun(id, updates, db) {
+  const d = db || getDatabase();
+  const sets = [];
+  const params = [];
+  if (updates.status !== undefined) {
+    sets.push("status = ?");
+    params.push(updates.status);
+  }
+  if (updates.error !== undefined) {
+    sets.push("error = ?");
+    params.push(updates.error);
+  }
+  if (updates.corpus_size !== undefined) {
+    sets.push("corpus_size = ?");
+    params.push(updates.corpus_size);
+  }
+  if (updates.proposals_generated !== undefined) {
+    sets.push("proposals_generated = ?");
+    params.push(updates.proposals_generated);
+  }
+  if (updates.proposals_accepted !== undefined) {
+    sets.push("proposals_accepted = ?");
+    params.push(updates.proposals_accepted);
+  }
+  if (updates.proposals_rejected !== undefined) {
+    sets.push("proposals_rejected = ?");
+    params.push(updates.proposals_rejected);
+  }
+  if (updates.completed_at !== undefined) {
+    sets.push("completed_at = ?");
+    params.push(updates.completed_at);
+  }
+  if (sets.length === 0)
+    return getSynthesisRun(id, d);
+  params.push(id);
+  d.run(`UPDATE synthesis_runs SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getSynthesisRun(id, d);
+}
+function createProposal(input, db) {
+  const d = db || getDatabase();
+  const id = shortUuid();
+  const timestamp = now();
+  d.run(`INSERT INTO synthesis_proposals (id, run_id, proposal_type, memory_ids, target_memory_id, proposed_changes, reasoning, confidence, status, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?)`, [
+    id,
+    input.run_id,
+    input.proposal_type,
+    JSON.stringify(input.memory_ids),
+    input.target_memory_id ?? null,
+    JSON.stringify(input.proposed_changes),
+    input.reasoning ?? null,
+    input.confidence,
+    timestamp
+  ]);
+  return getProposal(id, d);
+}
+function getProposal(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM synthesis_proposals WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return parseProposalRow(row);
+}
+function listProposals(run_id, filter, db) {
+  const d = db || getDatabase();
+  const params = [run_id];
+  let sql = "SELECT * FROM synthesis_proposals WHERE run_id = ?";
+  if (filter?.status) {
+    sql += " AND status = ?";
+    params.push(filter.status);
+  }
+  sql += " ORDER BY created_at ASC";
+  const rows = d.query(sql).all(...params);
+  return rows.map(parseProposalRow);
+}
+function updateProposal(id, updates, db) {
+  const d = db || getDatabase();
+  const sets = [];
+  const params = [];
+  if (updates.status !== undefined) {
+    sets.push("status = ?");
+    params.push(updates.status);
+  }
+  if (updates.executed_at !== undefined) {
+    sets.push("executed_at = ?");
+    params.push(updates.executed_at);
+  }
+  if (updates.rollback_data !== undefined) {
+    sets.push("rollback_data = ?");
+    params.push(JSON.stringify(updates.rollback_data));
+  }
+  if (sets.length === 0)
+    return getProposal(id, d);
+  params.push(id);
+  d.run(`UPDATE synthesis_proposals SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getProposal(id, d);
+}
+function createMetric(input, db) {
+  const d = db || getDatabase();
+  const id = shortUuid();
+  const timestamp = now();
+  d.run(`INSERT INTO synthesis_metrics (id, run_id, metric_type, value, baseline, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)`, [id, input.run_id, input.metric_type, input.value, input.baseline ?? null, timestamp]);
+  return { id, run_id: input.run_id, metric_type: input.metric_type, value: input.value, baseline: input.baseline ?? null, created_at: timestamp };
+}
+function listMetrics(run_id, db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM synthesis_metrics WHERE run_id = ? ORDER BY created_at ASC").all(run_id);
+  return rows.map(parseMetricRow);
+}
+function recordSynthesisEvent(input, db) {
+  try {
+    const d = db || getDatabase();
+    const id = shortUuid();
+    const timestamp = now();
+    d.run(`INSERT INTO synthesis_events (id, event_type, memory_id, agent_id, project_id, session_id, query, importance_at_time, metadata, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      id,
+      input.event_type,
+      input.memory_id ?? null,
+      input.agent_id ?? null,
+      input.project_id ?? null,
+      input.session_id ?? null,
+      input.query ?? null,
+      input.importance_at_time ?? null,
+      JSON.stringify(input.metadata ?? {}),
+      timestamp
+    ]);
+  } catch {}
+}
+function listSynthesisEvents(filter, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter.memory_id) {
+    conditions.push("memory_id = ?");
+    params.push(filter.memory_id);
+  }
+  if (filter.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filter.project_id);
+  }
+  if (filter.event_type) {
+    conditions.push("event_type = ?");
+    params.push(filter.event_type);
+  }
+  if (filter.since) {
+    conditions.push("created_at >= ?");
+    params.push(filter.since);
+  }
+  let sql = "SELECT * FROM synthesis_events";
+  if (conditions.length > 0) {
+    sql += ` WHERE ${conditions.join(" AND ")}`;
+  }
+  sql += " ORDER BY created_at DESC";
+  if (filter.limit) {
+    sql += " LIMIT ?";
+    params.push(filter.limit);
+  }
+  const rows = d.query(sql).all(...params);
+  return rows.map(parseEventRow);
+}
+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
+});
+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
+      });
+    }
+  });
+  hookRegistry.register({
+    type: "OnSessionStart",
+    blocking: false,
+    builtin: true,
+    priority: 100,
+    description: "Record session start as a history memory for analytics",
+    handler: async (ctx) => {
+      const { createMemory: createMemory2 } = await Promise.resolve().then(() => (init_memories(), exports_memories));
+      try {
+        createMemory2({
+          key: `session-start-${ctx.agentId}`,
+          value: `Agent ${ctx.agentId} started session on project ${ctx.projectId} at ${new Date(ctx.timestamp).toISOString()}`,
+          category: "history",
+          scope: "shared",
+          importance: 3,
+          source: "system",
+          agent_id: ctx.agentId,
+          project_id: ctx.projectId,
+          session_id: ctx.sessionId
+        });
+      } catch {}
+    }
+  });
+  hookRegistry.register({
+    type: "PostMemorySave",
+    blocking: false,
+    builtin: true,
+    priority: 200,
+    description: "Record memory save event for synthesis analytics",
+    handler: async (ctx) => {
+      const { recordSynthesisEvent: recordSynthesisEvent2 } = await Promise.resolve().then(() => (init_synthesis(), exports_synthesis));
+      recordSynthesisEvent2({
+        event_type: "saved",
+        memory_id: ctx.memory.id,
+        agent_id: ctx.agentId,
+        project_id: ctx.projectId,
+        session_id: ctx.sessionId,
+        importance_at_time: ctx.memory.importance
+      });
+    }
+  });
+  hookRegistry.register({
+    type: "PostMemoryInject",
+    blocking: false,
+    builtin: true,
+    priority: 200,
+    description: "Record injection event for synthesis analytics",
+    handler: async (ctx) => {
+      const { recordSynthesisEvent: recordSynthesisEvent2 } = await Promise.resolve().then(() => (init_synthesis(), exports_synthesis));
+      recordSynthesisEvent2({
+        event_type: "injected",
+        agent_id: ctx.agentId,
+        project_id: ctx.projectId,
+        session_id: ctx.sessionId,
+        metadata: { count: ctx.memoriesCount, format: ctx.format }
+      });
+    }
+  });
+});
+
+// src/lib/synthesis/corpus-builder.ts
+function extractTerms(text) {
+  const stopWords = new Set([
+    "a",
+    "an",
+    "the",
+    "is",
+    "it",
+    "in",
+    "of",
+    "for",
+    "to",
+    "and",
+    "or",
+    "but",
+    "not",
+    "with",
+    "this",
+    "that",
+    "are",
+    "was",
+    "be",
+    "by",
+    "at",
+    "as",
+    "on",
+    "has",
+    "have",
+    "had",
+    "do",
+    "did",
+    "does",
+    "will",
+    "would",
+    "can",
+    "could",
+    "should",
+    "may",
+    "might",
+    "shall",
+    "from",
+    "into",
+    "then",
+    "than",
+    "so",
+    "if",
+    "up",
+    "out",
+    "about",
+    "its",
+    "my",
+    "we",
+    "i",
+    "you"
+  ]);
+  return new Set(text.toLowerCase().replace(/[^a-z0-9\s\-_]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w)));
+}
+function jaccardSimilarity(a, b) {
+  if (a.size === 0 && b.size === 0)
+    return 0;
+  const intersection = new Set([...a].filter((x) => b.has(x)));
+  const union = new Set([...a, ...b]);
+  return intersection.size / union.size;
+}
+function isStale(memory) {
+  if (memory.status !== "active")
+    return false;
+  if (memory.importance >= 7)
+    return false;
+  if (!memory.accessed_at)
+    return true;
+  const thirtyDaysAgo = Date.now() - 30 * 24 * 60 * 60 * 1000;
+  return new Date(memory.accessed_at).getTime() < thirtyDaysAgo;
+}
+async function buildCorpus(options) {
+  const d = options.db || getDatabase();
+  const limit = options.limit ?? 500;
+  const projectId = options.projectId ?? null;
+  const memories = listMemories({
+    status: "active",
+    project_id: options.projectId,
+    agent_id: options.agentId,
+    limit
+  }, d);
+  const recallEvents = listSynthesisEvents({
+    event_type: "recalled",
+    project_id: options.projectId
+  }, d);
+  const recallCounts = new Map;
+  const lastRecalledMap = new Map;
+  for (const event of recallEvents) {
+    if (!event.memory_id)
+      continue;
+    recallCounts.set(event.memory_id, (recallCounts.get(event.memory_id) ?? 0) + 1);
+    const existing = lastRecalledMap.get(event.memory_id);
+    if (!existing || event.created_at > existing) {
+      lastRecalledMap.set(event.memory_id, event.created_at);
+    }
+  }
+  const searchEvents = listSynthesisEvents({
+    event_type: "searched",
+    project_id: options.projectId
+  }, d);
+  const searchHits = new Map;
+  for (const event of searchEvents) {
+    if (!event.memory_id)
+      continue;
+    searchHits.set(event.memory_id, (searchHits.get(event.memory_id) ?? 0) + 1);
+  }
+  const termSets = new Map;
+  for (const m of memories) {
+    termSets.set(m.id, extractTerms(`${m.key} ${m.value} ${m.summary ?? ""}`));
+  }
+  const duplicateCandidates = [];
+  const similarityThreshold = 0.5;
+  const similarIds = new Map;
+  for (let i = 0;i < memories.length; i++) {
+    const a = memories[i];
+    const termsA = termSets.get(a.id);
+    const aSimIds = [];
+    for (let j = i + 1;j < memories.length; j++) {
+      const b = memories[j];
+      const termsB = termSets.get(b.id);
+      const sim = jaccardSimilarity(termsA, termsB);
+      if (sim >= similarityThreshold) {
+        duplicateCandidates.push({ a, b, similarity: sim });
+        aSimIds.push(b.id);
+        const bSimIds = similarIds.get(b.id) ?? [];
+        bSimIds.push(a.id);
+        similarIds.set(b.id, bSimIds);
+      }
+    }
+    if (aSimIds.length > 0) {
+      const existing = similarIds.get(a.id) ?? [];
+      similarIds.set(a.id, [...existing, ...aSimIds]);
+    }
+  }
+  duplicateCandidates.sort((a, b) => b.similarity - a.similarity);
+  const items = memories.map((memory) => ({
+    memory,
+    recallCount: recallCounts.get(memory.id) ?? 0,
+    lastRecalled: lastRecalledMap.get(memory.id) ?? null,
+    searchHits: searchHits.get(memory.id) ?? 0,
+    similarMemoryIds: similarIds.get(memory.id) ?? []
+  }));
+  const staleMemories = memories.filter(isStale);
+  const lowImportanceHighRecall = memories.filter((m) => m.importance < 5 && (recallCounts.get(m.id) ?? 0) > 3);
+  const highImportanceLowRecall = memories.filter((m) => m.importance > 7 && (recallCounts.get(m.id) ?? 0) === 0);
+  return {
+    projectId,
+    totalMemories: memories.length,
+    items,
+    staleMemories,
+    duplicateCandidates,
+    lowImportanceHighRecall,
+    highImportanceLowRecall,
+    generatedAt: now()
+  };
+}
+var init_corpus_builder = __esm(() => {
+  init_database();
+  init_memories();
+  init_synthesis();
+});
+
+// src/lib/synthesis/llm-analyzer.ts
+function buildCorpusPrompt(corpus, maxProposals) {
+  const lines = [];
+  lines.push(`## Memory Corpus Analysis`);
+  lines.push(`Project: ${corpus.projectId ?? "(global)"}`);
+  lines.push(`Total active memories: ${corpus.totalMemories}`);
+  lines.push(`Analysis generated at: ${corpus.generatedAt}`);
+  lines.push("");
+  if (corpus.staleMemories.length > 0) {
+    lines.push(`## Stale Memories (not accessed in 30+ days, importance < 7)`);
+    lines.push(`Count: ${corpus.staleMemories.length}`);
+    for (const m of corpus.staleMemories.slice(0, 30)) {
+      const accessed = m.accessed_at ?? "never";
+      lines.push(`- id:${m.id} key="${m.key}" importance=${m.importance} lastAccessed=${accessed}`);
+      lines.push(`  value: ${m.value.slice(0, 120)}`);
+    }
+    lines.push("");
+  }
+  if (corpus.duplicateCandidates.length > 0) {
+    lines.push(`## Potential Duplicates (term overlap \u2265 50%)`);
+    lines.push(`Count: ${corpus.duplicateCandidates.length} pairs`);
+    for (const { a, b, similarity } of corpus.duplicateCandidates.slice(0, 20)) {
+      lines.push(`- similarity=${similarity.toFixed(2)}`);
+      lines.push(`  A id:${a.id} key="${a.key}" importance=${a.importance}: ${a.value.slice(0, 80)}`);
+      lines.push(`  B id:${b.id} key="${b.key}" importance=${b.importance}: ${b.value.slice(0, 80)}`);
+    }
+    lines.push("");
+  }
+  if (corpus.lowImportanceHighRecall.length > 0) {
+    lines.push(`## Low Importance But High Recall (candidates for importance promotion)`);
+    for (const m of corpus.lowImportanceHighRecall.slice(0, 20)) {
+      lines.push(`- id:${m.id} key="${m.key}" importance=${m.importance} recall_count=${m.access_count}`);
+    }
+    lines.push("");
+  }
+  if (corpus.highImportanceLowRecall.length > 0) {
+    lines.push(`## High Importance But Never Recalled (may need value update)`);
+    for (const m of corpus.highImportanceLowRecall.slice(0, 20)) {
+      lines.push(`- id:${m.id} key="${m.key}" importance=${m.importance}: ${m.value.slice(0, 80)}`);
+    }
+    lines.push("");
+  }
+  lines.push(`## Instructions`);
+  lines.push(`Generate up to ${maxProposals} proposals as a JSON array. Each proposal must have:`);
+  lines.push(`  - type: "merge" | "archive" | "promote" | "update_value" | "add_tag" | "remove_duplicate"`);
+  lines.push(`  - memory_ids: string[] (IDs this proposal acts on)`);
+  lines.push(`  - target_memory_id: string (optional \u2014 used for merge/remove_duplicate)`);
+  lines.push(`  - proposed_changes: object (e.g. {new_importance:8} or {new_value:"..."} or {tags:["x"]})`);
+  lines.push(`  - reasoning: string (one sentence)`);
+  lines.push(`  - confidence: number 0.0-1.0`);
+  lines.push("");
+  lines.push(`Return ONLY the JSON array. No markdown, no explanation.`);
+  return lines.join(`
+`);
+}
+async function analyzeCorpus(corpus, options) {
+  const startMs = Date.now();
+  const maxProposals = options?.maxProposals ?? 20;
+  const empty = {
+    proposals: [],
+    summary: "No LLM provider available.",
+    analysisDurationMs: 0
+  };
+  let provider = options?.provider ? providerRegistry.getProvider(options.provider) : providerRegistry.getAvailable();
+  if (!provider) {
+    return { ...empty, analysisDurationMs: Date.now() - startMs };
+  }
+  const userPrompt = buildCorpusPrompt(corpus, maxProposals);
+  try {
+    const rawResponse = await callProviderRaw(provider, SYNTHESIS_SYSTEM_PROMPT, userPrompt);
+    if (!rawResponse) {
+      return { ...empty, analysisDurationMs: Date.now() - startMs };
+    }
+    const parsed = parseProposalsResponse(rawResponse);
+    const analysisDurationMs = Date.now() - startMs;
+    const validProposals = parsed.slice(0, maxProposals);
+    return {
+      proposals: validProposals,
+      summary: buildSummary(corpus, validProposals.length),
+      analysisDurationMs
+    };
+  } catch {
+    return { ...empty, analysisDurationMs: Date.now() - startMs };
+  }
+}
+async function callProviderRaw(provider, systemPrompt, userPrompt) {
+  if (!provider)
+    return null;
+  const { config, name } = provider;
+  if (!config.apiKey)
+    return null;
+  const timeoutMs = config.timeoutMs ?? 30000;
+  try {
+    if (name === "anthropic") {
+      return await callAnthropic(config.apiKey, config.model, systemPrompt, userPrompt, timeoutMs);
+    } else if (name === "openai" || name === "cerebras" || name === "grok") {
+      return await callOpenAICompat(name, config.apiKey, config.model, systemPrompt, userPrompt, timeoutMs);
+    }
+  } catch {}
+  return null;
+}
+async function callAnthropic(apiKey, model, systemPrompt, userPrompt, timeoutMs) {
+  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,
+      max_tokens: 2048,
+      system: systemPrompt,
+      messages: [{ role: "user", content: userPrompt }]
+    }),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!response.ok)
+    return null;
+  const data = await response.json();
+  return data.content?.[0]?.text ?? null;
+}
+function getBaseUrlForProvider(providerName) {
+  switch (providerName) {
+    case "openai":
+      return "https://api.openai.com/v1";
+    case "cerebras":
+      return "https://api.cerebras.ai/v1";
+    case "grok":
+      return "https://api.x.ai/v1";
+    default:
+      return "https://api.openai.com/v1";
+  }
+}
+async function callOpenAICompat(providerName, apiKey, model, systemPrompt, userPrompt, timeoutMs) {
+  const baseUrl = getBaseUrlForProvider(providerName);
+  const response = await fetch(`${baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${apiKey}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 2048,
+      temperature: 0,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ]
+    }),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!response.ok)
+    return null;
+  const data = await response.json();
+  return data.choices?.[0]?.message?.content ?? null;
+}
+function parseProposalsResponse(raw) {
+  try {
+    const cleaned = raw.replace(/^```(?:json)?\s*/m, "").replace(/\s*```$/m, "").trim();
+    const parsed = JSON.parse(cleaned);
+    if (!Array.isArray(parsed))
+      return [];
+    const validTypes = new Set([
+      "merge",
+      "archive",
+      "promote",
+      "update_value",
+      "add_tag",
+      "remove_duplicate"
+    ]);
+    return parsed.filter((item) => {
+      if (!item || typeof item !== "object")
+        return false;
+      const p = item;
+      return typeof p["type"] === "string" && validTypes.has(p["type"]) && Array.isArray(p["memory_ids"]) && typeof p["proposed_changes"] === "object" && typeof p["reasoning"] === "string" && typeof p["confidence"] === "number";
+    }).map((p) => ({
+      type: p.type,
+      memory_ids: p.memory_ids.filter((id) => typeof id === "string"),
+      target_memory_id: typeof p.target_memory_id === "string" ? p.target_memory_id : undefined,
+      proposed_changes: p.proposed_changes ?? {},
+      reasoning: p.reasoning,
+      confidence: Math.max(0, Math.min(1, p.confidence))
+    }));
+  } catch {
+    return [];
+  }
+}
+function buildSummary(corpus, proposalCount) {
+  return `Analyzed ${corpus.totalMemories} memories. ` + `Found ${corpus.staleMemories.length} stale, ` + `${corpus.duplicateCandidates.length} duplicate pairs. ` + `Generated ${proposalCount} proposals.`;
+}
+var SYNTHESIS_SYSTEM_PROMPT = "You are a memory synthesizer. Analyze this agent's memory corpus and propose consolidations to improve quality and reduce redundancy. Return ONLY a JSON array of proposal objects.";
+var init_llm_analyzer = __esm(() => {
+  init_registry();
+});
+
+// src/lib/synthesis/validator.ts
+function validateProposals(proposals, corpus, config) {
+  const cfg = { ...DEFAULT_SAFETY_CONFIG, ...config };
+  const memoryMap = new Map(corpus.items.map((item) => [item.memory.id, item.memory]));
+  const rejectedProposals = [];
+  const warnings = [];
+  let archiveCount = 0;
+  let mergeCount = 0;
+  for (const proposal of proposals) {
+    if (proposal.type === "archive" || proposal.type === "remove_duplicate") {
+      archiveCount++;
+    }
+    if (proposal.type === "merge") {
+      mergeCount++;
+    }
+  }
+  const corpusSize = corpus.totalMemories;
+  const archivePercent = corpusSize > 0 ? archiveCount / corpusSize * 100 : 0;
+  const mergePercent = corpusSize > 0 ? mergeCount / corpusSize * 100 : 0;
+  if (archivePercent > cfg.maxArchivePercent) {
+    warnings.push(`Archive proposals (${archiveCount}) exceed ${cfg.maxArchivePercent}% of corpus (${archivePercent.toFixed(1)}%). Some will be rejected.`);
+  }
+  if (mergePercent > cfg.maxMergePercent) {
+    warnings.push(`Merge proposals (${mergeCount}) exceed ${cfg.maxMergePercent}% of corpus (${mergePercent.toFixed(1)}%). Some will be rejected.`);
+  }
+  let remainingArchiveSlots = Math.floor(cfg.maxArchivePercent / 100 * corpusSize);
+  let remainingMergeSlots = Math.floor(cfg.maxMergePercent / 100 * corpusSize);
+  for (let i = 0;i < proposals.length; i++) {
+    const proposal = proposals[i];
+    const proposalRef = `proposal[${i}]`;
+    if (proposal.confidence < cfg.minConfidence) {
+      rejectedProposals.push({
+        proposalId: proposalRef,
+        reason: `Confidence ${proposal.confidence.toFixed(2)} below minimum ${cfg.minConfidence}`
+      });
+      continue;
+    }
+    const missingIds = proposal.memory_ids.filter((id) => !memoryMap.has(id));
+    if (missingIds.length > 0) {
+      rejectedProposals.push({
+        proposalId: proposalRef,
+        reason: `References unknown memory IDs: ${missingIds.join(", ")}`
+      });
+      continue;
+    }
+    if (cfg.protectPinned) {
+      const pinnedIds = proposal.memory_ids.filter((id) => {
+        const m = memoryMap.get(id);
+        return m?.pinned === true;
+      });
+      if (pinnedIds.length > 0) {
+        rejectedProposals.push({
+          proposalId: proposalRef,
+          reason: `Attempts to modify pinned memories: ${pinnedIds.join(", ")}`
+        });
+        continue;
+      }
+    }
+    if (proposal.type === "archive" || proposal.type === "remove_duplicate" || proposal.type === "merge") {
+      const highImportanceIds = proposal.memory_ids.filter((id) => {
+        const m = memoryMap.get(id);
+        return m && m.importance >= cfg.protectHighImportance;
+      });
+      if (highImportanceIds.length > 0) {
+        rejectedProposals.push({
+          proposalId: proposalRef,
+          reason: `Attempts to archive/merge memories with importance \u2265 ${cfg.protectHighImportance}: ${highImportanceIds.join(", ")}`
+        });
+        continue;
+      }
+    }
+    if (proposal.type === "archive" || proposal.type === "remove_duplicate") {
+      if (remainingArchiveSlots <= 0) {
+        rejectedProposals.push({
+          proposalId: proposalRef,
+          reason: `Archive quota exhausted (max ${cfg.maxArchivePercent}% of corpus)`
+        });
+        continue;
+      }
+      remainingArchiveSlots--;
+    }
+    if (proposal.type === "merge") {
+      if (remainingMergeSlots <= 0) {
+        rejectedProposals.push({
+          proposalId: proposalRef,
+          reason: `Merge quota exhausted (max ${cfg.maxMergePercent}% of corpus)`
+        });
+        continue;
+      }
+      remainingMergeSlots--;
+    }
+    if (proposal.target_memory_id && !memoryMap.has(proposal.target_memory_id)) {
+      rejectedProposals.push({
+        proposalId: proposalRef,
+        reason: `target_memory_id "${proposal.target_memory_id}" does not exist in corpus`
+      });
+      continue;
+    }
+  }
+  return {
+    valid: rejectedProposals.length === 0,
+    rejectedProposals,
+    warnings
+  };
+}
+var DEFAULT_SAFETY_CONFIG;
+var init_validator = __esm(() => {
+  DEFAULT_SAFETY_CONFIG = {
+    maxArchivePercent: 20,
+    maxMergePercent: 30,
+    minConfidence: 0.6,
+    protectPinned: true,
+    protectHighImportance: 9
+  };
+});
+
+// src/lib/synthesis/executor.ts
+async function executeProposals(runId, proposals, db) {
+  const d = db || getDatabase();
+  let executed = 0;
+  let failed = 0;
+  const rollbackData = {};
+  for (const proposal of proposals) {
+    try {
+      const rollback = executeProposal(proposal, d);
+      updateProposal(proposal.id, {
+        status: "accepted",
+        executed_at: now(),
+        rollback_data: rollback
+      }, d);
+      rollbackData[proposal.id] = rollback;
+      executed++;
+    } catch (err) {
+      try {
+        updateProposal(proposal.id, { status: "rejected" }, d);
+      } catch {}
+      failed++;
+    }
+  }
+  return { runId, executed, failed, rollbackData };
+}
+function executeProposal(proposal, d) {
+  let rollbackData = {};
+  d.transaction(() => {
+    switch (proposal.proposal_type) {
+      case "archive":
+        rollbackData = executeArchive(proposal, d);
+        break;
+      case "promote":
+        rollbackData = executePromote(proposal, d);
+        break;
+      case "update_value":
+        rollbackData = executeUpdateValue(proposal, d);
+        break;
+      case "add_tag":
+        rollbackData = executeAddTag(proposal, d);
+        break;
+      case "merge":
+        rollbackData = executeMerge(proposal, d);
+        break;
+      case "remove_duplicate":
+        rollbackData = executeRemoveDuplicate(proposal, d);
+        break;
+      default:
+        throw new Error(`Unknown proposal type: ${proposal.proposal_type}`);
+    }
+  })();
+  return rollbackData;
+}
+function executeArchive(proposal, d) {
+  const rollback = {};
+  for (const memId of proposal.memory_ids) {
+    const mem = getMemory(memId, d);
+    if (!mem)
+      continue;
+    rollback[memId] = mem.status;
+    d.run("UPDATE memories SET status = 'archived', updated_at = ? WHERE id = ?", [now(), memId]);
+  }
+  return { old_status: rollback };
+}
+function executePromote(proposal, d) {
+  const newImportance = proposal.proposed_changes["new_importance"];
+  if (typeof newImportance !== "number") {
+    throw new Error("promote proposal missing new_importance in proposed_changes");
+  }
+  const rollback = {};
+  for (const memId of proposal.memory_ids) {
+    const mem = getMemory(memId, d);
+    if (!mem)
+      continue;
+    rollback[memId] = mem.importance;
+    d.run("UPDATE memories SET importance = ?, updated_at = ? WHERE id = ?", [Math.max(1, Math.min(10, Math.round(newImportance))), now(), memId]);
+  }
+  return { old_importance: rollback };
+}
+function executeUpdateValue(proposal, d) {
+  const newValue = proposal.proposed_changes["new_value"];
+  if (typeof newValue !== "string") {
+    throw new Error("update_value proposal missing new_value in proposed_changes");
+  }
+  const rollback = {};
+  const memId = proposal.memory_ids[0];
+  if (!memId)
+    throw new Error("update_value proposal has no memory_ids");
+  const mem = getMemory(memId, d);
+  if (!mem)
+    throw new Error(`Memory ${memId} not found`);
+  rollback[memId] = { value: mem.value, version: mem.version };
+  d.run("UPDATE memories SET value = ?, version = version + 1, updated_at = ? WHERE id = ?", [newValue, now(), memId]);
+  return { old_state: rollback };
+}
+function executeAddTag(proposal, d) {
+  const tagsToAdd = proposal.proposed_changes["tags"];
+  if (!Array.isArray(tagsToAdd)) {
+    throw new Error("add_tag proposal missing tags array in proposed_changes");
+  }
+  const rollback = {};
+  for (const memId of proposal.memory_ids) {
+    const mem = getMemory(memId, d);
+    if (!mem)
+      continue;
+    rollback[memId] = [...mem.tags];
+    const newTags = Array.from(new Set([...mem.tags, ...tagsToAdd]));
+    d.run("UPDATE memories SET tags = ?, updated_at = ? WHERE id = ?", [JSON.stringify(newTags), now(), memId]);
+    const insertTag = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
+    for (const tag of tagsToAdd) {
+      insertTag.run(memId, tag);
+    }
+  }
+  return { old_tags: rollback };
+}
+function executeMerge(proposal, d) {
+  const targetId = proposal.target_memory_id;
+  if (!targetId)
+    throw new Error("merge proposal missing target_memory_id");
+  const target = getMemory(targetId, d);
+  if (!target)
+    throw new Error(`Target memory ${targetId} not found`);
+  const rollback = {
+    target_old_value: target.value,
+    target_old_version: target.version,
+    archived_memories: {}
+  };
+  const sourceValues = [];
+  for (const memId of proposal.memory_ids) {
+    if (memId === targetId)
+      continue;
+    const mem = getMemory(memId, d);
+    if (!mem)
+      continue;
+    sourceValues.push(mem.value);
+    rollback.archived_memories[memId] = mem.status;
+  }
+  const mergedValue = proposal.proposed_changes["merged_value"] ?? [target.value, ...sourceValues].join(`
+---
+`);
+  d.run("UPDATE memories SET value = ?, version = version + 1, updated_at = ? WHERE id = ?", [mergedValue, now(), targetId]);
+  for (const memId of proposal.memory_ids) {
+    if (memId === targetId)
+      continue;
+    d.run("UPDATE memories SET status = 'archived', updated_at = ? WHERE id = ?", [now(), memId]);
+  }
+  return rollback;
+}
+function executeRemoveDuplicate(proposal, d) {
+  const memories = proposal.memory_ids.map((id) => getMemory(id, d)).filter((m) => m !== null);
+  if (memories.length < 2) {
+    throw new Error("remove_duplicate requires at least 2 memories");
+  }
+  memories.sort((a, b) => b.importance - a.importance || a.created_at.localeCompare(b.created_at));
+  const keepId = proposal.target_memory_id ?? memories[0].id;
+  const rollback = {};
+  for (const mem of memories) {
+    if (mem.id === keepId)
+      continue;
+    rollback[mem.id] = mem.status;
+    d.run("UPDATE memories SET status = 'archived', updated_at = ? WHERE id = ?", [now(), mem.id]);
+  }
+  return { old_status: rollback, kept_id: keepId };
+}
+async function rollbackRun(runId, db) {
+  const d = db || getDatabase();
+  const proposals = listProposals(runId, { status: "accepted" }, d);
+  let rolledBack = 0;
+  const errors = [];
+  for (const proposal of proposals) {
+    try {
+      rollbackProposal(proposal, d);
+      updateProposal(proposal.id, { status: "rolled_back" }, d);
+      rolledBack++;
+    } catch (err) {
+      errors.push(`Proposal ${proposal.id} (${proposal.proposal_type}): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { rolled_back: rolledBack, errors };
+}
+function rollbackProposal(proposal, d) {
+  const rb = proposal.rollback_data;
+  if (!rb)
+    return;
+  d.transaction(() => {
+    switch (proposal.proposal_type) {
+      case "archive":
+      case "remove_duplicate": {
+        const oldStatus = rb["old_status"];
+        if (!oldStatus)
+          break;
+        for (const [memId, status] of Object.entries(oldStatus)) {
+          d.run("UPDATE memories SET status = ?, updated_at = ? WHERE id = ?", [status, now(), memId]);
+        }
+        break;
+      }
+      case "promote": {
+        const oldImportance = rb["old_importance"];
+        if (!oldImportance)
+          break;
+        for (const [memId, importance] of Object.entries(oldImportance)) {
+          d.run("UPDATE memories SET importance = ?, updated_at = ? WHERE id = ?", [importance, now(), memId]);
+        }
+        break;
+      }
+      case "update_value": {
+        const oldState = rb["old_state"];
+        if (!oldState)
+          break;
+        for (const [memId, state] of Object.entries(oldState)) {
+          d.run("UPDATE memories SET value = ?, version = ?, updated_at = ? WHERE id = ?", [state.value, state.version, now(), memId]);
+        }
+        break;
+      }
+      case "add_tag": {
+        const oldTags = rb["old_tags"];
+        if (!oldTags)
+          break;
+        for (const [memId, tags] of Object.entries(oldTags)) {
+          d.run("UPDATE memories SET tags = ?, updated_at = ? WHERE id = ?", [JSON.stringify(tags), now(), memId]);
+          d.run("DELETE FROM memory_tags WHERE memory_id = ?", [memId]);
+          const insertTag = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
+          for (const tag of tags) {
+            insertTag.run(memId, tag);
+          }
+        }
+        break;
+      }
+      case "merge": {
+        const targetOldValue = rb["target_old_value"];
+        const targetOldVersion = rb["target_old_version"];
+        const archivedMemories = rb["archived_memories"];
+        const targetId = proposal.target_memory_id;
+        if (targetId && targetOldValue !== undefined && targetOldVersion !== undefined) {
+          d.run("UPDATE memories SET value = ?, version = ?, updated_at = ? WHERE id = ?", [targetOldValue, targetOldVersion, now(), targetId]);
+        }
+        if (archivedMemories) {
+          for (const [memId, status] of Object.entries(archivedMemories)) {
+            d.run("UPDATE memories SET status = ?, updated_at = ? WHERE id = ?", [status, now(), memId]);
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  })();
+}
+var init_executor = __esm(() => {
+  init_database();
+  init_memories();
+  init_synthesis();
 });
 
-// src/lib/auto-memory.ts
-var exports_auto_memory = {};
-__export(exports_auto_memory, {
-  processConversationTurn: () => processConversationTurn,
-  getAutoMemoryStats: () => getAutoMemoryStats,
-  configureAutoMemory: () => configureAutoMemory
+// src/lib/synthesis/metrics.ts
+async function measureEffectiveness(runId, preCorpus, db) {
+  const d = db || getDatabase();
+  const postMemories = listMemories({
+    status: "active",
+    project_id: preCorpus.projectId ?? undefined
+  }, d);
+  const postCount = postMemories.length;
+  const preCount = preCorpus.totalMemories;
+  const corpusReduction = preCount > 0 ? (preCount - postCount) / preCount * 100 : 0;
+  const preAvgImportance = preCorpus.items.length > 0 ? preCorpus.items.reduce((sum, i) => sum + i.memory.importance, 0) / preCorpus.items.length : 0;
+  const postAvgImportance = postMemories.length > 0 ? postMemories.reduce((sum, m) => sum + m.importance, 0) / postMemories.length : 0;
+  const importanceDrift = postAvgImportance - preAvgImportance;
+  const preDuplicatePairs = preCorpus.duplicateCandidates.length;
+  const acceptedProposals = listProposals(runId, { status: "accepted" }, d);
+  const deduplicationProposals = acceptedProposals.filter((p) => p.proposal_type === "remove_duplicate" || p.proposal_type === "merge");
+  const deduplicationRate = preDuplicatePairs > 0 ? deduplicationProposals.length / preDuplicatePairs * 100 : 0;
+  const recallWeight = {
+    corpusReduction: 0.3,
+    importanceDrift: 0.4,
+    deduplicationRate: 0.3
+  };
+  const estimatedRecallImprovement = Math.max(0, Math.min(100, corpusReduction * recallWeight.corpusReduction + Math.max(0, importanceDrift * 10) * recallWeight.importanceDrift + deduplicationRate * recallWeight.deduplicationRate));
+  const metricDefs = [
+    { metric_type: "corpus_reduction_pct", value: corpusReduction, baseline: 0 },
+    { metric_type: "importance_drift", value: importanceDrift, baseline: 0 },
+    { metric_type: "deduplication_rate_pct", value: deduplicationRate, baseline: 0 },
+    { metric_type: "estimated_recall_improvement_pct", value: estimatedRecallImprovement, baseline: 0 },
+    { metric_type: "pre_corpus_size", value: preCount, baseline: preCount },
+    { metric_type: "post_corpus_size", value: postCount, baseline: preCount },
+    { metric_type: "proposals_accepted", value: acceptedProposals.length, baseline: 0 },
+    { metric_type: "pre_avg_importance", value: preAvgImportance, baseline: preAvgImportance },
+    { metric_type: "post_avg_importance", value: postAvgImportance, baseline: preAvgImportance }
+  ];
+  for (const def of metricDefs) {
+    createMetric({
+      run_id: runId,
+      metric_type: def.metric_type,
+      value: def.value,
+      baseline: def.baseline ?? null
+    }, d);
+  }
+  const metrics = listMetrics(runId, d);
+  return {
+    runId,
+    corpusReduction,
+    importanceDrift,
+    deduplicationRate,
+    estimatedRecallImprovement,
+    metrics
+  };
+}
+var init_metrics = __esm(() => {
+  init_database();
+  init_synthesis();
+  init_memories();
 });
-function isDuplicate(content, agentId, projectId) {
+
+// src/lib/synthesis/index.ts
+var exports_synthesis2 = {};
+__export(exports_synthesis2, {
+  runSynthesis: () => runSynthesis,
+  rollbackSynthesis: () => rollbackSynthesis,
+  getSynthesisStatus: () => getSynthesisStatus
+});
+async function runSynthesis(options = {}) {
+  const d = options.db || getDatabase();
+  const projectId = options.projectId ?? null;
+  const agentId = options.agentId ?? null;
+  const dryRun = options.dryRun ?? false;
+  const run = createSynthesisRun({
+    triggered_by: "manual",
+    project_id: projectId,
+    agent_id: agentId
+  }, d);
+  updateSynthesisRun(run.id, { status: "running" }, d);
   try {
-    const query = content.split(/\s+/).filter((w) => w.length > 3).slice(0, 10).join(" ");
-    if (!query)
-      return false;
-    const results = searchMemories(query, {
-      agent_id: agentId,
-      project_id: projectId,
-      limit: 3
+    const corpus = await buildCorpus({
+      projectId: projectId ?? undefined,
+      agentId: agentId ?? undefined,
+      db: d
     });
-    if (results.length === 0)
-      return false;
-    const contentWords = new Set(content.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
-    for (const result of results) {
-      const existingWords = new Set(result.memory.value.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
-      if (contentWords.size === 0 || existingWords.size === 0)
-        continue;
-      const intersection = [...contentWords].filter((w) => existingWords.has(w)).length;
-      const union = new Set([...contentWords, ...existingWords]).size;
-      const similarity = intersection / union;
-      if (similarity >= DEDUP_SIMILARITY_THRESHOLD)
-        return true;
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-async function linkEntitiesToMemory(memoryId, content, _agentId, projectId) {
-  const provider = providerRegistry.getAvailable();
-  if (!provider)
-    return;
-  try {
-    const { entities, relations } = await provider.extractEntities(content);
-    const entityIdMap = new Map;
-    for (const extracted of entities) {
-      if (extracted.confidence < 0.6)
-        continue;
-      try {
-        const existing = getEntityByName(extracted.name);
-        const entityId = existing ? existing.id : createEntity({
-          name: extracted.name,
-          type: extracted.type,
-          project_id: projectId
-        }).id;
-        entityIdMap.set(extracted.name, entityId);
-        linkEntityToMemory(entityId, memoryId, "subject");
-      } catch {}
+    updateSynthesisRun(run.id, { corpus_size: corpus.totalMemories }, d);
+    const analysisResult = await analyzeCorpus(corpus, {
+      provider: options.provider,
+      maxProposals: options.maxProposals ?? 20
+    });
+    const validation = validateProposals(analysisResult.proposals, corpus, options.safetyConfig);
+    const rejectedIndices = new Set(validation.rejectedProposals.map((r) => {
+      const match = r.proposalId.match(/\[(\d+)\]/);
+      return match ? parseInt(match[1], 10) : -1;
+    }));
+    const validProposals = analysisResult.proposals.filter((_, idx) => !rejectedIndices.has(idx));
+    const savedProposals = [];
+    for (const p of validProposals) {
+      const saved = createProposal({
+        run_id: run.id,
+        proposal_type: p.type,
+        memory_ids: p.memory_ids,
+        target_memory_id: p.target_memory_id ?? null,
+        proposed_changes: p.proposed_changes,
+        reasoning: p.reasoning,
+        confidence: p.confidence
+      }, d);
+      savedProposals.push(saved);
+    }
+    updateSynthesisRun(run.id, {
+      proposals_generated: analysisResult.proposals.length,
+      proposals_rejected: validation.rejectedProposals.length
+    }, d);
+    let executedCount = 0;
+    if (!dryRun && savedProposals.length > 0) {
+      const execResult = await executeProposals(run.id, savedProposals, d);
+      executedCount = execResult.executed;
+      updateSynthesisRun(run.id, {
+        proposals_accepted: execResult.executed,
+        proposals_rejected: validation.rejectedProposals.length + execResult.failed,
+        status: "completed",
+        completed_at: now()
+      }, d);
+    } else {
+      updateSynthesisRun(run.id, {
+        status: "completed",
+        completed_at: now()
+      }, d);
     }
-    for (const rel of relations) {
-      const fromId = entityIdMap.get(rel.from);
-      const toId = entityIdMap.get(rel.to);
-      if (!fromId || !toId)
-        continue;
+    let effectivenessReport = null;
+    if (!dryRun && executedCount > 0) {
       try {
-        createRelation({
-          source_entity_id: fromId,
-          target_entity_id: toId,
-          relation_type: rel.type
-        });
+        effectivenessReport = await measureEffectiveness(run.id, corpus, d);
       } catch {}
     }
+    const finalRun = listSynthesisRuns({ project_id: projectId, limit: 1 }, d)[0] ?? run;
+    const finalProposals = listProposals(run.id, undefined, d);
+    return {
+      run: finalRun,
+      proposals: finalProposals,
+      executed: executedCount,
+      metrics: effectivenessReport,
+      dryRun
+    };
   } catch (err) {
-    console.error("[auto-memory] entity linking failed:", err);
+    updateSynthesisRun(run.id, {
+      status: "failed",
+      error: err instanceof Error ? err.message : String(err),
+      completed_at: now()
+    }, d);
+    const failedRun = listSynthesisRuns({ project_id: projectId, limit: 1 }, d)[0] ?? run;
+    return {
+      run: failedRun,
+      proposals: [],
+      executed: 0,
+      metrics: null,
+      dryRun
+    };
   }
 }
-async function saveExtractedMemory(extracted, context) {
-  const minImportance = providerRegistry.getConfig().minImportance;
-  if (extracted.importance < minImportance)
-    return null;
-  if (!extracted.content.trim())
-    return null;
-  if (isDuplicate(extracted.content, context.agentId, context.projectId)) {
-    return null;
+async function rollbackSynthesis(runId, db) {
+  const d = db || getDatabase();
+  const result = await rollbackRun(runId, d);
+  if (result.errors.length === 0) {
+    updateSynthesisRun(runId, { status: "rolled_back", completed_at: now() }, d);
   }
-  try {
-    const input = {
-      key: extracted.content.slice(0, 120).replace(/\s+/g, "-").toLowerCase(),
-      value: extracted.content,
-      category: extracted.category,
-      scope: extracted.suggestedScope,
-      importance: extracted.importance,
-      tags: [
-        ...extracted.tags,
-        "auto-extracted",
-        ...context.sessionId ? [`session:${context.sessionId}`] : []
-      ],
-      agent_id: context.agentId,
-      project_id: context.projectId,
-      session_id: context.sessionId,
-      metadata: {
-        reasoning: extracted.reasoning,
-        auto_extracted: true,
-        extracted_at: new Date().toISOString()
-      }
+  return result;
+}
+function getSynthesisStatus(runId, projectId, db) {
+  const d = db || getDatabase();
+  if (runId) {
+    const recentRuns2 = listSynthesisRuns({ project_id: projectId ?? null, limit: 10 }, d);
+    const specificRun = recentRuns2.find((r) => r.id === runId) ?? null;
+    return {
+      lastRun: specificRun ?? recentRuns2[0] ?? null,
+      recentRuns: recentRuns2
     };
-    const memory = createMemory(input, "merge");
-    return memory.id;
-  } catch (err) {
-    console.error("[auto-memory] saveExtractedMemory failed:", err);
-    return null;
   }
-}
-async function processJob(job) {
-  if (!providerRegistry.getConfig().enabled)
-    return;
-  const provider = providerRegistry.getAvailable();
-  if (!provider)
-    return;
-  const context = {
-    agentId: job.agentId,
-    projectId: job.projectId,
-    sessionId: job.sessionId
+  const recentRuns = listSynthesisRuns({ project_id: projectId ?? null, limit: 10 }, d);
+  return {
+    lastRun: recentRuns[0] ?? null,
+    recentRuns
   };
-  let extracted = [];
-  try {
-    extracted = await provider.extractMemories(job.turn, context);
-  } catch {
-    const fallbacks = providerRegistry.getFallbacks();
-    for (const fallback of fallbacks) {
-      try {
-        extracted = await fallback.extractMemories(job.turn, context);
-        if (extracted.length > 0)
-          break;
-      } catch {
-        continue;
-      }
-    }
-  }
-  if (extracted.length === 0)
-    return;
-  for (const memory of extracted) {
-    const memoryId = await saveExtractedMemory(memory, context);
-    if (!memoryId)
-      continue;
-    if (providerRegistry.getConfig().autoEntityLink) {
-      linkEntitiesToMemory(memoryId, memory.content, job.agentId, job.projectId);
-    }
-  }
-}
-function processConversationTurn(turn, context, source = "turn") {
-  if (!turn?.trim())
-    return;
-  autoMemoryQueue.enqueue({
-    ...context,
-    turn,
-    timestamp: Date.now(),
-    source
-  });
-}
-function getAutoMemoryStats() {
-  return autoMemoryQueue.getStats();
-}
-function configureAutoMemory(config) {
-  providerRegistry.configure(config);
 }
-var DEDUP_SIMILARITY_THRESHOLD = 0.85;
-var init_auto_memory = __esm(() => {
-  init_memories();
-  init_search();
-  init_entities();
-  init_relations();
-  init_entity_memories();
-  init_registry();
-  init_auto_memory_queue();
-  autoMemoryQueue.setHandler(processJob);
+var init_synthesis2 = __esm(() => {
+  init_database();
+  init_synthesis();
+  init_corpus_builder();
+  init_llm_analyzer();
+  init_validator();
+  init_executor();
+  init_metrics();
 });
 
 // node_modules/commander/esm.mjs
@@ -8148,4 +9847,150 @@ autoMemory.command("disable").description("Disable auto-memory extraction").acti
   configureAutoMemory2({ enabled: false });
   console.log(chalk.yellow("\u26A0 Auto-memory disabled"));
 });
+var hooksCmd = program2.command("hooks").description("Hook registry and webhook management");
+hooksCmd.command("list").description("List registered hooks in the in-memory registry").option("--type <type>", "Filter by hook type").action(async (opts) => {
+  const { hookRegistry: hookRegistry2 } = await Promise.resolve().then(() => (init_hooks(), exports_hooks));
+  const hooks = hookRegistry2.list(opts.type);
+  if (hooks.length === 0) {
+    console.log(chalk.gray("No hooks registered."));
+    return;
+  }
+  for (const h of hooks) {
+    const builtinTag = h.builtin ? chalk.blue(" [builtin]") : "";
+    const blockingTag = h.blocking ? chalk.red(" [blocking]") : chalk.gray(" [non-blocking]");
+    console.log(`${chalk.cyan(h.id)} ${chalk.bold(h.type)}${builtinTag}${blockingTag} priority=${h.priority}`);
+    if (h.description)
+      console.log(`  ${chalk.gray(h.description)}`);
+  }
+});
+hooksCmd.command("stats").description("Show hook registry statistics").action(async () => {
+  const { hookRegistry: hookRegistry2 } = await Promise.resolve().then(() => (init_hooks(), exports_hooks));
+  const stats = hookRegistry2.stats();
+  console.log(chalk.bold("Hook Registry Stats"));
+  console.log(`  Total:       ${chalk.cyan(stats.total)}`);
+  console.log(`  Blocking:    ${chalk.red(stats.blocking)}`);
+  console.log(`  Non-blocking:${chalk.green(stats.nonBlocking)}`);
+  if (Object.keys(stats.byType).length > 0) {
+    console.log(chalk.bold(`
+By type:`));
+    for (const [type, count] of Object.entries(stats.byType)) {
+      console.log(`  ${type}: ${count}`);
+    }
+  }
+});
+var webhooksCmd = hooksCmd.command("webhooks").alias("wh").description("Manage persistent HTTP webhook hooks");
+webhooksCmd.command("list").description("List all persisted webhook hooks").option("--type <type>", "Filter by hook type").option("--disabled", "Show only disabled webhooks").action(async (opts) => {
+  const { listWebhookHooks: listWebhookHooks2 } = await Promise.resolve().then(() => (init_webhook_hooks(), exports_webhook_hooks));
+  const webhooks = listWebhookHooks2({
+    type: opts.type,
+    enabled: opts.disabled ? false : undefined
+  });
+  if (webhooks.length === 0) {
+    console.log(chalk.gray("No webhooks registered."));
+    return;
+  }
+  for (const wh of webhooks) {
+    const enabledTag = wh.enabled ? chalk.green("enabled") : chalk.red("disabled");
+    const blockingTag = wh.blocking ? chalk.red("blocking") : chalk.gray("non-blocking");
+    console.log(`${chalk.cyan(wh.id)} [${enabledTag}] ${chalk.bold(wh.type)} \u2192 ${wh.handlerUrl}`);
+    console.log(`  ${blockingTag} | priority=${wh.priority} | invocations=${wh.invocationCount} failures=${wh.failureCount}`);
+    if (wh.description)
+      console.log(`  ${chalk.gray(wh.description)}`);
+  }
+});
+webhooksCmd.command("create <type> <url>").description("Create a persistent webhook hook").option("--blocking", "Block the operation until the webhook responds").option("--priority <n>", "Hook priority (default 50)", "50").option("--agent <id>", "Scope to specific agent").option("--project <id>", "Scope to specific project").option("--description <text>", "Human-readable description").action(async (type, url, opts) => {
+  const { createWebhookHook: createWebhookHook2 } = await Promise.resolve().then(() => (init_webhook_hooks(), exports_webhook_hooks));
+  const { reloadWebhooks: reloadWebhooks2 } = await Promise.resolve().then(() => (init_built_in_hooks(), exports_built_in_hooks));
+  const wh = createWebhookHook2({
+    type,
+    handlerUrl: url,
+    blocking: opts.blocking ?? false,
+    priority: parseInt(opts.priority, 10),
+    agentId: opts.agent,
+    projectId: opts.project,
+    description: opts.description
+  });
+  reloadWebhooks2();
+  console.log(chalk.green("\u2713 Webhook created"));
+  console.log(`  ID:   ${chalk.cyan(wh.id)}`);
+  console.log(`  Type: ${wh.type}`);
+  console.log(`  URL:  ${wh.handlerUrl}`);
+});
+webhooksCmd.command("delete <id>").description("Delete a webhook by ID").action(async (id) => {
+  const { deleteWebhookHook: deleteWebhookHook2 } = await Promise.resolve().then(() => (init_webhook_hooks(), exports_webhook_hooks));
+  const deleted = deleteWebhookHook2(id);
+  if (deleted) {
+    console.log(chalk.green(`\u2713 Webhook ${id} deleted`));
+  } else {
+    console.error(chalk.red(`Webhook not found: ${id}`));
+    process.exit(1);
+  }
+});
+webhooksCmd.command("enable <id>").description("Enable a webhook").action(async (id) => {
+  const { updateWebhookHook: updateWebhookHook2 } = await Promise.resolve().then(() => (init_webhook_hooks(), exports_webhook_hooks));
+  const { reloadWebhooks: reloadWebhooks2 } = await Promise.resolve().then(() => (init_built_in_hooks(), exports_built_in_hooks));
+  const updated = updateWebhookHook2(id, { enabled: true });
+  if (updated) {
+    reloadWebhooks2();
+    console.log(chalk.green(`\u2713 Webhook ${id} enabled`));
+  } else {
+    console.error(chalk.red(`Webhook not found: ${id}`));
+    process.exit(1);
+  }
+});
+webhooksCmd.command("disable <id>").description("Disable a webhook (without deleting it)").action(async (id) => {
+  const { updateWebhookHook: updateWebhookHook2 } = await Promise.resolve().then(() => (init_webhook_hooks(), exports_webhook_hooks));
+  const { reloadWebhooks: reloadWebhooks2 } = await Promise.resolve().then(() => (init_built_in_hooks(), exports_built_in_hooks));
+  const updated = updateWebhookHook2(id, { enabled: false });
+  if (updated) {
+    reloadWebhooks2();
+    console.log(chalk.yellow(`\u2298 Webhook ${id} disabled`));
+  } else {
+    console.error(chalk.red(`Webhook not found: ${id}`));
+    process.exit(1);
+  }
+});
+var synthesisCmd = program2.command("synthesis").alias("synth").description("ALMA memory synthesis \u2014 analyze and consolidate memories");
+synthesisCmd.command("run").description("Run memory synthesis on the corpus").option("--project <id>", "Project ID to synthesize").option("--dry-run", "Preview proposals without applying them").option("--max-proposals <n>", "Maximum proposals to generate", "20").option("--provider <name>", "LLM provider (anthropic, openai, cerebras, grok)").action(async (opts) => {
+  const { runSynthesis: runSynthesis2 } = await Promise.resolve().then(() => (init_synthesis2(), exports_synthesis2));
+  console.log(chalk.blue("Running memory synthesis..."));
+  const result = await runSynthesis2({
+    projectId: opts.project,
+    dryRun: opts.dryRun ?? false,
+    maxProposals: opts.maxProposals ? parseInt(opts.maxProposals) : 20,
+    provider: opts.provider
+  });
+  if (result.dryRun) {
+    console.log(chalk.yellow(`DRY RUN \u2014 ${result.proposals.length} proposals generated (not applied)`));
+  } else {
+    console.log(chalk.green(`\u2713 Synthesis complete`));
+    console.log(`  Corpus:    ${result.run.corpus_size} memories`);
+    console.log(`  Proposals: ${result.run.proposals_generated} generated, ${result.run.proposals_accepted} applied`);
+  }
+  if (result.metrics) {
+    console.log(`  Reduction: ${(result.metrics.corpusReduction * 100).toFixed(1)}%`);
+  }
+  console.log(`  Run ID: ${chalk.cyan(result.run.id)}`);
+});
+synthesisCmd.command("status").description("Show recent synthesis runs").option("--project <id>", "Filter by project").action(async (opts) => {
+  const { listSynthesisRuns: listSynthesisRuns2 } = await Promise.resolve().then(() => (init_synthesis(), exports_synthesis));
+  const runs = listSynthesisRuns2({ project_id: opts.project, limit: 10 });
+  if (runs.length === 0) {
+    console.log(chalk.gray("No synthesis runs found."));
+    return;
+  }
+  for (const run of runs) {
+    const statusColor = run.status === "completed" ? chalk.green : run.status === "failed" ? chalk.red : chalk.yellow;
+    console.log(`${chalk.cyan(run.id)} [${statusColor(run.status)}] corpus=${run.corpus_size} accepted=${run.proposals_accepted}/${run.proposals_generated} ${run.started_at.slice(0, 10)}`);
+  }
+});
+synthesisCmd.command("rollback <runId>").description("Roll back a synthesis run").action(async (runId) => {
+  const { rollbackSynthesis: rollbackSynthesis2 } = await Promise.resolve().then(() => (init_synthesis2(), exports_synthesis2));
+  console.log(chalk.yellow(`Rolling back synthesis run ${runId}...`));
+  const result = await rollbackSynthesis2(runId);
+  console.log(chalk.green(`\u2713 Rolled back ${result.rolled_back} proposals`));
+  if (result.errors.length > 0) {
+    console.log(chalk.red(`  Errors: ${result.errors.join(", ")}`));
+  }
+});
 program2.parse(process.argv);