@hasna/mementos 0.7.0 → 0.9.0

package/dist/server/index.js

@@ -402,6 +402,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 (
@@ -421,7 +490,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);
+`
   ];
 });
 
@@ -2616,6 +2708,294 @@ var init_auto_memory = __esm(() => {
   autoMemoryQueue.setHandler(processJob);
 });
 
+// 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/server/index.ts
 init_memories();
 import { existsSync as existsSync3 } from "fs";
@@ -3159,6 +3539,41 @@ hookRegistry.register({
     } 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 }
+    });
+  }
+});
 var _webhooksLoaded = false;
 function loadWebhooksFromDb() {
   if (_webhooksLoaded)
@@ -3204,28 +3619,1381 @@ function reloadWebhooks() {
   loadWebhooksFromDb();
 }
 
-// src/server/index.ts
-var DEFAULT_PORT = 19428;
-function parsePort() {
-  const envPort = process.env["PORT"];
-  if (envPort) {
-    const p = parseInt(envPort, 10);
-    if (!Number.isNaN(p))
-      return p;
+// src/lib/synthesis/index.ts
+init_database();
+init_synthesis();
+
+// src/lib/synthesis/corpus-builder.ts
+init_database();
+init_memories();
+init_synthesis();
+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 portArg = process.argv.find((a) => a === "--port" || a.startsWith("--port="));
-  if (portArg) {
-    if (portArg.includes("=")) {
-      return parseInt(portArg.split("=")[1], 10) || DEFAULT_PORT;
+  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]);
     }
-    const idx = process.argv.indexOf(portArg);
-    return parseInt(process.argv[idx + 1], 10) || DEFAULT_PORT;
   }
-  return DEFAULT_PORT;
+  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()
+  };
 }
-function resolveDashboardDir() {
-  const candidates = [];
-  try {
+
+// src/lib/synthesis/llm-analyzer.ts
+init_registry();
+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.";
+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.`;
+}
+
+// src/lib/synthesis/validator.ts
+var DEFAULT_SAFETY_CONFIG = {
+  maxArchivePercent: 20,
+  maxMergePercent: 30,
+  minConfidence: 0.6,
+  protectPinned: true,
+  protectHighImportance: 9
+};
+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
+  };
+}
+
+// src/lib/synthesis/executor.ts
+init_database();
+init_memories();
+init_synthesis();
+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;
+    }
+  })();
+}
+
+// src/lib/synthesis/metrics.ts
+init_database();
+init_synthesis();
+init_memories();
+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
+  };
+}
+
+// src/lib/synthesis/index.ts
+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
+  };
+}
+
+// src/server/index.ts
+init_synthesis();
+
+// src/db/session-jobs.ts
+init_database();
+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 getSessionJob(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM session_memory_jobs WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return parseJobRow(row);
+}
+function listSessionJobs(filter, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter?.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(filter.agent_id);
+  }
+  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 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 updateSessionJob(id, updates, db) {
+  const d = db || getDatabase();
+  const setClauses = [];
+  const params = [];
+  if (updates.status !== undefined) {
+    setClauses.push("status = ?");
+    params.push(updates.status);
+  }
+  if (updates.chunk_count !== undefined) {
+    setClauses.push("chunk_count = ?");
+    params.push(updates.chunk_count);
+  }
+  if (updates.memories_extracted !== undefined) {
+    setClauses.push("memories_extracted = ?");
+    params.push(updates.memories_extracted);
+  }
+  if ("error" in updates) {
+    setClauses.push("error = ?");
+    params.push(updates.error ?? null);
+  }
+  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 getNextPendingJob(db) {
+  const d = db || getDatabase();
+  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);
+}
+
+// src/lib/session-queue.ts
+init_database();
+
+// src/lib/session-processor.ts
+init_memories();
+init_registry();
+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": [...]}]`;
+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 chunks;
+}
+async function extractMemoriesFromChunk(chunk, context, db) {
+  const provider = providerRegistry.getAvailable();
+  if (!provider)
+    return 0;
+  try {
+    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 {}
+    }
+    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;
+  }
+}
+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 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;
+}
+
+// src/lib/session-queue.ts
+var _pendingQueue = new Set;
+var _isProcessing = false;
+var _workerStarted = false;
+function enqueueSessionJob(jobId) {
+  _pendingQueue.add(jobId);
+  if (!_isProcessing) {
+    _processNext();
+  }
+}
+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;
+    }
+  }
+  if (!jobId)
+    return;
+  _isProcessing = true;
+  try {
+    await processSessionJob(jobId);
+  } catch {} finally {
+    _isProcessing = false;
+    if (_pendingQueue.size > 0) {
+      _processNext();
+    }
+  }
+}
+
+// src/lib/session-auto-resolve.ts
+function autoResolveAgentProject(metadata, db) {
+  let agentId = null;
+  let projectId = null;
+  let confidence = "none";
+  const methods = [];
+  if (metadata.agentName) {
+    try {
+      const agent = getAgent(metadata.agentName, db);
+      if (agent) {
+        agentId = agent.id;
+        confidence = "high";
+        methods.push(`agent-by-name:${metadata.agentName}`);
+        if (agent.active_project_id && !projectId) {
+          projectId = agent.active_project_id;
+          methods.push("project-from-agent-active");
+        }
+      }
+    } catch {}
+  }
+  if (metadata.workingDir && !projectId) {
+    try {
+      const project = getProject(metadata.workingDir, db);
+      if (project) {
+        projectId = project.id;
+        if (confidence !== "high")
+          confidence = "high";
+        methods.push(`project-by-path:${metadata.workingDir}`);
+      } else {
+        const allProjects = listProjects(db);
+        for (const p of allProjects) {
+          if (p.path && metadata.workingDir.startsWith(p.path)) {
+            projectId = p.id;
+            if (confidence !== "high")
+              confidence = "high";
+            methods.push(`project-by-path-prefix:${p.path}`);
+            break;
+          }
+        }
+      }
+    } catch {}
+  }
+  if (metadata.gitRemote && !projectId) {
+    try {
+      const repoName = metadata.gitRemote.replace(/\.git$/, "").split(/[/:]/).filter(Boolean).pop();
+      if (repoName) {
+        const project = getProject(repoName, db);
+        if (project) {
+          projectId = project.id;
+          if (confidence === "none")
+            confidence = "low";
+          methods.push(`project-by-git-remote:${repoName}`);
+        }
+      }
+    } catch {}
+  }
+  if (methods.length === 0) {
+    confidence = "none";
+  }
+  return {
+    agentId,
+    projectId,
+    confidence,
+    method: methods.join(", ") || "none"
+  };
+}
+
+// src/server/index.ts
+var DEFAULT_PORT = 19428;
+function parsePort() {
+  const envPort = process.env["PORT"];
+  if (envPort) {
+    const p = parseInt(envPort, 10);
+    if (!Number.isNaN(p))
+      return p;
+  }
+  const portArg = process.argv.find((a) => a === "--port" || a.startsWith("--port="));
+  if (portArg) {
+    if (portArg.includes("=")) {
+      return parseInt(portArg.split("=")[1], 10) || DEFAULT_PORT;
+    }
+    const idx = process.argv.indexOf(portArg);
+    return parseInt(process.argv[idx + 1], 10) || DEFAULT_PORT;
+  }
+  return DEFAULT_PORT;
+}
+function resolveDashboardDir() {
+  const candidates = [];
+  try {
     const scriptDir = dirname3(fileURLToPath(import.meta.url));
     candidates.push(join3(scriptDir, "..", "dashboard", "dist"));
     candidates.push(join3(scriptDir, "..", "..", "dashboard", "dist"));
@@ -4280,8 +6048,77 @@ addRoute("DELETE", "/api/webhooks/:id", (_req, _url, params) => {
     return errorResponse("Webhook not found", 404);
   return new Response(null, { status: 204 });
 });
+addRoute("POST", "/api/synthesis/run", async (req) => {
+  const body = await readJson(req) ?? {};
+  const result = await runSynthesis({
+    projectId: body.project_id,
+    agentId: body.agent_id,
+    dryRun: body.dry_run,
+    maxProposals: body.max_proposals,
+    provider: body.provider
+  });
+  return json(result, result.dryRun ? 200 : 201);
+});
+addRoute("GET", "/api/synthesis/runs", (_req, url) => {
+  const projectId = url.searchParams.get("project_id") ?? undefined;
+  const limit = url.searchParams.get("limit") ? parseInt(url.searchParams.get("limit")) : 20;
+  const runs = listSynthesisRuns({ project_id: projectId, limit });
+  return json({ runs, count: runs.length });
+});
+addRoute("GET", "/api/synthesis/status", (_req, url) => {
+  const projectId = url.searchParams.get("project_id") ?? undefined;
+  const runId = url.searchParams.get("run_id") ?? undefined;
+  return json(getSynthesisStatus(runId, projectId));
+});
+addRoute("POST", "/api/synthesis/rollback/:run_id", async (_req, _url, params) => {
+  const result = await rollbackSynthesis(params["run_id"]);
+  return json(result);
+});
+addRoute("POST", "/api/sessions/ingest", async (req) => {
+  const body = await readJson(req) ?? {};
+  const { transcript, session_id, agent_id, project_id, source, metadata } = body;
+  if (!transcript || typeof transcript !== "string")
+    return errorResponse("transcript is required", 400);
+  if (!session_id || typeof session_id !== "string")
+    return errorResponse("session_id is required", 400);
+  let resolvedAgentId = agent_id;
+  let resolvedProjectId = project_id;
+  if (!resolvedAgentId || !resolvedProjectId) {
+    const resolved = autoResolveAgentProject(metadata ?? {});
+    if (!resolvedAgentId && resolved.agentId)
+      resolvedAgentId = resolved.agentId;
+    if (!resolvedProjectId && resolved.projectId)
+      resolvedProjectId = resolved.projectId;
+  }
+  const job = createSessionJob({
+    session_id,
+    transcript,
+    source: source ?? "manual",
+    agent_id: resolvedAgentId,
+    project_id: resolvedProjectId,
+    metadata: metadata ?? {}
+  });
+  enqueueSessionJob(job.id);
+  return json({ job_id: job.id, status: "queued", message: "Session queued for memory extraction" }, 202);
+});
+addRoute("GET", "/api/sessions/jobs", (_req, url) => {
+  const agentId = url.searchParams.get("agent_id") ?? undefined;
+  const projectId = url.searchParams.get("project_id") ?? undefined;
+  const status = url.searchParams.get("status") ?? undefined;
+  const limit = url.searchParams.get("limit") ? parseInt(url.searchParams.get("limit")) : 20;
+  const jobs = listSessionJobs({ agent_id: agentId, project_id: projectId, status, limit });
+  return json({ jobs, count: jobs.length });
+});
+addRoute("GET", "/api/sessions/jobs/:id", (_req, _url, params) => {
+  const job = getSessionJob(params["id"]);
+  if (!job)
+    return errorResponse("Session job not found", 404);
+  return json(job);
+});
+addRoute("GET", "/api/sessions/queue/stats", () => json(getSessionQueueStats()));
 function startServer(port) {
   loadWebhooksFromDb();
+  startSessionQueueWorker();
   const hostname = process.env["MEMENTOS_HOST"] ?? "127.0.0.1";
   Bun.serve({
     port,