@hasna/mementos 0.7.0 → 0.8.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 (
@@ -4928,6 +4997,294 @@ 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, {
@@ -5028,6 +5385,964 @@ var init_built_in_hooks = __esm(() => {
       } 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();
 });
 
 // node_modules/commander/esm.mjs
@@ -8635,4 +9950,47 @@ 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(", ")}`));
+  }
+});
 program2.parse(process.argv);