@hasna/mementos 0.7.0 → 0.9.0

package/dist/cli/index.js

@@ -2432,6 +2432,75 @@ 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 (
@@ -2451,7 +2520,30 @@ var init_database = __esm(() => {
   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);
-  `
+  `,
+    `
+CREATE TABLE IF NOT EXISTS session_memory_jobs (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  agent_id TEXT,
+  project_id TEXT,
+  source TEXT NOT NULL DEFAULT 'manual' CHECK(source IN ('claude-code','codex','manual','open-sessions')),
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','processing','completed','failed')),
+  transcript TEXT NOT NULL,
+  chunk_count INTEGER NOT NULL DEFAULT 0,
+  memories_extracted INTEGER NOT NULL DEFAULT 0,
+  error TEXT,
+  metadata TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  started_at TEXT,
+  completed_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_session_memory_jobs_status ON session_memory_jobs(status);
+CREATE INDEX IF NOT EXISTS idx_session_memory_jobs_agent ON session_memory_jobs(agent_id);
+CREATE INDEX IF NOT EXISTS idx_session_memory_jobs_project ON session_memory_jobs(project_id);
+CREATE INDEX IF NOT EXISTS idx_session_memory_jobs_session ON session_memory_jobs(session_id);
+INSERT OR IGNORE INTO _migrations (id) VALUES (13);
+`
   ];
 });
 
@@ -4863,171 +4955,1819 @@ function createWebhookHook(input, db) {
     input.description ?? null,
     timestamp
   ]);
-  return getWebhookHook(id, d);
+  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/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();
+});
+
+// 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 corpus = await buildCorpus({
+      projectId: projectId ?? undefined,
+      agentId: agentId ?? undefined,
+      db: d
+    });
+    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);
+    }
+    let effectivenessReport = null;
+    if (!dryRun && executedCount > 0) {
+      try {
+        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) {
+    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 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);
+  }
+  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 recentRuns = listSynthesisRuns({ project_id: projectId ?? null, limit: 10 }, d);
+  return {
+    lastRun: recentRuns[0] ?? null,
+    recentRuns
+  };
+}
+var init_synthesis2 = __esm(() => {
+  init_database();
+  init_synthesis();
+  init_corpus_builder();
+  init_llm_analyzer();
+  init_validator();
+  init_executor();
+  init_metrics();
+});
+
+// src/db/session-jobs.ts
+var exports_session_jobs = {};
+__export(exports_session_jobs, {
+  updateSessionJob: () => updateSessionJob,
+  listSessionJobs: () => listSessionJobs,
+  getSessionJob: () => getSessionJob,
+  getNextPendingJob: () => getNextPendingJob,
+  createSessionJob: () => createSessionJob
+});
+function parseJobRow(row) {
+  return {
+    id: row["id"],
+    session_id: row["session_id"],
+    agent_id: row["agent_id"] || null,
+    project_id: row["project_id"] || null,
+    source: row["source"],
+    status: row["status"],
+    transcript: row["transcript"],
+    chunk_count: row["chunk_count"],
+    memories_extracted: row["memories_extracted"],
+    error: row["error"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    created_at: row["created_at"],
+    started_at: row["started_at"] || null,
+    completed_at: row["completed_at"] || null
+  };
+}
+function createSessionJob(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const source = input.source ?? "manual";
+  const metadata = JSON.stringify(input.metadata ?? {});
+  d.run(`INSERT INTO session_memory_jobs
+      (id, session_id, agent_id, project_id, source, status, transcript, chunk_count, memories_extracted, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, 'pending', ?, 0, 0, ?, ?)`, [
+    id,
+    input.session_id,
+    input.agent_id ?? null,
+    input.project_id ?? null,
+    source,
+    input.transcript,
+    metadata,
+    timestamp
+  ]);
+  return getSessionJob(id, d);
 }
-function getWebhookHook(id, db) {
+function getSessionJob(id, db) {
   const d = db || getDatabase();
-  const row = d.query("SELECT * FROM webhook_hooks WHERE id = ?").get(id);
-  return row ? parseRow(row) : null;
+  const row = d.query("SELECT * FROM session_memory_jobs WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return parseJobRow(row);
 }
-function listWebhookHooks(filter = {}, db) {
+function listSessionJobs(filter, db) {
   const d = db || getDatabase();
   const conditions = [];
   const params = [];
-  if (filter.type) {
-    conditions.push("type = ?");
-    params.push(filter.type);
+  if (filter?.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(filter.agent_id);
   }
-  if (filter.enabled !== undefined) {
-    conditions.push("enabled = ?");
-    params.push(filter.enabled ? 1 : 0);
+  if (filter?.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filter.project_id);
+  }
+  if (filter?.status) {
+    conditions.push("status = ?");
+    params.push(filter.status);
+  }
+  if (filter?.session_id) {
+    conditions.push("session_id = ?");
+    params.push(filter.session_id);
   }
   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);
+  const limit = filter?.limit ?? 20;
+  const offset = filter?.offset ?? 0;
+  const rows = d.query(`SELECT * FROM session_memory_jobs ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+  return rows.map(parseJobRow);
 }
-function updateWebhookHook(id, updates, db) {
+function updateSessionJob(id, updates, db) {
   const d = db || getDatabase();
-  const existing = getWebhookHook(id, d);
-  if (!existing)
-    return null;
-  const sets = [];
+  const setClauses = [];
   const params = [];
-  if (updates.enabled !== undefined) {
-    sets.push("enabled = ?");
-    params.push(updates.enabled ? 1 : 0);
+  if (updates.status !== undefined) {
+    setClauses.push("status = ?");
+    params.push(updates.status);
   }
-  if (updates.description !== undefined) {
-    sets.push("description = ?");
-    params.push(updates.description);
+  if (updates.chunk_count !== undefined) {
+    setClauses.push("chunk_count = ?");
+    params.push(updates.chunk_count);
   }
-  if (updates.priority !== undefined) {
-    sets.push("priority = ?");
-    params.push(updates.priority);
+  if (updates.memories_extracted !== undefined) {
+    setClauses.push("memories_extracted = ?");
+    params.push(updates.memories_extracted);
   }
-  if (sets.length > 0) {
-    params.push(id);
-    d.run(`UPDATE webhook_hooks SET ${sets.join(", ")} WHERE id = ?`, params);
+  if ("error" in updates) {
+    setClauses.push("error = ?");
+    params.push(updates.error ?? null);
   }
-  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;
+  if ("started_at" in updates) {
+    setClauses.push("started_at = ?");
+    params.push(updates.started_at ?? null);
+  }
+  if ("completed_at" in updates) {
+    setClauses.push("completed_at = ?");
+    params.push(updates.completed_at ?? null);
+  }
+  if (setClauses.length === 0)
+    return getSessionJob(id, d);
+  params.push(id);
+  d.run(`UPDATE session_memory_jobs SET ${setClauses.join(", ")} WHERE id = ?`, params);
+  return getSessionJob(id, d);
 }
-function recordWebhookInvocation(id, success, db) {
+function getNextPendingJob(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]);
-  }
+  const row = d.query("SELECT * FROM session_memory_jobs WHERE status = 'pending' ORDER BY created_at ASC LIMIT 1").get();
+  if (!row)
+    return null;
+  return parseJobRow(row);
 }
-var init_webhook_hooks = __esm(() => {
+var init_session_jobs = __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;
+// src/lib/session-processor.ts
+function chunkTranscript(transcript, chunkSize = 2000, overlap = 200) {
+  if (!transcript || transcript.length === 0)
+    return [];
+  if (transcript.length <= chunkSize)
+    return [transcript];
+  const chunks = [];
+  let start = 0;
+  while (start < transcript.length) {
+    const end = Math.min(start + chunkSize, transcript.length);
+    chunks.push(transcript.slice(start, end));
+    if (end === transcript.length)
+      break;
+    start += chunkSize - overlap;
   }
-  return _processConversationTurn;
+  return chunks;
 }
-function loadWebhooksFromDb() {
-  if (_webhooksLoaded)
-    return;
-  _webhooksLoaded = true;
+async function extractMemoriesFromChunk(chunk, context, db) {
+  const provider = providerRegistry.getAvailable();
+  if (!provider)
+    return 0;
   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 extracted = await provider.extractMemories(SESSION_EXTRACTION_USER_TEMPLATE(chunk, context.sessionId), {
+      sessionId: context.sessionId,
+      agentId: context.agentId,
+      projectId: context.projectId
+    });
+    let savedCount = 0;
+    const sourceTag = context.source ? `source:${context.source}` : "source:manual";
+    for (const memory of extracted) {
+      if (!memory.content || !memory.content.trim())
+        continue;
+      try {
+        createMemory({
+          key: memory.content.slice(0, 120).replace(/\s+/g, "-").toLowerCase(),
+          value: memory.content,
+          category: memory.category,
+          scope: memory.suggestedScope ?? "shared",
+          importance: memory.importance,
+          tags: [
+            ...memory.tags,
+            "session-extracted",
+            sourceTag,
+            `session:${context.sessionId}`
+          ],
+          source: "auto",
+          agent_id: context.agentId,
+          project_id: context.projectId,
+          session_id: context.sessionId,
+          metadata: {
+            auto_extracted: true,
+            session_source: context.source ?? "manual",
+            extracted_at: new Date().toISOString(),
+            reasoning: memory.reasoning
+          }
+        }, "merge", db);
+        savedCount++;
+      } catch {}
     }
-  } catch (err) {
-    console.error("[hooks] Failed to load webhooks from DB:", err);
+    return savedCount;
+  } catch {
+    try {
+      const fallbacks = providerRegistry.getFallbacks();
+      for (const fallback of fallbacks) {
+        try {
+          const extracted = await fallback.extractMemories(SESSION_EXTRACTION_USER_TEMPLATE(chunk, context.sessionId), {
+            sessionId: context.sessionId,
+            agentId: context.agentId,
+            projectId: context.projectId
+          });
+          let savedCount = 0;
+          const sourceTag = context.source ? `source:${context.source}` : "source:manual";
+          for (const memory of extracted) {
+            if (!memory.content || !memory.content.trim())
+              continue;
+            try {
+              createMemory({
+                key: memory.content.slice(0, 120).replace(/\s+/g, "-").toLowerCase(),
+                value: memory.content,
+                category: memory.category,
+                scope: memory.suggestedScope ?? "shared",
+                importance: memory.importance,
+                tags: [
+                  ...memory.tags,
+                  "session-extracted",
+                  sourceTag,
+                  `session:${context.sessionId}`
+                ],
+                source: "auto",
+                agent_id: context.agentId,
+                project_id: context.projectId,
+                session_id: context.sessionId,
+                metadata: {
+                  auto_extracted: true,
+                  session_source: context.source ?? "manual",
+                  extracted_at: new Date().toISOString(),
+                  reasoning: memory.reasoning
+                }
+              }, "merge", db);
+              savedCount++;
+            } catch {}
+          }
+          if (savedCount > 0)
+            return savedCount;
+        } catch {
+          continue;
+        }
+      }
+    } catch {}
+    return 0;
   }
 }
-function makeWebhookHandler(webhookId, url) {
-  return async (context) => {
+async function processSessionJob(jobId, db) {
+  const result = {
+    jobId,
+    chunksProcessed: 0,
+    memoriesExtracted: 0,
+    errors: []
+  };
+  let job;
+  try {
+    job = getSessionJob(jobId, db);
+    if (!job) {
+      result.errors.push(`Job not found: ${jobId}`);
+      return result;
+    }
+  } catch (e) {
+    result.errors.push(`Failed to fetch job: ${String(e)}`);
+    return result;
+  }
+  try {
+    updateSessionJob(jobId, { status: "processing", started_at: new Date().toISOString() }, db);
+  } catch (e) {
+    result.errors.push(`Failed to mark job as processing: ${String(e)}`);
+    return result;
+  }
+  const chunks = chunkTranscript(job.transcript);
+  try {
+    updateSessionJob(jobId, { chunk_count: chunks.length }, db);
+  } catch {}
+  let totalMemories = 0;
+  for (let i = 0;i < chunks.length; i++) {
+    const chunk = chunks[i];
     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);
+      const count = await extractMemoriesFromChunk(chunk, {
+        sessionId: job.session_id,
+        agentId: job.agent_id ?? undefined,
+        projectId: job.project_id ?? undefined,
+        source: job.source
+      }, db);
+      totalMemories += count;
+      result.chunksProcessed++;
+    } catch (e) {
+      result.errors.push(`Chunk ${i} failed: ${String(e)}`);
     }
-  };
+  }
+  result.memoriesExtracted = totalMemories;
+  try {
+    if (result.errors.length > 0 && result.chunksProcessed === 0) {
+      updateSessionJob(jobId, {
+        status: "failed",
+        error: result.errors.join("; "),
+        completed_at: new Date().toISOString(),
+        memories_extracted: totalMemories,
+        chunk_count: chunks.length
+      }, db);
+    } else {
+      updateSessionJob(jobId, {
+        status: "completed",
+        completed_at: new Date().toISOString(),
+        memories_extracted: totalMemories,
+        chunk_count: chunks.length
+      }, db);
+    }
+  } catch (e) {
+    result.errors.push(`Failed to update job status: ${String(e)}`);
+  }
+  return result;
 }
-function reloadWebhooks() {
-  _webhooksLoaded = false;
-  loadWebhooksFromDb();
+var SESSION_EXTRACTION_USER_TEMPLATE = (chunk, sessionId) => `Extract memories from this session chunk (session: ${sessionId}):
+
+${chunk}
+
+Return JSON array: [{"key": "...", "value": "...", "category": "knowledge|fact|preference|history", "importance": 1-10, "tags": [...]}]`;
+var init_session_processor = __esm(() => {
+  init_memories();
+  init_registry();
+  init_session_jobs();
+});
+
+// src/lib/session-queue.ts
+var exports_session_queue = {};
+__export(exports_session_queue, {
+  startSessionQueueWorker: () => startSessionQueueWorker,
+  getSessionQueueStats: () => getSessionQueueStats,
+  enqueueSessionJob: () => enqueueSessionJob
+});
+function enqueueSessionJob(jobId) {
+  _pendingQueue.add(jobId);
+  if (!_isProcessing) {
+    _processNext();
+  }
 }
-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
-      });
+function getSessionQueueStats() {
+  try {
+    const db = getDatabase();
+    const rows = db.query("SELECT status, COUNT(*) as count FROM session_memory_jobs GROUP BY status").all();
+    const stats = {
+      pending: 0,
+      processing: 0,
+      completed: 0,
+      failed: 0
+    };
+    for (const row of rows) {
+      if (row.status === "pending")
+        stats.pending = row.count;
+      else if (row.status === "processing")
+        stats.processing = row.count;
+      else if (row.status === "completed")
+        stats.completed = row.count;
+      else if (row.status === "failed")
+        stats.failed = row.count;
+    }
+    return stats;
+  } catch {
+    return {
+      pending: _pendingQueue.size,
+      processing: _isProcessing ? 1 : 0,
+      completed: 0,
+      failed: 0
+    };
+  }
+}
+function startSessionQueueWorker() {
+  if (_workerStarted)
+    return;
+  _workerStarted = true;
+  setInterval(() => {
+    _processNext();
+  }, 5000);
+}
+async function _processNext() {
+  if (_isProcessing)
+    return;
+  let jobId;
+  if (_pendingQueue.size > 0) {
+    jobId = [..._pendingQueue][0];
+    _pendingQueue.delete(jobId);
+  } else {
+    try {
+      const job = getNextPendingJob();
+      if (job)
+        jobId = job.id;
+    } catch {
+      return;
     }
-  });
-  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 {}
+  }
+  if (!jobId)
+    return;
+  _isProcessing = true;
+  try {
+    await processSessionJob(jobId);
+  } catch {} finally {
+    _isProcessing = false;
+    if (_pendingQueue.size > 0) {
+      _processNext();
     }
-  });
+  }
+}
+var _pendingQueue, _isProcessing = false, _workerStarted = false;
+var init_session_queue = __esm(() => {
+  init_database();
+  init_session_jobs();
+  init_session_processor();
+  _pendingQueue = new Set;
 });
 
 // node_modules/commander/esm.mjs
@@ -8635,4 +10375,129 @@ webhooksCmd.command("disable <id>").description("Disable a webhook (without dele
     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(", ")}`));
+  }
+});
+var sessionCmd = program2.command("session").description("Session auto-memory \u2014 ingest session transcripts for memory extraction");
+sessionCmd.command("ingest <transcriptFile>").description("Ingest a session transcript file for memory extraction").option("--session-id <id>", "Session ID (default: auto-generated)").option("--agent <id>", "Agent ID").option("--project <id>", "Project ID").option("--source <source>", "Source (claude-code, codex, manual, open-sessions)", "manual").action(async (transcriptFile, opts) => {
+  const { readFileSync: readFileSync3 } = await import("fs");
+  const { createSessionJob: createSessionJob2 } = await Promise.resolve().then(() => (init_session_jobs(), exports_session_jobs));
+  const { enqueueSessionJob: enqueueSessionJob2 } = await Promise.resolve().then(() => (init_session_queue(), exports_session_queue));
+  const transcript = readFileSync3(transcriptFile, "utf-8");
+  const sessionId = opts.sessionId ?? `cli-${Date.now()}`;
+  const job = createSessionJob2({
+    session_id: sessionId,
+    transcript,
+    source: opts.source,
+    agent_id: opts.agent,
+    project_id: opts.project
+  });
+  enqueueSessionJob2(job.id);
+  console.log(chalk.green(`\u2713 Session queued: ${chalk.cyan(job.id)}`));
+  console.log(`  Session: ${sessionId}`);
+  console.log(`  Length:  ${transcript.length} chars`);
+});
+sessionCmd.command("status <jobId>").description("Check status of a session extraction job").action(async (jobId) => {
+  const { getSessionJob: getSessionJob2 } = await Promise.resolve().then(() => (init_session_jobs(), exports_session_jobs));
+  const job = getSessionJob2(jobId);
+  if (!job) {
+    console.error(chalk.red(`Job not found: ${jobId}`));
+    process.exit(1);
+  }
+  const statusColor = job.status === "completed" ? chalk.green : job.status === "failed" ? chalk.red : chalk.yellow;
+  console.log(`${chalk.cyan(job.id)} [${statusColor(job.status)}]`);
+  console.log(`  Session:   ${job.session_id}`);
+  console.log(`  Chunks:    ${job.chunk_count}`);
+  console.log(`  Extracted: ${job.memories_extracted} memories`);
+  if (job.error)
+    console.log(chalk.red(`  Error: ${job.error}`));
+});
+sessionCmd.command("list").description("List session extraction jobs").option("--agent <id>", "Filter by agent").option("--project <id>", "Filter by project").option("--status <status>", "Filter by status").option("--limit <n>", "Max results", "20").action(async (opts) => {
+  const { listSessionJobs: listSessionJobs2 } = await Promise.resolve().then(() => (init_session_jobs(), exports_session_jobs));
+  const jobs = listSessionJobs2({
+    agent_id: opts.agent,
+    project_id: opts.project,
+    status: opts.status,
+    limit: parseInt(opts.limit)
+  });
+  if (jobs.length === 0) {
+    console.log(chalk.gray("No session jobs found."));
+    return;
+  }
+  for (const job of jobs) {
+    const statusColor = job.status === "completed" ? chalk.green : job.status === "failed" ? chalk.red : chalk.yellow;
+    console.log(`${chalk.cyan(job.id.slice(0, 8))} [${statusColor(job.status)}] ${job.memories_extracted} memories | ${job.created_at.slice(0, 10)}`);
+  }
+});
+sessionCmd.command("setup-hook").description("Install mementos session hook into Claude Code or Codex").option("--claude", "Install Claude Code stop hook").option("--codex", "Install Codex session hook").option("--show", "Print hook script instead of installing").action(async (opts) => {
+  const { resolve: resolve4 } = await import("path");
+  const hookPath = resolve4(import.meta.dirname, "../../scripts/hooks");
+  if (opts.claude) {
+    const script = `${hookPath}/claude-stop-hook.ts`;
+    if (opts.show) {
+      const { readFileSync: readFileSync3 } = await import("fs");
+      console.log(readFileSync3(script, "utf-8"));
+      return;
+    }
+    console.log(chalk.bold("Claude Code stop hook installation:"));
+    console.log("");
+    console.log("Add to your .claude/settings.json:");
+    console.log(chalk.cyan(JSON.stringify({
+      hooks: {
+        Stop: [{ matcher: "", hooks: [{ type: "command", command: `bun ${script}` }] }]
+      }
+    }, null, 2)));
+    console.log("");
+    console.log(`Or run: ${chalk.cyan(`claude hooks add Stop "bun ${script}"`)}`);
+  } else if (opts.codex) {
+    const script = `${hookPath}/codex-stop-hook.ts`;
+    console.log(chalk.bold("Codex session hook installation:"));
+    console.log("");
+    console.log("Add to ~/.codex/config.toml:");
+    console.log(chalk.cyan(`[hooks]
+session_end = "bun ${script}"`));
+  } else {
+    console.log("Usage: mementos session setup-hook --claude | --codex");
+  }
+});
 program2.parse(process.argv);