@hasna/mementos 0.4.41 → 0.6.0

package/dist/index.js

@@ -341,6 +341,11 @@ var MIGRATIONS = [
   CREATE INDEX IF NOT EXISTS idx_resource_locks_agent ON resource_locks(agent_id);
   CREATE INDEX IF NOT EXISTS idx_resource_locks_expires ON resource_locks(expires_at);
   INSERT OR IGNORE INTO _migrations (id) VALUES (8);
+  `,
+  `
+  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);
   `
 ];
 var _db = null;
@@ -438,1387 +443,1026 @@ function containsSecrets(text) {
   return false;
 }
 
-// src/db/agents.ts
-var CONFLICT_WINDOW_MS = 30 * 60 * 1000;
-function parseAgentRow(row) {
+// src/db/entity-memories.ts
+function parseEntityRow(row) {
   return {
     id: row["id"],
     name: row["name"],
-    session_id: row["session_id"] || null,
+    type: row["type"],
     description: row["description"] || null,
-    role: row["role"] || null,
     metadata: JSON.parse(row["metadata"] || "{}"),
-    active_project_id: row["active_project_id"] || null,
+    project_id: row["project_id"] || null,
     created_at: row["created_at"],
-    last_seen_at: row["last_seen_at"]
+    updated_at: row["updated_at"]
   };
 }
-function registerAgent(name, sessionId, description, role, projectId, db) {
-  const d = db || getDatabase();
-  const timestamp = now();
-  const normalizedName = name.trim().toLowerCase();
-  const existing = d.query("SELECT * FROM agents WHERE LOWER(name) = ?").get(normalizedName);
-  if (existing) {
-    const existingId = existing["id"];
-    const existingSessionId = existing["session_id"] || null;
-    const existingLastSeen = existing["last_seen_at"];
-    if (sessionId && existingSessionId && existingSessionId !== sessionId) {
-      const lastSeenMs = new Date(existingLastSeen).getTime();
-      const nowMs = Date.now();
-      if (nowMs - lastSeenMs < CONFLICT_WINDOW_MS) {
-        throw new AgentConflictError({
-          existing_id: existingId,
-          existing_name: normalizedName,
-          last_seen_at: existingLastSeen,
-          session_hint: existingSessionId.slice(0, 8),
-          working_dir: null
-        });
-      }
-    }
-    d.run("UPDATE agents SET last_seen_at = ?, session_id = ? WHERE id = ?", [
-      timestamp,
-      sessionId ?? existingSessionId,
-      existingId
-    ]);
-    if (description) {
-      d.run("UPDATE agents SET description = ? WHERE id = ?", [description, existingId]);
-    }
-    if (role) {
-      d.run("UPDATE agents SET role = ? WHERE id = ?", [role, existingId]);
-    }
-    if (projectId !== undefined) {
-      d.run("UPDATE agents SET active_project_id = ? WHERE id = ?", [projectId, existingId]);
-    }
-    return getAgent(existingId, d);
-  }
-  const id = shortUuid();
-  d.run("INSERT INTO agents (id, name, session_id, description, role, active_project_id, created_at, last_seen_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [id, normalizedName, sessionId ?? null, description || null, role || "agent", projectId ?? null, timestamp, timestamp]);
-  return getAgent(id, d);
+function parseEntityMemoryRow(row) {
+  return {
+    entity_id: row["entity_id"],
+    memory_id: row["memory_id"],
+    role: row["role"],
+    created_at: row["created_at"]
+  };
 }
-function getAgent(idOrName, db) {
+function linkEntityToMemory(entityId, memoryId, role = "context", db) {
   const d = db || getDatabase();
-  let row = d.query("SELECT * FROM agents WHERE id = ?").get(idOrName);
-  if (row)
-    return parseAgentRow(row);
-  row = d.query("SELECT * FROM agents WHERE LOWER(name) = ?").get(idOrName.trim().toLowerCase());
-  if (row)
-    return parseAgentRow(row);
-  const rows = d.query("SELECT * FROM agents WHERE id LIKE ?").all(`${idOrName}%`);
-  if (rows.length === 1)
-    return parseAgentRow(rows[0]);
-  return null;
+  const timestamp = now();
+  d.run(`INSERT OR IGNORE INTO entity_memories (entity_id, memory_id, role, created_at)
+     VALUES (?, ?, ?, ?)`, [entityId, memoryId, role, timestamp]);
+  const row = d.query("SELECT * FROM entity_memories WHERE entity_id = ? AND memory_id = ?").get(entityId, memoryId);
+  return parseEntityMemoryRow(row);
 }
-function listAgents(db) {
+function unlinkEntityFromMemory(entityId, memoryId, db) {
   const d = db || getDatabase();
-  const rows = d.query("SELECT * FROM agents ORDER BY last_seen_at DESC").all();
-  return rows.map(parseAgentRow);
+  d.run("DELETE FROM entity_memories WHERE entity_id = ? AND memory_id = ?", [entityId, memoryId]);
 }
-function touchAgent(idOrName, db) {
+function getMemoriesForEntity(entityId, db) {
   const d = db || getDatabase();
-  const agent = getAgent(idOrName, d);
-  if (!agent)
-    return;
-  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), agent.id]);
+  const rows = d.query(`SELECT m.* FROM memories m
+       INNER JOIN entity_memories em ON em.memory_id = m.id
+       WHERE em.entity_id = ?
+       ORDER BY m.importance DESC, m.created_at DESC`).all(entityId);
+  return rows.map(parseMemoryRow);
 }
-function listAgentsByProject(projectId, db) {
+function getEntitiesForMemory(memoryId, db) {
   const d = db || getDatabase();
-  const rows = d.query("SELECT * FROM agents WHERE active_project_id = ? ORDER BY last_seen_at DESC").all(projectId);
-  return rows.map(parseAgentRow);
+  const rows = d.query(`SELECT e.* FROM entities e
+       INNER JOIN entity_memories em ON em.entity_id = e.id
+       WHERE em.memory_id = ?
+       ORDER BY e.name ASC`).all(memoryId);
+  return rows.map(parseEntityRow);
 }
-function updateAgent(id, updates, db) {
+function bulkLinkEntities(entityIds, memoryId, role = "context", db) {
   const d = db || getDatabase();
-  const agent = getAgent(id, d);
-  if (!agent)
-    return null;
   const timestamp = now();
-  if (updates.name) {
-    const normalizedNewName = updates.name.trim().toLowerCase();
-    if (normalizedNewName !== agent.name) {
-      const existing = d.query("SELECT id FROM agents WHERE LOWER(name) = ? AND id != ?").get(normalizedNewName, agent.id);
-      if (existing) {
-        throw new Error(`Agent name already taken: ${normalizedNewName}`);
-      }
-      d.run("UPDATE agents SET name = ? WHERE id = ?", [normalizedNewName, agent.id]);
+  const tx = d.transaction(() => {
+    const stmt = d.prepare(`INSERT OR IGNORE INTO entity_memories (entity_id, memory_id, role, created_at)
+       VALUES (?, ?, ?, ?)`);
+    for (const entityId of entityIds) {
+      stmt.run(entityId, memoryId, role, timestamp);
     }
-  }
-  if (updates.description !== undefined) {
-    d.run("UPDATE agents SET description = ? WHERE id = ?", [updates.description, agent.id]);
-  }
-  if (updates.role !== undefined) {
-    d.run("UPDATE agents SET role = ? WHERE id = ?", [updates.role, agent.id]);
-  }
-  if (updates.metadata !== undefined) {
-    d.run("UPDATE agents SET metadata = ? WHERE id = ?", [JSON.stringify(updates.metadata), agent.id]);
-  }
-  if ("active_project_id" in updates) {
-    d.run("UPDATE agents SET active_project_id = ? WHERE id = ?", [updates.active_project_id ?? null, agent.id]);
-  }
-  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [timestamp, agent.id]);
-  return getAgent(agent.id, d);
-}
-
-// src/db/projects.ts
-function parseProjectRow(row) {
-  return {
-    id: row["id"],
-    name: row["name"],
-    path: row["path"],
-    description: row["description"] || null,
-    memory_prefix: row["memory_prefix"] || null,
-    created_at: row["created_at"],
-    updated_at: row["updated_at"]
-  };
-}
-function registerProject(name, path, description, memoryPrefix, db) {
-  const d = db || getDatabase();
-  const timestamp = now();
-  const existing = d.query("SELECT * FROM projects WHERE path = ?").get(path);
-  if (existing) {
-    const existingId = existing["id"];
-    d.run("UPDATE projects SET updated_at = ? WHERE id = ?", [
-      timestamp,
-      existingId
-    ]);
-    return parseProjectRow(existing);
-  }
-  const id = uuid();
-  d.run("INSERT INTO projects (id, name, path, description, memory_prefix, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)", [id, name, path, description || null, memoryPrefix || null, timestamp, timestamp]);
-  return getProject(id, d);
-}
-function getProject(idOrPath, db) {
-  const d = db || getDatabase();
-  let row = d.query("SELECT * FROM projects WHERE id = ?").get(idOrPath);
-  if (row)
-    return parseProjectRow(row);
-  row = d.query("SELECT * FROM projects WHERE path = ?").get(idOrPath);
-  if (row)
-    return parseProjectRow(row);
-  row = d.query("SELECT * FROM projects WHERE LOWER(name) = ?").get(idOrPath.toLowerCase());
-  if (row)
-    return parseProjectRow(row);
-  return null;
+  });
+  tx();
 }
-function listProjects(db) {
+function getEntityMemoryLinks(entityId, memoryId, db) {
   const d = db || getDatabase();
-  const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
-  return rows.map(parseProjectRow);
-}
-
-// src/lib/extractor.ts
-var TECH_KEYWORDS = new Set([
-  "typescript",
-  "javascript",
-  "python",
-  "rust",
-  "go",
-  "java",
-  "ruby",
-  "swift",
-  "kotlin",
-  "react",
-  "vue",
-  "angular",
-  "svelte",
-  "nextjs",
-  "bun",
-  "node",
-  "deno",
-  "sqlite",
-  "postgres",
-  "mysql",
-  "redis",
-  "docker",
-  "kubernetes",
-  "git",
-  "npm",
-  "yarn",
-  "pnpm",
-  "webpack",
-  "vite",
-  "tailwind",
-  "prisma",
-  "drizzle",
-  "zod",
-  "commander",
-  "express",
-  "fastify",
-  "hono"
-]);
-var FILE_PATH_RE = /(?:^|\s)((?:\/|\.\/|~\/)?(?:[\w.-]+\/)+[\w.-]+\.\w+)/g;
-var URL_RE = /https?:\/\/[^\s)]+/g;
-var NPM_PACKAGE_RE = /@[\w-]+\/[\w.-]+/g;
-var PASCAL_CASE_RE = /\b([A-Z][a-z]+(?:[A-Z][a-z]+)+)\b/g;
-function getSearchText(memory) {
-  const parts = [memory.key, memory.value];
-  if (memory.summary)
-    parts.push(memory.summary);
-  return parts.join(" ");
-}
-function extractEntities(memory, db) {
-  const text = getSearchText(memory);
-  const entityMap = new Map;
-  function add(name, type, confidence) {
-    const normalized = name.toLowerCase();
-    if (normalized.length < 3)
-      return;
-    const existing = entityMap.get(normalized);
-    if (!existing || existing.confidence < confidence) {
-      entityMap.set(normalized, { name: normalized, type, confidence });
-    }
-  }
-  for (const match of text.matchAll(FILE_PATH_RE)) {
-    add(match[1].trim(), "file", 0.9);
-  }
-  for (const match of text.matchAll(URL_RE)) {
-    add(match[0], "api", 0.8);
-  }
-  for (const match of text.matchAll(NPM_PACKAGE_RE)) {
-    add(match[0], "tool", 0.85);
+  const conditions = [];
+  const params = [];
+  if (entityId) {
+    conditions.push("entity_id = ?");
+    params.push(entityId);
   }
-  try {
-    const d = db || getDatabase();
-    const agents = listAgents(d);
-    const textLower2 = text.toLowerCase();
-    for (const agent of agents) {
-      const nameLower = agent.name.toLowerCase();
-      if (nameLower.length >= 3 && textLower2.includes(nameLower)) {
-        add(agent.name, "person", 0.95);
-      }
-    }
-  } catch {}
-  try {
-    const d = db || getDatabase();
-    const projects = listProjects(d);
-    const textLower2 = text.toLowerCase();
-    for (const project of projects) {
-      const nameLower = project.name.toLowerCase();
-      if (nameLower.length >= 3 && textLower2.includes(nameLower)) {
-        add(project.name, "project", 0.95);
-      }
-    }
-  } catch {}
-  const textLower = text.toLowerCase();
-  for (const keyword of TECH_KEYWORDS) {
-    const re = new RegExp(`\\b${keyword}\\b`, "i");
-    if (re.test(textLower)) {
-      add(keyword, "tool", 0.7);
-    }
+  if (memoryId) {
+    conditions.push("memory_id = ?");
+    params.push(memoryId);
   }
-  for (const match of text.matchAll(PASCAL_CASE_RE)) {
-    add(match[1], "concept", 0.5);
+  let sql = "SELECT * FROM entity_memories";
+  if (conditions.length > 0) {
+    sql += ` WHERE ${conditions.join(" AND ")}`;
   }
-  return Array.from(entityMap.values()).sort((a, b) => b.confidence - a.confidence);
+  sql += " ORDER BY created_at DESC";
+  const rows = d.query(sql).all(...params);
+  return rows.map(parseEntityMemoryRow);
 }
 
-// src/db/entities.ts
-function parseEntityRow(row) {
+// src/db/memories.ts
+function runEntityExtraction(_memory, _projectId, _d) {}
+function parseMemoryRow(row) {
   return {
     id: row["id"],
-    name: row["name"],
-    type: row["type"],
-    description: row["description"] || null,
-    metadata: JSON.parse(row["metadata"] || "{}"),
+    key: row["key"],
+    value: row["value"],
+    category: row["category"],
+    scope: row["scope"],
+    summary: row["summary"] || null,
+    tags: JSON.parse(row["tags"] || "[]"),
+    importance: row["importance"],
+    source: row["source"],
+    status: row["status"],
+    pinned: !!row["pinned"],
+    agent_id: row["agent_id"] || null,
     project_id: row["project_id"] || null,
+    session_id: row["session_id"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    access_count: row["access_count"],
+    version: row["version"],
+    expires_at: row["expires_at"] || null,
     created_at: row["created_at"],
-    updated_at: row["updated_at"]
+    updated_at: row["updated_at"],
+    accessed_at: row["accessed_at"] || null
   };
 }
-function createEntity(input, db) {
+function createMemory(input, dedupeMode = "merge", db) {
   const d = db || getDatabase();
   const timestamp = now();
+  let expiresAt = input.expires_at || null;
+  if (input.ttl_ms && !expiresAt) {
+    expiresAt = new Date(Date.now() + input.ttl_ms).toISOString();
+  }
+  const id = uuid();
+  const tags = input.tags || [];
+  const tagsJson = JSON.stringify(tags);
   const metadataJson = JSON.stringify(input.metadata || {});
-  const existing = d.query(`SELECT * FROM entities
-       WHERE name = ? AND type = ? AND COALESCE(project_id, '') = ?`).get(input.name, input.type, input.project_id || "");
-  if (existing) {
-    const sets = ["updated_at = ?"];
-    const params = [timestamp];
-    if (input.description !== undefined) {
-      sets.push("description = ?");
-      params.push(input.description);
-    }
-    if (input.metadata !== undefined) {
-      sets.push("metadata = ?");
-      params.push(metadataJson);
+  const safeValue = redactSecrets(input.value);
+  const safeSummary = input.summary ? redactSecrets(input.summary) : null;
+  if (dedupeMode === "merge") {
+    const existing = d.query(`SELECT id, version FROM memories
+         WHERE key = ? AND scope = ?
+           AND COALESCE(agent_id, '') = ?
+           AND COALESCE(project_id, '') = ?
+           AND COALESCE(session_id, '') = ?`).get(input.key, input.scope || "private", input.agent_id || "", input.project_id || "", input.session_id || "");
+    if (existing) {
+      d.run(`UPDATE memories SET
+           value = ?, category = ?, summary = ?, tags = ?,
+           importance = ?, metadata = ?, expires_at = ?,
+           pinned = COALESCE(pinned, 0),
+           version = version + 1, updated_at = ?
+         WHERE id = ?`, [
+        safeValue,
+        input.category || "knowledge",
+        safeSummary,
+        tagsJson,
+        input.importance ?? 5,
+        metadataJson,
+        expiresAt,
+        timestamp,
+        existing.id
+      ]);
+      d.run("DELETE FROM memory_tags WHERE memory_id = ?", [existing.id]);
+      const insertTag2 = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
+      for (const tag of tags) {
+        insertTag2.run(existing.id, tag);
+      }
+      const merged = getMemory(existing.id, d);
+      try {
+        const oldLinks = getEntityMemoryLinks(undefined, merged.id, d);
+        for (const link of oldLinks) {
+          unlinkEntityFromMemory(link.entity_id, merged.id, d);
+        }
+        runEntityExtraction(merged, input.project_id, d);
+      } catch {}
+      return merged;
     }
-    const existingId = existing["id"];
-    params.push(existingId);
-    d.run(`UPDATE entities SET ${sets.join(", ")} WHERE id = ?`, params);
-    return getEntity(existingId, d);
   }
-  const id = shortUuid();
-  d.run(`INSERT INTO entities (id, name, type, description, metadata, project_id, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+  d.run(`INSERT INTO memories (id, key, value, category, scope, summary, tags, importance, source, status, pinned, agent_id, project_id, session_id, metadata, access_count, version, expires_at, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', 0, ?, ?, ?, ?, 0, 1, ?, ?, ?)`, [
     id,
-    input.name,
-    input.type,
-    input.description || null,
-    metadataJson,
+    input.key,
+    input.value,
+    input.category || "knowledge",
+    input.scope || "private",
+    input.summary || null,
+    tagsJson,
+    input.importance ?? 5,
+    input.source || "agent",
+    input.agent_id || null,
     input.project_id || null,
+    input.session_id || null,
+    metadataJson,
+    expiresAt,
     timestamp,
     timestamp
   ]);
-  return getEntity(id, d);
+  const insertTag = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
+  for (const tag of tags) {
+    insertTag.run(id, tag);
+  }
+  const memory = getMemory(id, d);
+  try {
+    runEntityExtraction(memory, input.project_id, d);
+  } catch {}
+  return memory;
 }
-function getEntity(id, db) {
+function getMemory(id, db) {
   const d = db || getDatabase();
-  const row = d.query("SELECT * FROM entities WHERE id = ?").get(id);
+  const row = d.query("SELECT * FROM memories WHERE id = ?").get(id);
   if (!row)
-    throw new EntityNotFoundError(id);
-  return parseEntityRow(row);
+    return null;
+  return parseMemoryRow(row);
 }
-function getEntityByName(name, type, projectId, db) {
+function getMemoryByKey(key, scope, agentId, projectId, sessionId, db) {
   const d = db || getDatabase();
-  let sql = "SELECT * FROM entities WHERE name = ?";
-  const params = [name];
-  if (type) {
-    sql += " AND type = ?";
-    params.push(type);
+  let sql = "SELECT * FROM memories WHERE key = ?";
+  const params = [key];
+  if (scope) {
+    sql += " AND scope = ?";
+    params.push(scope);
   }
-  if (projectId !== undefined) {
+  if (agentId) {
+    sql += " AND agent_id = ?";
+    params.push(agentId);
+  }
+  if (projectId) {
     sql += " AND project_id = ?";
     params.push(projectId);
   }
-  sql += " LIMIT 1";
+  if (sessionId) {
+    sql += " AND session_id = ?";
+    params.push(sessionId);
+  }
+  sql += " AND status = 'active' ORDER BY importance DESC LIMIT 1";
   const row = d.query(sql).get(...params);
   if (!row)
     return null;
-  return parseEntityRow(row);
+  return parseMemoryRow(row);
 }
-function listEntities(filter = {}, db) {
+function getMemoriesByKey(key, scope, agentId, projectId, db) {
   const d = db || getDatabase();
-  const conditions = [];
-  const params = [];
-  if (filter.type) {
-    conditions.push("type = ?");
-    params.push(filter.type);
+  let sql = "SELECT * FROM memories WHERE key = ?";
+  const params = [key];
+  if (scope) {
+    sql += " AND scope = ?";
+    params.push(scope);
   }
-  if (filter.project_id) {
-    conditions.push("project_id = ?");
-    params.push(filter.project_id);
+  if (agentId) {
+    sql += " AND agent_id = ?";
+    params.push(agentId);
   }
-  if (filter.search) {
-    conditions.push("(name LIKE ? OR description LIKE ?)");
-    const term = `%${filter.search}%`;
-    params.push(term, term);
+  if (projectId) {
+    sql += " AND project_id = ?";
+    params.push(projectId);
   }
-  let sql = "SELECT * FROM entities";
+  sql += " AND status = 'active' ORDER BY importance DESC";
+  const rows = d.query(sql).all(...params);
+  return rows.map(parseMemoryRow);
+}
+function listMemories(filter, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter) {
+    if (filter.scope) {
+      if (Array.isArray(filter.scope)) {
+        conditions.push(`scope IN (${filter.scope.map(() => "?").join(",")})`);
+        params.push(...filter.scope);
+      } else {
+        conditions.push("scope = ?");
+        params.push(filter.scope);
+      }
+    }
+    if (filter.category) {
+      if (Array.isArray(filter.category)) {
+        conditions.push(`category IN (${filter.category.map(() => "?").join(",")})`);
+        params.push(...filter.category);
+      } else {
+        conditions.push("category = ?");
+        params.push(filter.category);
+      }
+    }
+    if (filter.source) {
+      if (Array.isArray(filter.source)) {
+        conditions.push(`source IN (${filter.source.map(() => "?").join(",")})`);
+        params.push(...filter.source);
+      } else {
+        conditions.push("source = ?");
+        params.push(filter.source);
+      }
+    }
+    if (filter.status) {
+      if (Array.isArray(filter.status)) {
+        conditions.push(`status IN (${filter.status.map(() => "?").join(",")})`);
+        params.push(...filter.status);
+      } else {
+        conditions.push("status = ?");
+        params.push(filter.status);
+      }
+    } else {
+      conditions.push("status = 'active'");
+    }
+    if (filter.project_id) {
+      conditions.push("project_id = ?");
+      params.push(filter.project_id);
+    }
+    if (filter.agent_id) {
+      conditions.push("agent_id = ?");
+      params.push(filter.agent_id);
+    }
+    if (filter.session_id) {
+      conditions.push("session_id = ?");
+      params.push(filter.session_id);
+    }
+    if (filter.min_importance) {
+      conditions.push("importance >= ?");
+      params.push(filter.min_importance);
+    }
+    if (filter.pinned !== undefined) {
+      conditions.push("pinned = ?");
+      params.push(filter.pinned ? 1 : 0);
+    }
+    if (filter.tags && filter.tags.length > 0) {
+      for (const tag of filter.tags) {
+        conditions.push("id IN (SELECT memory_id FROM memory_tags WHERE tag = ?)");
+        params.push(tag);
+      }
+    }
+    if (filter.search) {
+      conditions.push("(key LIKE ? OR value LIKE ? OR summary LIKE ?)");
+      const term = `%${filter.search}%`;
+      params.push(term, term, term);
+    }
+  } else {
+    conditions.push("status = 'active'");
+  }
+  let sql = "SELECT * FROM memories";
   if (conditions.length > 0) {
     sql += ` WHERE ${conditions.join(" AND ")}`;
   }
-  sql += " ORDER BY updated_at DESC";
-  if (filter.limit) {
+  sql += " ORDER BY importance DESC, created_at DESC";
+  if (filter?.limit) {
     sql += " LIMIT ?";
     params.push(filter.limit);
   }
-  if (filter.offset) {
+  if (filter?.offset) {
     sql += " OFFSET ?";
     params.push(filter.offset);
   }
   const rows = d.query(sql).all(...params);
-  return rows.map(parseEntityRow);
+  return rows.map(parseMemoryRow);
 }
-function updateEntity(id, input, db) {
+function updateMemory(id, input, db) {
   const d = db || getDatabase();
-  const existing = d.query("SELECT id FROM entities WHERE id = ?").get(id);
+  const existing = getMemory(id, d);
   if (!existing)
-    throw new EntityNotFoundError(id);
-  const sets = ["updated_at = ?"];
-  const params = [now()];
-  if (input.name !== undefined) {
-    sets.push("name = ?");
-    params.push(input.name);
-  }
-  if (input.type !== undefined) {
-    sets.push("type = ?");
-    params.push(input.type);
-  }
-  if (input.description !== undefined) {
-    sets.push("description = ?");
-    params.push(input.description);
+    throw new MemoryNotFoundError(id);
+  if (existing.version !== input.version) {
+    throw new VersionConflictError(id, input.version, existing.version);
   }
-  if (input.metadata !== undefined) {
+  try {
+    d.run(`INSERT OR IGNORE INTO memory_versions (id, memory_id, version, value, importance, scope, category, tags, summary, pinned, status, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      uuid(),
+      existing.id,
+      existing.version,
+      existing.value,
+      existing.importance,
+      existing.scope,
+      existing.category,
+      JSON.stringify(existing.tags),
+      existing.summary,
+      existing.pinned ? 1 : 0,
+      existing.status,
+      existing.updated_at
+    ]);
+  } catch {}
+  const sets = ["version = version + 1", "updated_at = ?"];
+  const params = [now()];
+  if (input.value !== undefined) {
+    sets.push("value = ?");
+    params.push(redactSecrets(input.value));
+  }
+  if (input.category !== undefined) {
+    sets.push("category = ?");
+    params.push(input.category);
+  }
+  if (input.scope !== undefined) {
+    sets.push("scope = ?");
+    params.push(input.scope);
+  }
+  if (input.summary !== undefined) {
+    sets.push("summary = ?");
+    params.push(input.summary);
+  }
+  if (input.importance !== undefined) {
+    sets.push("importance = ?");
+    params.push(input.importance);
+  }
+  if (input.pinned !== undefined) {
+    sets.push("pinned = ?");
+    params.push(input.pinned ? 1 : 0);
+  }
+  if (input.status !== undefined) {
+    sets.push("status = ?");
+    params.push(input.status);
+  }
+  if (input.metadata !== undefined) {
     sets.push("metadata = ?");
     params.push(JSON.stringify(input.metadata));
   }
+  if (input.expires_at !== undefined) {
+    sets.push("expires_at = ?");
+    params.push(input.expires_at);
+  }
+  if (input.tags !== undefined) {
+    sets.push("tags = ?");
+    params.push(JSON.stringify(input.tags));
+    d.run("DELETE FROM memory_tags WHERE memory_id = ?", [id]);
+    const insertTag = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
+    for (const tag of input.tags) {
+      insertTag.run(id, tag);
+    }
+  }
   params.push(id);
-  d.run(`UPDATE entities SET ${sets.join(", ")} WHERE id = ?`, params);
-  return getEntity(id, d);
-}
-function deleteEntity(id, db) {
-  const d = db || getDatabase();
-  const result = d.run("DELETE FROM entities WHERE id = ?", [id]);
-  if (result.changes === 0)
-    throw new EntityNotFoundError(id);
-}
-function mergeEntities(sourceId, targetId, db) {
-  const d = db || getDatabase();
-  getEntity(sourceId, d);
-  getEntity(targetId, d);
-  d.run(`UPDATE OR IGNORE relations SET source_entity_id = ? WHERE source_entity_id = ?`, [targetId, sourceId]);
-  d.run(`UPDATE OR IGNORE relations SET target_entity_id = ? WHERE target_entity_id = ?`, [targetId, sourceId]);
-  d.run("DELETE FROM relations WHERE source_entity_id = ? OR target_entity_id = ?", [
-    sourceId,
-    sourceId
-  ]);
-  d.run(`UPDATE OR IGNORE entity_memories SET entity_id = ? WHERE entity_id = ?`, [targetId, sourceId]);
-  d.run("DELETE FROM entity_memories WHERE entity_id = ?", [sourceId]);
-  d.run("DELETE FROM entities WHERE id = ?", [sourceId]);
-  d.run("UPDATE entities SET updated_at = ? WHERE id = ?", [now(), targetId]);
-  return getEntity(targetId, d);
-}
-
-// src/db/entity-memories.ts
-function parseEntityRow2(row) {
-  return {
-    id: row["id"],
-    name: row["name"],
-    type: row["type"],
-    description: row["description"] || null,
-    metadata: JSON.parse(row["metadata"] || "{}"),
-    project_id: row["project_id"] || null,
-    created_at: row["created_at"],
-    updated_at: row["updated_at"]
-  };
-}
-function parseEntityMemoryRow(row) {
-  return {
-    entity_id: row["entity_id"],
-    memory_id: row["memory_id"],
-    role: row["role"],
-    created_at: row["created_at"]
-  };
+  d.run(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`, params);
+  const updated = getMemory(id, d);
+  try {
+    if (input.value !== undefined) {
+      const oldLinks = getEntityMemoryLinks(undefined, updated.id, d);
+      for (const link of oldLinks) {
+        unlinkEntityFromMemory(link.entity_id, updated.id, d);
+      }
+      runEntityExtraction(updated, existing.project_id || undefined, d);
+    }
+  } catch {}
+  return updated;
 }
-function linkEntityToMemory(entityId, memoryId, role = "context", db) {
+function deleteMemory(id, db) {
   const d = db || getDatabase();
-  const timestamp = now();
-  d.run(`INSERT OR IGNORE INTO entity_memories (entity_id, memory_id, role, created_at)
-     VALUES (?, ?, ?, ?)`, [entityId, memoryId, role, timestamp]);
-  const row = d.query("SELECT * FROM entity_memories WHERE entity_id = ? AND memory_id = ?").get(entityId, memoryId);
-  return parseEntityMemoryRow(row);
+  const result = d.run("DELETE FROM memories WHERE id = ?", [id]);
+  return result.changes > 0;
 }
-function unlinkEntityFromMemory(entityId, memoryId, db) {
+function bulkDeleteMemories(ids, db) {
   const d = db || getDatabase();
-  d.run("DELETE FROM entity_memories WHERE entity_id = ? AND memory_id = ?", [entityId, memoryId]);
+  if (ids.length === 0)
+    return 0;
+  const placeholders = ids.map(() => "?").join(",");
+  const countRow = d.query(`SELECT COUNT(*) as c FROM memories WHERE id IN (${placeholders})`).get(...ids);
+  const count = countRow.c;
+  if (count > 0) {
+    d.run(`DELETE FROM memories WHERE id IN (${placeholders})`, ids);
+  }
+  return count;
 }
-function getMemoriesForEntity(entityId, db) {
+function touchMemory(id, db) {
   const d = db || getDatabase();
-  const rows = d.query(`SELECT m.* FROM memories m
-       INNER JOIN entity_memories em ON em.memory_id = m.id
-       WHERE em.entity_id = ?
-       ORDER BY m.importance DESC, m.created_at DESC`).all(entityId);
-  return rows.map(parseMemoryRow);
+  d.run("UPDATE memories SET access_count = access_count + 1, accessed_at = ? WHERE id = ?", [now(), id]);
 }
-function getEntitiesForMemory(memoryId, db) {
+var RECALL_PROMOTE_THRESHOLD = 3;
+function incrementRecallCount(id, db) {
   const d = db || getDatabase();
-  const rows = d.query(`SELECT e.* FROM entities e
-       INNER JOIN entity_memories em ON em.entity_id = e.id
-       WHERE em.memory_id = ?
-       ORDER BY e.name ASC`).all(memoryId);
-  return rows.map(parseEntityRow2);
+  try {
+    d.run("UPDATE memories SET recall_count = recall_count + 1, access_count = access_count + 1, accessed_at = ? WHERE id = ?", [now(), id]);
+    const row = d.query("SELECT recall_count, importance FROM memories WHERE id = ?").get(id);
+    if (!row)
+      return;
+    const promotions = Math.floor(row.recall_count / RECALL_PROMOTE_THRESHOLD);
+    if (promotions > 0 && row.importance < 10) {
+      const newImportance = Math.min(10, row.importance + 1);
+      d.run("UPDATE memories SET importance = ? WHERE id = ? AND importance < 10", [newImportance, id]);
+    }
+  } catch {}
 }
-function bulkLinkEntities(entityIds, memoryId, role = "context", db) {
+function cleanExpiredMemories(db) {
   const d = db || getDatabase();
   const timestamp = now();
-  const tx = d.transaction(() => {
-    const stmt = d.prepare(`INSERT OR IGNORE INTO entity_memories (entity_id, memory_id, role, created_at)
-       VALUES (?, ?, ?, ?)`);
-    for (const entityId of entityIds) {
-      stmt.run(entityId, memoryId, role, timestamp);
-    }
-  });
-  tx();
+  const countRow = d.query("SELECT COUNT(*) as c FROM memories WHERE expires_at IS NOT NULL AND expires_at < ?").get(timestamp);
+  const count = countRow.c;
+  if (count > 0) {
+    d.run("DELETE FROM memories WHERE expires_at IS NOT NULL AND expires_at < ?", [timestamp]);
+  }
+  return count;
 }
-function getEntityMemoryLinks(entityId, memoryId, db) {
+function getMemoryVersions(memoryId, db) {
   const d = db || getDatabase();
-  const conditions = [];
-  const params = [];
-  if (entityId) {
-    conditions.push("entity_id = ?");
-    params.push(entityId);
-  }
-  if (memoryId) {
-    conditions.push("memory_id = ?");
-    params.push(memoryId);
-  }
-  let sql = "SELECT * FROM entity_memories";
-  if (conditions.length > 0) {
-    sql += ` WHERE ${conditions.join(" AND ")}`;
+  try {
+    const rows = d.query("SELECT * FROM memory_versions WHERE memory_id = ? ORDER BY version ASC").all(memoryId);
+    return rows.map((row) => ({
+      id: row["id"],
+      memory_id: row["memory_id"],
+      version: row["version"],
+      value: row["value"],
+      importance: row["importance"],
+      scope: row["scope"],
+      category: row["category"],
+      tags: JSON.parse(row["tags"] || "[]"),
+      summary: row["summary"] || null,
+      pinned: !!row["pinned"],
+      status: row["status"],
+      created_at: row["created_at"]
+    }));
+  } catch {
+    return [];
   }
-  sql += " ORDER BY created_at DESC";
-  const rows = d.query(sql).all(...params);
-  return rows.map(parseEntityMemoryRow);
-}
-
-// src/db/relations.ts
-function parseRelationRow(row) {
-  return {
-    id: row["id"],
-    source_entity_id: row["source_entity_id"],
-    target_entity_id: row["target_entity_id"],
-    relation_type: row["relation_type"],
-    weight: row["weight"],
-    metadata: JSON.parse(row["metadata"] || "{}"),
-    created_at: row["created_at"]
-  };
 }
-function parseEntityRow3(row) {
+// src/db/agents.ts
+var CONFLICT_WINDOW_MS = 30 * 60 * 1000;
+function parseAgentRow(row) {
   return {
     id: row["id"],
     name: row["name"],
-    type: row["type"],
+    session_id: row["session_id"] || null,
     description: row["description"] || null,
+    role: row["role"] || null,
     metadata: JSON.parse(row["metadata"] || "{}"),
-    project_id: row["project_id"] || null,
+    active_project_id: row["active_project_id"] || null,
     created_at: row["created_at"],
-    updated_at: row["updated_at"]
+    last_seen_at: row["last_seen_at"]
   };
 }
-function createRelation(input, db) {
+function registerAgent(name, sessionId, description, role, projectId, db) {
   const d = db || getDatabase();
-  const id = shortUuid();
   const timestamp = now();
-  const weight = input.weight ?? 1;
-  const metadata = JSON.stringify(input.metadata ?? {});
-  d.run(`INSERT INTO relations (id, source_entity_id, target_entity_id, relation_type, weight, metadata, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?)
-     ON CONFLICT(source_entity_id, target_entity_id, relation_type)
-     DO UPDATE SET weight = excluded.weight, metadata = excluded.metadata`, [id, input.source_entity_id, input.target_entity_id, input.relation_type, weight, metadata, timestamp]);
-  const row = d.query(`SELECT * FROM relations
-       WHERE source_entity_id = ? AND target_entity_id = ? AND relation_type = ?`).get(input.source_entity_id, input.target_entity_id, input.relation_type);
-  return parseRelationRow(row);
-}
-function getRelation(id, db) {
-  const d = db || getDatabase();
-  const row = d.query("SELECT * FROM relations WHERE id = ?").get(id);
-  if (!row)
-    throw new Error(`Relation not found: ${id}`);
-  return parseRelationRow(row);
-}
-function listRelations(filter, db) {
-  const d = db || getDatabase();
-  const conditions = [];
-  const params = [];
-  if (filter.entity_id) {
-    const dir = filter.direction || "both";
-    if (dir === "outgoing") {
-      conditions.push("source_entity_id = ?");
-      params.push(filter.entity_id);
-    } else if (dir === "incoming") {
-      conditions.push("target_entity_id = ?");
-      params.push(filter.entity_id);
-    } else {
-      conditions.push("(source_entity_id = ? OR target_entity_id = ?)");
-      params.push(filter.entity_id, filter.entity_id);
+  const normalizedName = name.trim().toLowerCase();
+  const existing = d.query("SELECT * FROM agents WHERE LOWER(name) = ?").get(normalizedName);
+  if (existing) {
+    const existingId = existing["id"];
+    const existingSessionId = existing["session_id"] || null;
+    const existingLastSeen = existing["last_seen_at"];
+    if (sessionId && existingSessionId && existingSessionId !== sessionId) {
+      const lastSeenMs = new Date(existingLastSeen).getTime();
+      const nowMs = Date.now();
+      if (nowMs - lastSeenMs < CONFLICT_WINDOW_MS) {
+        throw new AgentConflictError({
+          existing_id: existingId,
+          existing_name: normalizedName,
+          last_seen_at: existingLastSeen,
+          session_hint: existingSessionId.slice(0, 8),
+          working_dir: null
+        });
+      }
     }
+    d.run("UPDATE agents SET last_seen_at = ?, session_id = ? WHERE id = ?", [
+      timestamp,
+      sessionId ?? existingSessionId,
+      existingId
+    ]);
+    if (description) {
+      d.run("UPDATE agents SET description = ? WHERE id = ?", [description, existingId]);
+    }
+    if (role) {
+      d.run("UPDATE agents SET role = ? WHERE id = ?", [role, existingId]);
+    }
+    if (projectId !== undefined) {
+      d.run("UPDATE agents SET active_project_id = ? WHERE id = ?", [projectId, existingId]);
+    }
+    return getAgent(existingId, d);
   }
-  if (filter.relation_type) {
-    conditions.push("relation_type = ?");
-    params.push(filter.relation_type);
-  }
-  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  const rows = d.query(`SELECT * FROM relations ${where} ORDER BY created_at DESC`).all(...params);
-  return rows.map(parseRelationRow);
+  const id = shortUuid();
+  d.run("INSERT INTO agents (id, name, session_id, description, role, active_project_id, created_at, last_seen_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [id, normalizedName, sessionId ?? null, description || null, role || "agent", projectId ?? null, timestamp, timestamp]);
+  return getAgent(id, d);
 }
-function deleteRelation(id, db) {
+function getAgent(idOrName, db) {
   const d = db || getDatabase();
-  const result = d.run("DELETE FROM relations WHERE id = ?", [id]);
-  if (result.changes === 0)
-    throw new Error(`Relation not found: ${id}`);
+  let row = d.query("SELECT * FROM agents WHERE id = ?").get(idOrName);
+  if (row)
+    return parseAgentRow(row);
+  row = d.query("SELECT * FROM agents WHERE LOWER(name) = ?").get(idOrName.trim().toLowerCase());
+  if (row)
+    return parseAgentRow(row);
+  const rows = d.query("SELECT * FROM agents WHERE id LIKE ?").all(`${idOrName}%`);
+  if (rows.length === 1)
+    return parseAgentRow(rows[0]);
+  return null;
 }
-function getRelatedEntities(entityId, relationType, db) {
+function listAgents(db) {
   const d = db || getDatabase();
-  let sql;
-  const params = [];
-  if (relationType) {
-    sql = `
-      SELECT DISTINCT e.* FROM entities e
-      JOIN relations r ON (
-        (r.source_entity_id = ? AND r.target_entity_id = e.id)
-        OR (r.target_entity_id = ? AND r.source_entity_id = e.id)
-      )
-      WHERE r.relation_type = ?
-    `;
-    params.push(entityId, entityId, relationType);
-  } else {
-    sql = `
-      SELECT DISTINCT e.* FROM entities e
-      JOIN relations r ON (
-        (r.source_entity_id = ? AND r.target_entity_id = e.id)
-        OR (r.target_entity_id = ? AND r.source_entity_id = e.id)
-      )
-    `;
-    params.push(entityId, entityId);
-  }
-  const rows = d.query(sql).all(...params);
-  return rows.map(parseEntityRow3);
+  const rows = d.query("SELECT * FROM agents ORDER BY last_seen_at DESC").all();
+  return rows.map(parseAgentRow);
 }
-function getEntityGraph(entityId, depth = 2, db) {
+function touchAgent(idOrName, db) {
   const d = db || getDatabase();
-  const entityRows = d.query(`WITH RECURSIVE graph(id, depth) AS (
-        VALUES(?, 0)
-        UNION
-        SELECT CASE WHEN r.source_entity_id = g.id THEN r.target_entity_id ELSE r.source_entity_id END, g.depth + 1
-        FROM relations r JOIN graph g ON (r.source_entity_id = g.id OR r.target_entity_id = g.id)
-        WHERE g.depth < ?
-      )
-      SELECT DISTINCT e.* FROM entities e JOIN graph g ON e.id = g.id`).all(entityId, depth);
-  const entities = entityRows.map(parseEntityRow3);
-  const entityIds = new Set(entities.map((e) => e.id));
-  if (entityIds.size === 0) {
-    return { entities: [], relations: [] };
-  }
-  const placeholders = Array.from(entityIds).map(() => "?").join(",");
-  const relationRows = d.query(`SELECT * FROM relations
-       WHERE source_entity_id IN (${placeholders})
-         AND target_entity_id IN (${placeholders})`).all(...Array.from(entityIds), ...Array.from(entityIds));
-  const relations = relationRows.map(parseRelationRow);
-  return { entities, relations };
+  const agent = getAgent(idOrName, d);
+  if (!agent)
+    return;
+  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), agent.id]);
 }
-function findPath(fromEntityId, toEntityId, maxDepth = 5, db) {
+function listAgentsByProject(projectId, db) {
   const d = db || getDatabase();
-  const rows = d.query(`WITH RECURSIVE path(id, trail, depth) AS (
-        SELECT ?, ?, 0
-        UNION
-        SELECT
-          CASE WHEN r.source_entity_id = p.id THEN r.target_entity_id ELSE r.source_entity_id END,
-          p.trail || ',' || CASE WHEN r.source_entity_id = p.id THEN r.target_entity_id ELSE r.source_entity_id END,
-          p.depth + 1
-        FROM relations r JOIN path p ON (r.source_entity_id = p.id OR r.target_entity_id = p.id)
-        WHERE p.depth < ?
-          AND INSTR(p.trail, CASE WHEN r.source_entity_id = p.id THEN r.target_entity_id ELSE r.source_entity_id END) = 0
-      )
-      SELECT trail FROM path WHERE id = ? ORDER BY depth ASC LIMIT 1`).get(fromEntityId, fromEntityId, maxDepth, toEntityId);
-  if (!rows)
-    return null;
-  const ids = rows.trail.split(",");
-  const entities = [];
-  for (const id of ids) {
-    const row = d.query("SELECT * FROM entities WHERE id = ?").get(id);
-    if (row)
-      entities.push(parseEntityRow3(row));
-  }
-  return entities.length > 0 ? entities : null;
+  const rows = d.query("SELECT * FROM agents WHERE active_project_id = ? ORDER BY last_seen_at DESC").all(projectId);
+  return rows.map(parseAgentRow);
 }
-
-// src/lib/config.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, readdirSync, writeFileSync, unlinkSync } from "fs";
-import { homedir } from "os";
-import { basename, dirname as dirname2, join as join2, resolve as resolve2 } from "path";
-var DEFAULT_CONFIG = {
-  default_scope: "private",
-  default_category: "knowledge",
-  default_importance: 5,
-  max_entries: 1000,
-  max_entries_per_scope: {
-    global: 500,
-    shared: 300,
-    private: 200
-  },
-  injection: {
-    max_tokens: 500,
-    min_importance: 5,
-    categories: ["preference", "fact"],
-    refresh_interval: 5
-  },
-  extraction: {
-    enabled: true,
-    min_confidence: 0.5
-  },
-  sync_agents: ["claude", "codex", "gemini"],
-  auto_cleanup: {
-    enabled: true,
-    expired_check_interval: 3600,
-    unused_archive_days: 7,
-    stale_deprioritize_days: 14
-  }
-};
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    const sourceVal = source[key];
-    const targetVal = result[key];
-    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
-      result[key] = deepMerge(targetVal, sourceVal);
-    } else {
-      result[key] = sourceVal;
+function updateAgent(id, updates, db) {
+  const d = db || getDatabase();
+  const agent = getAgent(id, d);
+  if (!agent)
+    return null;
+  const timestamp = now();
+  if (updates.name) {
+    const normalizedNewName = updates.name.trim().toLowerCase();
+    if (normalizedNewName !== agent.name) {
+      const existing = d.query("SELECT id FROM agents WHERE LOWER(name) = ? AND id != ?").get(normalizedNewName, agent.id);
+      if (existing) {
+        throw new Error(`Agent name already taken: ${normalizedNewName}`);
+      }
+      d.run("UPDATE agents SET name = ? WHERE id = ?", [normalizedNewName, agent.id]);
     }
   }
-  return result;
-}
-var VALID_SCOPES = ["global", "shared", "private"];
-var VALID_CATEGORIES = [
-  "preference",
-  "fact",
-  "knowledge",
-  "history"
-];
-function isValidScope(value) {
-  return VALID_SCOPES.includes(value);
-}
-function isValidCategory(value) {
-  return VALID_CATEGORIES.includes(value);
-}
-function loadConfig() {
-  const configPath = join2(homedir(), ".mementos", "config.json");
-  let fileConfig = {};
-  if (existsSync2(configPath)) {
-    try {
-      const raw = readFileSync(configPath, "utf-8");
-      fileConfig = JSON.parse(raw);
-    } catch {}
+  if (updates.description !== undefined) {
+    d.run("UPDATE agents SET description = ? WHERE id = ?", [updates.description, agent.id]);
   }
-  const merged = deepMerge(DEFAULT_CONFIG, fileConfig);
-  const envScope = process.env["MEMENTOS_DEFAULT_SCOPE"];
-  if (envScope && isValidScope(envScope)) {
-    merged.default_scope = envScope;
+  if (updates.role !== undefined) {
+    d.run("UPDATE agents SET role = ? WHERE id = ?", [updates.role, agent.id]);
   }
-  const envCategory = process.env["MEMENTOS_DEFAULT_CATEGORY"];
-  if (envCategory && isValidCategory(envCategory)) {
-    merged.default_category = envCategory;
+  if (updates.metadata !== undefined) {
+    d.run("UPDATE agents SET metadata = ? WHERE id = ?", [JSON.stringify(updates.metadata), agent.id]);
   }
-  const envImportance = process.env["MEMENTOS_DEFAULT_IMPORTANCE"];
-  if (envImportance) {
-    const parsed = parseInt(envImportance, 10);
-    if (!Number.isNaN(parsed) && parsed >= 1 && parsed <= 10) {
-      merged.default_importance = parsed;
-    }
+  if ("active_project_id" in updates) {
+    d.run("UPDATE agents SET active_project_id = ? WHERE id = ?", [updates.active_project_id ?? null, agent.id]);
   }
-  return merged;
-}
-function profilesDir() {
-  return join2(homedir(), ".mementos", "profiles");
+  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [timestamp, agent.id]);
+  return getAgent(agent.id, d);
 }
-function globalConfigPath() {
-  return join2(homedir(), ".mementos", "config.json");
+// src/db/locks.ts
+function parseLockRow(row) {
+  return {
+    id: row["id"],
+    resource_type: row["resource_type"],
+    resource_id: row["resource_id"],
+    agent_id: row["agent_id"],
+    lock_type: row["lock_type"],
+    locked_at: row["locked_at"],
+    expires_at: row["expires_at"]
+  };
 }
-function readGlobalConfig() {
-  const p = globalConfigPath();
-  if (!existsSync2(p))
-    return {};
-  try {
-    return JSON.parse(readFileSync(p, "utf-8"));
-  } catch {
-    return {};
+function acquireLock(agentId, resourceType, resourceId, lockType = "exclusive", ttlSeconds = 300, db) {
+  const d = db || getDatabase();
+  cleanExpiredLocks(d);
+  const ownLock = d.query("SELECT * FROM resource_locks WHERE resource_type = ? AND resource_id = ? AND agent_id = ? AND lock_type = ? AND expires_at > datetime('now')").get(resourceType, resourceId, agentId, lockType);
+  if (ownLock) {
+    const newExpiry = new Date(Date.now() + ttlSeconds * 1000).toISOString();
+    d.run("UPDATE resource_locks SET expires_at = ? WHERE id = ?", [
+      newExpiry,
+      ownLock["id"]
+    ]);
+    return parseLockRow({ ...ownLock, expires_at: newExpiry });
   }
+  if (lockType === "exclusive") {
+    const existing = d.query("SELECT * FROM resource_locks WHERE resource_type = ? AND resource_id = ? AND lock_type = 'exclusive' AND agent_id != ? AND expires_at > datetime('now')").get(resourceType, resourceId, agentId);
+    if (existing) {
+      return null;
+    }
+  }
+  const id = shortUuid();
+  const lockedAt = now();
+  const expiresAt = new Date(Date.now() + ttlSeconds * 1000).toISOString();
+  d.run("INSERT INTO resource_locks (id, resource_type, resource_id, agent_id, lock_type, locked_at, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?)", [id, resourceType, resourceId, agentId, lockType, lockedAt, expiresAt]);
+  return {
+    id,
+    resource_type: resourceType,
+    resource_id: resourceId,
+    agent_id: agentId,
+    lock_type: lockType,
+    locked_at: lockedAt,
+    expires_at: expiresAt
+  };
 }
-function writeGlobalConfig(data) {
-  const p = globalConfigPath();
-  ensureDir2(dirname2(p));
-  writeFileSync(p, JSON.stringify(data, null, 2), "utf-8");
+function releaseLock(lockId, agentId, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM resource_locks WHERE id = ? AND agent_id = ?", [lockId, agentId]);
+  return result.changes > 0;
 }
-function getActiveProfile() {
-  const envProfile = process.env["MEMENTOS_PROFILE"];
-  if (envProfile)
-    return envProfile.trim();
-  const cfg = readGlobalConfig();
-  return cfg["active_profile"] || null;
+function releaseResourceLocks(agentId, resourceType, resourceId, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM resource_locks WHERE agent_id = ? AND resource_type = ? AND resource_id = ?", [agentId, resourceType, resourceId]);
+  return result.changes;
 }
-function setActiveProfile(name) {
-  const cfg = readGlobalConfig();
-  if (name === null) {
-    delete cfg["active_profile"];
-  } else {
-    cfg["active_profile"] = name;
-  }
-  writeGlobalConfig(cfg);
+function releaseAllAgentLocks(agentId, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM resource_locks WHERE agent_id = ?", [agentId]);
+  return result.changes;
 }
-function listProfiles() {
-  const dir = profilesDir();
-  if (!existsSync2(dir))
-    return [];
-  return readdirSync(dir).filter((f) => f.endsWith(".db")).map((f) => basename(f, ".db")).sort();
+function checkLock(resourceType, resourceId, lockType, db) {
+  const d = db || getDatabase();
+  cleanExpiredLocks(d);
+  const query = lockType ? "SELECT * FROM resource_locks WHERE resource_type = ? AND resource_id = ? AND lock_type = ? AND expires_at > datetime('now')" : "SELECT * FROM resource_locks WHERE resource_type = ? AND resource_id = ? AND expires_at > datetime('now')";
+  const rows = lockType ? d.query(query).all(resourceType, resourceId, lockType) : d.query(query).all(resourceType, resourceId);
+  return rows.map(parseLockRow);
 }
-function deleteProfile(name) {
-  const dbPath = join2(profilesDir(), `${name}.db`);
-  if (!existsSync2(dbPath))
-    return false;
-  unlinkSync(dbPath);
-  if (getActiveProfile() === name)
-    setActiveProfile(null);
-  return true;
+function agentHoldsLock(agentId, resourceType, resourceId, lockType, db) {
+  const d = db || getDatabase();
+  const query = lockType ? "SELECT * FROM resource_locks WHERE agent_id = ? AND resource_type = ? AND resource_id = ? AND lock_type = ? AND expires_at > datetime('now')" : "SELECT * FROM resource_locks WHERE agent_id = ? AND resource_type = ? AND resource_id = ? AND expires_at > datetime('now')";
+  const row = lockType ? d.query(query).get(agentId, resourceType, resourceId, lockType) : d.query(query).get(agentId, resourceType, resourceId);
+  return row ? parseLockRow(row) : null;
 }
-function ensureDir2(dir) {
-  if (!existsSync2(dir)) {
-    mkdirSync2(dir, { recursive: true });
+function listAgentLocks(agentId, db) {
+  const d = db || getDatabase();
+  cleanExpiredLocks(d);
+  const rows = d.query("SELECT * FROM resource_locks WHERE agent_id = ? AND expires_at > datetime('now') ORDER BY locked_at DESC").all(agentId);
+  return rows.map(parseLockRow);
+}
+function cleanExpiredLocks(db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM resource_locks WHERE expires_at <= datetime('now')");
+  return result.changes;
+}
+// src/lib/memory-lock.ts
+var MEMORY_WRITE_TTL = 30;
+function memoryLockId(key, scope, projectId) {
+  return `${scope}:${key}:${projectId ?? ""}`;
+}
+function acquireMemoryWriteLock(agentId, key, scope, projectId, ttlSeconds = MEMORY_WRITE_TTL, db) {
+  const d = db || getDatabase();
+  return acquireLock(agentId, "memory", memoryLockId(key, scope, projectId), "exclusive", ttlSeconds, d);
+}
+function releaseMemoryWriteLock(lockId, agentId, db) {
+  const d = db || getDatabase();
+  return releaseLock(lockId, agentId, d);
+}
+function checkMemoryWriteLock(key, scope, projectId, db) {
+  const d = db || getDatabase();
+  const locks = checkLock("memory", memoryLockId(key, scope, projectId), "exclusive", d);
+  return locks[0] ?? null;
+}
+function withMemoryLock(agentId, key, scope, projectId, fn, ttlSeconds = MEMORY_WRITE_TTL, db) {
+  const d = db || getDatabase();
+  const lock = acquireMemoryWriteLock(agentId, key, scope, projectId, ttlSeconds, d);
+  if (!lock) {
+    const existing = checkMemoryWriteLock(key, scope, projectId, d);
+    throw new MemoryLockConflictError(key, scope, existing?.agent_id ?? "unknown");
+  }
+  try {
+    return fn();
+  } finally {
+    releaseLock(lock.id, agentId, d);
   }
 }
 
-// src/db/memories.ts
-function runEntityExtraction(memory, projectId, d) {
-  const config = loadConfig();
-  if (config.extraction?.enabled === false)
-    return;
-  const extracted = extractEntities(memory, d);
-  const minConfidence = config.extraction?.min_confidence ?? 0.5;
-  const entityIds = [];
-  for (const ext of extracted) {
-    if (ext.confidence >= minConfidence) {
-      const entity = createEntity({ name: ext.name, type: ext.type, project_id: projectId }, d);
-      linkEntityToMemory(entity.id, memory.id, "context", d);
-      entityIds.push(entity.id);
-    }
-  }
-  for (let i = 0;i < entityIds.length; i++) {
-    for (let j = i + 1;j < entityIds.length; j++) {
-      try {
-        createRelation({ source_entity_id: entityIds[i], target_entity_id: entityIds[j], relation_type: "related_to" }, d);
-      } catch {}
-    }
+class MemoryLockConflictError extends Error {
+  conflict = true;
+  key;
+  scope;
+  blocking_agent_id;
+  constructor(key, scope, blockingAgentId) {
+    super(`Memory key "${key}" (scope: ${scope}) is currently write-locked by agent ${blockingAgentId}. ` + "Retry after a few seconds or use optimistic locking (version field).");
+    this.name = "MemoryLockConflictError";
+    this.key = key;
+    this.scope = scope;
+    this.blocking_agent_id = blockingAgentId;
   }
 }
-function parseMemoryRow(row) {
+// src/lib/focus.ts
+var sessionFocus = new Map;
+function setFocus(agentId, projectId) {
+  sessionFocus.set(agentId, projectId);
+  updateAgent(agentId, { active_project_id: projectId });
+}
+function getFocus(agentId) {
+  if (sessionFocus.has(agentId)) {
+    return sessionFocus.get(agentId) ?? null;
+  }
+  const agent = getAgent(agentId);
+  const projectId = agent?.active_project_id ?? null;
+  sessionFocus.set(agentId, projectId);
+  return projectId;
+}
+function unfocus(agentId) {
+  setFocus(agentId, null);
+}
+function resolveProjectId(agentId, explicitProjectId) {
+  if (explicitProjectId !== undefined && explicitProjectId !== null) {
+    return explicitProjectId;
+  }
+  if (agentId) {
+    return getFocus(agentId);
+  }
+  return null;
+}
+function buildFocusFilter(agentId, explicitProjectId, explicitScope) {
+  if (explicitScope || explicitProjectId)
+    return null;
+  if (!agentId)
+    return null;
+  const focusedProjectId = getFocus(agentId);
+  if (!focusedProjectId)
+    return null;
+  return {
+    focusMode: true,
+    agentId,
+    projectId: focusedProjectId
+  };
+}
+function focusFilterSQL(agentId, projectId) {
+  return {
+    sql: "(scope = 'global' OR (scope = 'private' AND agent_id = ?) OR (scope = 'shared' AND project_id = ?))",
+    params: [agentId, projectId]
+  };
+}
+// src/db/projects.ts
+function parseProjectRow(row) {
   return {
     id: row["id"],
-    key: row["key"],
-    value: row["value"],
-    category: row["category"],
-    scope: row["scope"],
-    summary: row["summary"] || null,
-    tags: JSON.parse(row["tags"] || "[]"),
-    importance: row["importance"],
-    source: row["source"],
-    status: row["status"],
-    pinned: !!row["pinned"],
-    agent_id: row["agent_id"] || null,
-    project_id: row["project_id"] || null,
-    session_id: row["session_id"] || null,
-    metadata: JSON.parse(row["metadata"] || "{}"),
-    access_count: row["access_count"],
-    version: row["version"],
-    expires_at: row["expires_at"] || null,
+    name: row["name"],
+    path: row["path"],
+    description: row["description"] || null,
+    memory_prefix: row["memory_prefix"] || null,
     created_at: row["created_at"],
-    updated_at: row["updated_at"],
-    accessed_at: row["accessed_at"] || null
+    updated_at: row["updated_at"]
   };
 }
-function createMemory(input, dedupeMode = "merge", db) {
+function registerProject(name, path, description, memoryPrefix, db) {
   const d = db || getDatabase();
   const timestamp = now();
-  let expiresAt = input.expires_at || null;
-  if (input.ttl_ms && !expiresAt) {
-    expiresAt = new Date(Date.now() + input.ttl_ms).toISOString();
+  const existing = d.query("SELECT * FROM projects WHERE path = ?").get(path);
+  if (existing) {
+    const existingId = existing["id"];
+    d.run("UPDATE projects SET updated_at = ? WHERE id = ?", [
+      timestamp,
+      existingId
+    ]);
+    return parseProjectRow(existing);
   }
   const id = uuid();
-  const tags = input.tags || [];
-  const tagsJson = JSON.stringify(tags);
-  const metadataJson = JSON.stringify(input.metadata || {});
-  const safeValue = redactSecrets(input.value);
-  const safeSummary = input.summary ? redactSecrets(input.summary) : null;
-  if (dedupeMode === "merge") {
-    const existing = d.query(`SELECT id, version FROM memories
-         WHERE key = ? AND scope = ?
-           AND COALESCE(agent_id, '') = ?
-           AND COALESCE(project_id, '') = ?
-           AND COALESCE(session_id, '') = ?`).get(input.key, input.scope || "private", input.agent_id || "", input.project_id || "", input.session_id || "");
-    if (existing) {
-      d.run(`UPDATE memories SET
-           value = ?, category = ?, summary = ?, tags = ?,
-           importance = ?, metadata = ?, expires_at = ?,
-           pinned = COALESCE(pinned, 0),
-           version = version + 1, updated_at = ?
-         WHERE id = ?`, [
-        safeValue,
-        input.category || "knowledge",
-        safeSummary,
-        tagsJson,
-        input.importance ?? 5,
-        metadataJson,
-        expiresAt,
-        timestamp,
-        existing.id
-      ]);
-      d.run("DELETE FROM memory_tags WHERE memory_id = ?", [existing.id]);
-      const insertTag2 = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
-      for (const tag of tags) {
-        insertTag2.run(existing.id, tag);
-      }
-      const merged = getMemory(existing.id, d);
-      try {
-        const oldLinks = getEntityMemoryLinks(undefined, merged.id, d);
-        for (const link of oldLinks) {
-          unlinkEntityFromMemory(link.entity_id, merged.id, d);
-        }
-        runEntityExtraction(merged, input.project_id, d);
-      } catch {}
-      return merged;
+  d.run("INSERT INTO projects (id, name, path, description, memory_prefix, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)", [id, name, path, description || null, memoryPrefix || null, timestamp, timestamp]);
+  return getProject(id, d);
+}
+function getProject(idOrPath, db) {
+  const d = db || getDatabase();
+  let row = d.query("SELECT * FROM projects WHERE id = ?").get(idOrPath);
+  if (row)
+    return parseProjectRow(row);
+  row = d.query("SELECT * FROM projects WHERE path = ?").get(idOrPath);
+  if (row)
+    return parseProjectRow(row);
+  row = d.query("SELECT * FROM projects WHERE LOWER(name) = ?").get(idOrPath.toLowerCase());
+  if (row)
+    return parseProjectRow(row);
+  return null;
+}
+function listProjects(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
+  return rows.map(parseProjectRow);
+}
+// src/db/entities.ts
+function parseEntityRow2(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    type: row["type"],
+    description: row["description"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    project_id: row["project_id"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"]
+  };
+}
+function createEntity(input, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  const metadataJson = JSON.stringify(input.metadata || {});
+  const existing = d.query(`SELECT * FROM entities
+       WHERE name = ? AND type = ? AND COALESCE(project_id, '') = ?`).get(input.name, input.type, input.project_id || "");
+  if (existing) {
+    const sets = ["updated_at = ?"];
+    const params = [timestamp];
+    if (input.description !== undefined) {
+      sets.push("description = ?");
+      params.push(input.description);
+    }
+    if (input.metadata !== undefined) {
+      sets.push("metadata = ?");
+      params.push(metadataJson);
     }
+    const existingId = existing["id"];
+    params.push(existingId);
+    d.run(`UPDATE entities SET ${sets.join(", ")} WHERE id = ?`, params);
+    return getEntity(existingId, d);
   }
-  d.run(`INSERT INTO memories (id, key, value, category, scope, summary, tags, importance, source, status, pinned, agent_id, project_id, session_id, metadata, access_count, version, expires_at, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', 0, ?, ?, ?, ?, 0, 1, ?, ?, ?)`, [
+  const id = shortUuid();
+  d.run(`INSERT INTO entities (id, name, type, description, metadata, project_id, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
     id,
-    input.key,
-    input.value,
-    input.category || "knowledge",
-    input.scope || "private",
-    input.summary || null,
-    tagsJson,
-    input.importance ?? 5,
-    input.source || "agent",
-    input.agent_id || null,
-    input.project_id || null,
-    input.session_id || null,
+    input.name,
+    input.type,
+    input.description || null,
     metadataJson,
-    expiresAt,
+    input.project_id || null,
     timestamp,
     timestamp
   ]);
-  const insertTag = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
-  for (const tag of tags) {
-    insertTag.run(id, tag);
-  }
-  const memory = getMemory(id, d);
-  try {
-    runEntityExtraction(memory, input.project_id, d);
-  } catch {}
-  return memory;
+  return getEntity(id, d);
 }
-function getMemory(id, db) {
+function getEntity(id, db) {
   const d = db || getDatabase();
-  const row = d.query("SELECT * FROM memories WHERE id = ?").get(id);
+  const row = d.query("SELECT * FROM entities WHERE id = ?").get(id);
   if (!row)
-    return null;
-  return parseMemoryRow(row);
+    throw new EntityNotFoundError(id);
+  return parseEntityRow2(row);
 }
-function getMemoryByKey(key, scope, agentId, projectId, sessionId, db) {
+function getEntityByName(name, type, projectId, db) {
   const d = db || getDatabase();
-  let sql = "SELECT * FROM memories WHERE key = ?";
-  const params = [key];
-  if (scope) {
-    sql += " AND scope = ?";
-    params.push(scope);
-  }
-  if (agentId) {
-    sql += " AND agent_id = ?";
-    params.push(agentId);
+  let sql = "SELECT * FROM entities WHERE name = ?";
+  const params = [name];
+  if (type) {
+    sql += " AND type = ?";
+    params.push(type);
   }
-  if (projectId) {
+  if (projectId !== undefined) {
     sql += " AND project_id = ?";
     params.push(projectId);
   }
-  if (sessionId) {
-    sql += " AND session_id = ?";
-    params.push(sessionId);
-  }
-  sql += " AND status = 'active' ORDER BY importance DESC LIMIT 1";
+  sql += " LIMIT 1";
   const row = d.query(sql).get(...params);
   if (!row)
     return null;
-  return parseMemoryRow(row);
-}
-function getMemoriesByKey(key, scope, agentId, projectId, db) {
-  const d = db || getDatabase();
-  let sql = "SELECT * FROM memories WHERE key = ?";
-  const params = [key];
-  if (scope) {
-    sql += " AND scope = ?";
-    params.push(scope);
-  }
-  if (agentId) {
-    sql += " AND agent_id = ?";
-    params.push(agentId);
-  }
-  if (projectId) {
-    sql += " AND project_id = ?";
-    params.push(projectId);
-  }
-  sql += " AND status = 'active' ORDER BY importance DESC";
-  const rows = d.query(sql).all(...params);
-  return rows.map(parseMemoryRow);
+  return parseEntityRow2(row);
 }
-function listMemories(filter, db) {
+function listEntities(filter = {}, db) {
   const d = db || getDatabase();
   const conditions = [];
   const params = [];
-  if (filter) {
-    if (filter.scope) {
-      if (Array.isArray(filter.scope)) {
-        conditions.push(`scope IN (${filter.scope.map(() => "?").join(",")})`);
-        params.push(...filter.scope);
-      } else {
-        conditions.push("scope = ?");
-        params.push(filter.scope);
-      }
-    }
-    if (filter.category) {
-      if (Array.isArray(filter.category)) {
-        conditions.push(`category IN (${filter.category.map(() => "?").join(",")})`);
-        params.push(...filter.category);
-      } else {
-        conditions.push("category = ?");
-        params.push(filter.category);
-      }
-    }
-    if (filter.source) {
-      if (Array.isArray(filter.source)) {
-        conditions.push(`source IN (${filter.source.map(() => "?").join(",")})`);
-        params.push(...filter.source);
-      } else {
-        conditions.push("source = ?");
-        params.push(filter.source);
-      }
-    }
-    if (filter.status) {
-      if (Array.isArray(filter.status)) {
-        conditions.push(`status IN (${filter.status.map(() => "?").join(",")})`);
-        params.push(...filter.status);
-      } else {
-        conditions.push("status = ?");
-        params.push(filter.status);
-      }
-    } else {
-      conditions.push("status = 'active'");
-    }
-    if (filter.project_id) {
-      conditions.push("project_id = ?");
-      params.push(filter.project_id);
-    }
-    if (filter.agent_id) {
-      conditions.push("agent_id = ?");
-      params.push(filter.agent_id);
-    }
-    if (filter.session_id) {
-      conditions.push("session_id = ?");
-      params.push(filter.session_id);
-    }
-    if (filter.min_importance) {
-      conditions.push("importance >= ?");
-      params.push(filter.min_importance);
-    }
-    if (filter.pinned !== undefined) {
-      conditions.push("pinned = ?");
-      params.push(filter.pinned ? 1 : 0);
-    }
-    if (filter.tags && filter.tags.length > 0) {
-      for (const tag of filter.tags) {
-        conditions.push("id IN (SELECT memory_id FROM memory_tags WHERE tag = ?)");
-        params.push(tag);
-      }
-    }
-    if (filter.search) {
-      conditions.push("(key LIKE ? OR value LIKE ? OR summary LIKE ?)");
-      const term = `%${filter.search}%`;
-      params.push(term, term, term);
-    }
-  } else {
-    conditions.push("status = 'active'");
+  if (filter.type) {
+    conditions.push("type = ?");
+    params.push(filter.type);
   }
-  let sql = "SELECT * FROM memories";
+  if (filter.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filter.project_id);
+  }
+  if (filter.search) {
+    conditions.push("(name LIKE ? OR description LIKE ?)");
+    const term = `%${filter.search}%`;
+    params.push(term, term);
+  }
+  let sql = "SELECT * FROM entities";
   if (conditions.length > 0) {
     sql += ` WHERE ${conditions.join(" AND ")}`;
   }
-  sql += " ORDER BY importance DESC, created_at DESC";
-  if (filter?.limit) {
+  sql += " ORDER BY updated_at DESC";
+  if (filter.limit) {
     sql += " LIMIT ?";
     params.push(filter.limit);
   }
-  if (filter?.offset) {
+  if (filter.offset) {
     sql += " OFFSET ?";
     params.push(filter.offset);
   }
   const rows = d.query(sql).all(...params);
-  return rows.map(parseMemoryRow);
+  return rows.map(parseEntityRow2);
 }
-function updateMemory(id, input, db) {
+function updateEntity(id, input, db) {
   const d = db || getDatabase();
-  const existing = getMemory(id, d);
+  const existing = d.query("SELECT id FROM entities WHERE id = ?").get(id);
   if (!existing)
-    throw new MemoryNotFoundError(id);
-  if (existing.version !== input.version) {
-    throw new VersionConflictError(id, input.version, existing.version);
+    throw new EntityNotFoundError(id);
+  const sets = ["updated_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
   }
-  try {
-    d.run(`INSERT OR IGNORE INTO memory_versions (id, memory_id, version, value, importance, scope, category, tags, summary, pinned, status, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
-      uuid(),
-      existing.id,
-      existing.version,
-      existing.value,
-      existing.importance,
-      existing.scope,
-      existing.category,
-      JSON.stringify(existing.tags),
-      existing.summary,
-      existing.pinned ? 1 : 0,
-      existing.status,
-      existing.updated_at
-    ]);
-  } catch {}
-  const sets = ["version = version + 1", "updated_at = ?"];
-  const params = [now()];
-  if (input.value !== undefined) {
-    sets.push("value = ?");
-    params.push(redactSecrets(input.value));
-  }
-  if (input.category !== undefined) {
-    sets.push("category = ?");
-    params.push(input.category);
-  }
-  if (input.scope !== undefined) {
-    sets.push("scope = ?");
-    params.push(input.scope);
-  }
-  if (input.summary !== undefined) {
-    sets.push("summary = ?");
-    params.push(input.summary);
-  }
-  if (input.importance !== undefined) {
-    sets.push("importance = ?");
-    params.push(input.importance);
-  }
-  if (input.pinned !== undefined) {
-    sets.push("pinned = ?");
-    params.push(input.pinned ? 1 : 0);
+  if (input.type !== undefined) {
+    sets.push("type = ?");
+    params.push(input.type);
   }
-  if (input.status !== undefined) {
-    sets.push("status = ?");
-    params.push(input.status);
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
   }
   if (input.metadata !== undefined) {
     sets.push("metadata = ?");
     params.push(JSON.stringify(input.metadata));
   }
-  if (input.expires_at !== undefined) {
-    sets.push("expires_at = ?");
-    params.push(input.expires_at);
-  }
-  if (input.tags !== undefined) {
-    sets.push("tags = ?");
-    params.push(JSON.stringify(input.tags));
-    d.run("DELETE FROM memory_tags WHERE memory_id = ?", [id]);
-    const insertTag = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
-    for (const tag of input.tags) {
-      insertTag.run(id, tag);
-    }
-  }
   params.push(id);
-  d.run(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`, params);
-  const updated = getMemory(id, d);
-  try {
-    if (input.value !== undefined) {
-      const oldLinks = getEntityMemoryLinks(undefined, updated.id, d);
-      for (const link of oldLinks) {
-        unlinkEntityFromMemory(link.entity_id, updated.id, d);
-      }
-      runEntityExtraction(updated, existing.project_id || undefined, d);
-    }
-  } catch {}
-  return updated;
-}
-function deleteMemory(id, db) {
-  const d = db || getDatabase();
-  const result = d.run("DELETE FROM memories WHERE id = ?", [id]);
-  return result.changes > 0;
-}
-function bulkDeleteMemories(ids, db) {
-  const d = db || getDatabase();
-  if (ids.length === 0)
-    return 0;
-  const placeholders = ids.map(() => "?").join(",");
-  const countRow = d.query(`SELECT COUNT(*) as c FROM memories WHERE id IN (${placeholders})`).get(...ids);
-  const count = countRow.c;
-  if (count > 0) {
-    d.run(`DELETE FROM memories WHERE id IN (${placeholders})`, ids);
-  }
-  return count;
-}
-function touchMemory(id, db) {
-  const d = db || getDatabase();
-  d.run("UPDATE memories SET access_count = access_count + 1, accessed_at = ? WHERE id = ?", [now(), id]);
+  d.run(`UPDATE entities SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getEntity(id, d);
 }
-function cleanExpiredMemories(db) {
+function deleteEntity(id, db) {
   const d = db || getDatabase();
-  const timestamp = now();
-  const countRow = d.query("SELECT COUNT(*) as c FROM memories WHERE expires_at IS NOT NULL AND expires_at < ?").get(timestamp);
-  const count = countRow.c;
-  if (count > 0) {
-    d.run("DELETE FROM memories WHERE expires_at IS NOT NULL AND expires_at < ?", [timestamp]);
-  }
-  return count;
+  const result = d.run("DELETE FROM entities WHERE id = ?", [id]);
+  if (result.changes === 0)
+    throw new EntityNotFoundError(id);
 }
-function getMemoryVersions(memoryId, db) {
+function mergeEntities(sourceId, targetId, db) {
   const d = db || getDatabase();
-  try {
-    const rows = d.query("SELECT * FROM memory_versions WHERE memory_id = ? ORDER BY version ASC").all(memoryId);
-    return rows.map((row) => ({
-      id: row["id"],
-      memory_id: row["memory_id"],
-      version: row["version"],
-      value: row["value"],
-      importance: row["importance"],
-      scope: row["scope"],
-      category: row["category"],
-      tags: JSON.parse(row["tags"] || "[]"),
-      summary: row["summary"] || null,
-      pinned: !!row["pinned"],
-      status: row["status"],
-      created_at: row["created_at"]
-    }));
-  } catch {
-    return [];
-  }
+  getEntity(sourceId, d);
+  getEntity(targetId, d);
+  d.run(`UPDATE OR IGNORE relations SET source_entity_id = ? WHERE source_entity_id = ?`, [targetId, sourceId]);
+  d.run(`UPDATE OR IGNORE relations SET target_entity_id = ? WHERE target_entity_id = ?`, [targetId, sourceId]);
+  d.run("DELETE FROM relations WHERE source_entity_id = ? OR target_entity_id = ?", [
+    sourceId,
+    sourceId
+  ]);
+  d.run(`UPDATE OR IGNORE entity_memories SET entity_id = ? WHERE entity_id = ?`, [targetId, sourceId]);
+  d.run("DELETE FROM entity_memories WHERE entity_id = ?", [sourceId]);
+  d.run("DELETE FROM entities WHERE id = ?", [sourceId]);
+  d.run("UPDATE entities SET updated_at = ? WHERE id = ?", [now(), targetId]);
+  return getEntity(targetId, d);
 }
-// src/db/locks.ts
-function parseLockRow(row) {
+
+// src/lib/search.ts
+function parseMemoryRow2(row) {
   return {
     id: row["id"],
-    resource_type: row["resource_type"],
-    resource_id: row["resource_id"],
-    agent_id: row["agent_id"],
-    lock_type: row["lock_type"],
-    locked_at: row["locked_at"],
-    expires_at: row["expires_at"]
-  };
-}
-function acquireLock(agentId, resourceType, resourceId, lockType = "exclusive", ttlSeconds = 300, db) {
-  const d = db || getDatabase();
-  cleanExpiredLocks(d);
-  const ownLock = d.query("SELECT * FROM resource_locks WHERE resource_type = ? AND resource_id = ? AND agent_id = ? AND lock_type = ? AND expires_at > datetime('now')").get(resourceType, resourceId, agentId, lockType);
-  if (ownLock) {
-    const newExpiry = new Date(Date.now() + ttlSeconds * 1000).toISOString();
-    d.run("UPDATE resource_locks SET expires_at = ? WHERE id = ?", [
-      newExpiry,
-      ownLock["id"]
-    ]);
-    return parseLockRow({ ...ownLock, expires_at: newExpiry });
-  }
-  if (lockType === "exclusive") {
-    const existing = d.query("SELECT * FROM resource_locks WHERE resource_type = ? AND resource_id = ? AND lock_type = 'exclusive' AND agent_id != ? AND expires_at > datetime('now')").get(resourceType, resourceId, agentId);
-    if (existing) {
-      return null;
-    }
-  }
-  const id = shortUuid();
-  const lockedAt = now();
-  const expiresAt = new Date(Date.now() + ttlSeconds * 1000).toISOString();
-  d.run("INSERT INTO resource_locks (id, resource_type, resource_id, agent_id, lock_type, locked_at, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?)", [id, resourceType, resourceId, agentId, lockType, lockedAt, expiresAt]);
-  return {
-    id,
-    resource_type: resourceType,
-    resource_id: resourceId,
-    agent_id: agentId,
-    lock_type: lockType,
-    locked_at: lockedAt,
-    expires_at: expiresAt
+    key: row["key"],
+    value: row["value"],
+    category: row["category"],
+    scope: row["scope"],
+    summary: row["summary"] || null,
+    tags: JSON.parse(row["tags"] || "[]"),
+    importance: row["importance"],
+    source: row["source"],
+    status: row["status"],
+    pinned: !!row["pinned"],
+    agent_id: row["agent_id"] || null,
+    project_id: row["project_id"] || null,
+    session_id: row["session_id"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    access_count: row["access_count"],
+    version: row["version"],
+    expires_at: row["expires_at"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"],
+    accessed_at: row["accessed_at"] || null
   };
 }
-function releaseLock(lockId, agentId, db) {
-  const d = db || getDatabase();
-  const result = d.run("DELETE FROM resource_locks WHERE id = ? AND agent_id = ?", [lockId, agentId]);
-  return result.changes > 0;
-}
-function releaseResourceLocks(agentId, resourceType, resourceId, db) {
-  const d = db || getDatabase();
-  const result = d.run("DELETE FROM resource_locks WHERE agent_id = ? AND resource_type = ? AND resource_id = ?", [agentId, resourceType, resourceId]);
-  return result.changes;
-}
-function releaseAllAgentLocks(agentId, db) {
-  const d = db || getDatabase();
-  const result = d.run("DELETE FROM resource_locks WHERE agent_id = ?", [agentId]);
-  return result.changes;
-}
-function checkLock(resourceType, resourceId, lockType, db) {
-  const d = db || getDatabase();
-  cleanExpiredLocks(d);
-  const query = lockType ? "SELECT * FROM resource_locks WHERE resource_type = ? AND resource_id = ? AND lock_type = ? AND expires_at > datetime('now')" : "SELECT * FROM resource_locks WHERE resource_type = ? AND resource_id = ? AND expires_at > datetime('now')";
-  const rows = lockType ? d.query(query).all(resourceType, resourceId, lockType) : d.query(query).all(resourceType, resourceId);
-  return rows.map(parseLockRow);
-}
-function agentHoldsLock(agentId, resourceType, resourceId, lockType, db) {
-  const d = db || getDatabase();
-  const query = lockType ? "SELECT * FROM resource_locks WHERE agent_id = ? AND resource_type = ? AND resource_id = ? AND lock_type = ? AND expires_at > datetime('now')" : "SELECT * FROM resource_locks WHERE agent_id = ? AND resource_type = ? AND resource_id = ? AND expires_at > datetime('now')";
-  const row = lockType ? d.query(query).get(agentId, resourceType, resourceId, lockType) : d.query(query).get(agentId, resourceType, resourceId);
-  return row ? parseLockRow(row) : null;
-}
-function listAgentLocks(agentId, db) {
-  const d = db || getDatabase();
-  cleanExpiredLocks(d);
-  const rows = d.query("SELECT * FROM resource_locks WHERE agent_id = ? AND expires_at > datetime('now') ORDER BY locked_at DESC").all(agentId);
-  return rows.map(parseLockRow);
-}
-function cleanExpiredLocks(db) {
-  const d = db || getDatabase();
-  const result = d.run("DELETE FROM resource_locks WHERE expires_at <= datetime('now')");
-  return result.changes;
+function preprocessQuery(query) {
+  let q = query.trim();
+  q = q.replace(/\s+/g, " ");
+  q = q.normalize("NFC");
+  return q;
 }
-// src/lib/memory-lock.ts
-var MEMORY_WRITE_TTL = 30;
-function memoryLockId(key, scope, projectId) {
-  return `${scope}:${key}:${projectId ?? ""}`;
-}
-function acquireMemoryWriteLock(agentId, key, scope, projectId, ttlSeconds = MEMORY_WRITE_TTL, db) {
-  const d = db || getDatabase();
-  return acquireLock(agentId, "memory", memoryLockId(key, scope, projectId), "exclusive", ttlSeconds, d);
-}
-function releaseMemoryWriteLock(lockId, agentId, db) {
-  const d = db || getDatabase();
-  return releaseLock(lockId, agentId, d);
-}
-function checkMemoryWriteLock(key, scope, projectId, db) {
-  const d = db || getDatabase();
-  const locks = checkLock("memory", memoryLockId(key, scope, projectId), "exclusive", d);
-  return locks[0] ?? null;
-}
-function withMemoryLock(agentId, key, scope, projectId, fn, ttlSeconds = MEMORY_WRITE_TTL, db) {
-  const d = db || getDatabase();
-  const lock = acquireMemoryWriteLock(agentId, key, scope, projectId, ttlSeconds, d);
-  if (!lock) {
-    const existing = checkMemoryWriteLock(key, scope, projectId, d);
-    throw new MemoryLockConflictError(key, scope, existing?.agent_id ?? "unknown");
-  }
-  try {
-    return fn();
-  } finally {
-    releaseLock(lock.id, agentId, d);
-  }
-}
-
-class MemoryLockConflictError extends Error {
-  conflict = true;
-  key;
-  scope;
-  blocking_agent_id;
-  constructor(key, scope, blockingAgentId) {
-    super(`Memory key "${key}" (scope: ${scope}) is currently write-locked by agent ${blockingAgentId}. ` + "Retry after a few seconds or use optimistic locking (version field).");
-    this.name = "MemoryLockConflictError";
-    this.key = key;
-    this.scope = scope;
-    this.blocking_agent_id = blockingAgentId;
-  }
-}
-// src/lib/search.ts
-function parseMemoryRow2(row) {
-  return {
-    id: row["id"],
-    key: row["key"],
-    value: row["value"],
-    category: row["category"],
-    scope: row["scope"],
-    summary: row["summary"] || null,
-    tags: JSON.parse(row["tags"] || "[]"),
-    importance: row["importance"],
-    source: row["source"],
-    status: row["status"],
-    pinned: !!row["pinned"],
-    agent_id: row["agent_id"] || null,
-    project_id: row["project_id"] || null,
-    session_id: row["session_id"] || null,
-    metadata: JSON.parse(row["metadata"] || "{}"),
-    access_count: row["access_count"],
-    version: row["version"],
-    expires_at: row["expires_at"] || null,
-    created_at: row["created_at"],
-    updated_at: row["updated_at"],
-    accessed_at: row["accessed_at"] || null
-  };
-}
-function preprocessQuery(query) {
-  let q = query.trim();
-  q = q.replace(/\s+/g, " ");
-  q = q.normalize("NFC");
-  return q;
-}
-function escapeLikePattern(s) {
-  return s.replace(/%/g, "\\%").replace(/_/g, "\\_");
+function escapeLikePattern(s) {
+  return s.replace(/%/g, "\\%").replace(/_/g, "\\_");
 }
 var STOP_WORDS = new Set([
   "a",
@@ -2309,6 +1953,12 @@ function searchMemories(query, filter, db) {
   const offset = filter?.offset ?? 0;
   const limit = filter?.limit ?? scored.length;
   const finalResults = scored.slice(offset, offset + limit);
+  if (finalResults.length > 0 && scored.length > 0) {
+    const topScore = scored[0]?.score ?? 0;
+    const secondScore = scored[1]?.score ?? 0;
+    const confidence = topScore > 0 ? Math.max(0, Math.min(1, (topScore - secondScore) / topScore)) : 0;
+    finalResults[0] = { ...finalResults[0], confidence };
+  }
   logSearchQuery(query, scored.length, filter?.agent_id, filter?.project_id, d);
   return finalResults;
 }
@@ -2319,6 +1969,148 @@ function logSearchQuery(query, resultCount, agentId, projectId, db) {
     d.run("INSERT INTO search_history (id, query, result_count, agent_id, project_id) VALUES (?, ?, ?, ?, ?)", [id, query, resultCount, agentId || null, projectId || null]);
   } catch {}
 }
+// src/lib/config.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, readdirSync, writeFileSync, unlinkSync } from "fs";
+import { homedir } from "os";
+import { basename, dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+var DEFAULT_CONFIG = {
+  default_scope: "private",
+  default_category: "knowledge",
+  default_importance: 5,
+  max_entries: 1000,
+  max_entries_per_scope: {
+    global: 500,
+    shared: 300,
+    private: 200
+  },
+  injection: {
+    max_tokens: 500,
+    min_importance: 5,
+    categories: ["preference", "fact"],
+    refresh_interval: 5
+  },
+  extraction: {
+    enabled: true,
+    min_confidence: 0.5
+  },
+  sync_agents: ["claude", "codex", "gemini"],
+  auto_cleanup: {
+    enabled: true,
+    expired_check_interval: 3600,
+    unused_archive_days: 7,
+    stale_deprioritize_days: 14
+  }
+};
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = result[key];
+    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(targetVal, sourceVal);
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+var VALID_SCOPES = ["global", "shared", "private"];
+var VALID_CATEGORIES = [
+  "preference",
+  "fact",
+  "knowledge",
+  "history"
+];
+function isValidScope(value) {
+  return VALID_SCOPES.includes(value);
+}
+function isValidCategory(value) {
+  return VALID_CATEGORIES.includes(value);
+}
+function loadConfig() {
+  const configPath = join2(homedir(), ".mementos", "config.json");
+  let fileConfig = {};
+  if (existsSync2(configPath)) {
+    try {
+      const raw = readFileSync(configPath, "utf-8");
+      fileConfig = JSON.parse(raw);
+    } catch {}
+  }
+  const merged = deepMerge(DEFAULT_CONFIG, fileConfig);
+  const envScope = process.env["MEMENTOS_DEFAULT_SCOPE"];
+  if (envScope && isValidScope(envScope)) {
+    merged.default_scope = envScope;
+  }
+  const envCategory = process.env["MEMENTOS_DEFAULT_CATEGORY"];
+  if (envCategory && isValidCategory(envCategory)) {
+    merged.default_category = envCategory;
+  }
+  const envImportance = process.env["MEMENTOS_DEFAULT_IMPORTANCE"];
+  if (envImportance) {
+    const parsed = parseInt(envImportance, 10);
+    if (!Number.isNaN(parsed) && parsed >= 1 && parsed <= 10) {
+      merged.default_importance = parsed;
+    }
+  }
+  return merged;
+}
+function profilesDir() {
+  return join2(homedir(), ".mementos", "profiles");
+}
+function globalConfigPath() {
+  return join2(homedir(), ".mementos", "config.json");
+}
+function readGlobalConfig() {
+  const p = globalConfigPath();
+  if (!existsSync2(p))
+    return {};
+  try {
+    return JSON.parse(readFileSync(p, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeGlobalConfig(data) {
+  const p = globalConfigPath();
+  ensureDir2(dirname2(p));
+  writeFileSync(p, JSON.stringify(data, null, 2), "utf-8");
+}
+function getActiveProfile() {
+  const envProfile = process.env["MEMENTOS_PROFILE"];
+  if (envProfile)
+    return envProfile.trim();
+  const cfg = readGlobalConfig();
+  return cfg["active_profile"] || null;
+}
+function setActiveProfile(name) {
+  const cfg = readGlobalConfig();
+  if (name === null) {
+    delete cfg["active_profile"];
+  } else {
+    cfg["active_profile"] = name;
+  }
+  writeGlobalConfig(cfg);
+}
+function listProfiles() {
+  const dir = profilesDir();
+  if (!existsSync2(dir))
+    return [];
+  return readdirSync(dir).filter((f) => f.endsWith(".db")).map((f) => basename(f, ".db")).sort();
+}
+function deleteProfile(name) {
+  const dbPath = join2(profilesDir(), `${name}.db`);
+  if (!existsSync2(dbPath))
+    return false;
+  unlinkSync(dbPath);
+  if (getActiveProfile() === name)
+    setActiveProfile(null);
+  return true;
+}
+function ensureDir2(dir) {
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+}
 // src/lib/injector.ts
 class MemoryInjector {
   config;
@@ -2486,183 +2278,1084 @@ function enforceQuotas(config, db) {
     d.run(`DELETE FROM memories WHERE id IN (${subquery})`, [scope, excess]);
     totalEvicted += delCount;
   }
-  return totalEvicted;
+  return totalEvicted;
+}
+function archiveStale(staleDays, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  const cutoff = new Date(Date.now() - staleDays * 24 * 60 * 60 * 1000).toISOString();
+  const archiveWhere = `status = 'active' AND pinned = 0 AND COALESCE(accessed_at, created_at) < ?`;
+  const count = d.query(`SELECT COUNT(*) as c FROM memories WHERE ${archiveWhere}`).get(cutoff).c;
+  if (count > 0) {
+    d.run(`UPDATE memories SET status = 'archived', updated_at = ? WHERE ${archiveWhere}`, [timestamp, cutoff]);
+  }
+  return count;
+}
+function archiveUnused(days, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+  const unusedWhere = `status = 'active' AND pinned = 0 AND access_count = 0 AND created_at < ?`;
+  const count = d.query(`SELECT COUNT(*) as c FROM memories WHERE ${unusedWhere}`).get(cutoff).c;
+  if (count > 0) {
+    d.run(`UPDATE memories SET status = 'archived', updated_at = ? WHERE ${unusedWhere}`, [timestamp, cutoff]);
+  }
+  return count;
+}
+function deprioritizeStale(days, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+  const deprioWhere = `status = 'active' AND pinned = 0 AND importance > 1 AND COALESCE(accessed_at, updated_at) < ?`;
+  const count = d.query(`SELECT COUNT(*) as c FROM memories WHERE ${deprioWhere}`).get(cutoff).c;
+  if (count > 0) {
+    d.run(`UPDATE memories
+       SET importance = MAX(importance - 1, 1),
+           version = version + 1,
+           updated_at = ?
+       WHERE ${deprioWhere}`, [timestamp, cutoff]);
+  }
+  return count;
+}
+function runCleanup(config, db) {
+  const d = db || getDatabase();
+  const expired = cleanExpiredMemories(d);
+  const evicted = enforceQuotas(config, d);
+  const archived = archiveStale(90, d);
+  const unused_archived = archiveUnused(config.auto_cleanup.unused_archive_days ?? 7, d);
+  const deprioritized = deprioritizeStale(config.auto_cleanup.stale_deprioritize_days ?? 14, d);
+  return { expired, evicted, archived, unused_archived, deprioritized };
+}
+// src/lib/sync.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+function getAgentSyncDir(agentName) {
+  const dir = join3(homedir2(), ".mementos", "agents", agentName);
+  if (!existsSync3(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  return dir;
+}
+function setHighWaterMark(agentDir, timestamp) {
+  const markFile = join3(agentDir, ".highwatermark");
+  writeFileSync2(markFile, timestamp, "utf-8");
+}
+function resolveConflict(local, remote, resolution) {
+  switch (resolution) {
+    case "prefer-local":
+      return "local";
+    case "prefer-remote":
+      return "remote";
+    case "prefer-newer":
+      return new Date(local.updated_at).getTime() >= new Date(remote.updated_at).getTime() ? "local" : "remote";
+  }
+}
+function pushMemories(agentName, agentId, projectId, db) {
+  const agentDir = getAgentSyncDir(agentName);
+  const memories = listMemories({
+    agent_id: agentId,
+    project_id: projectId,
+    status: "active",
+    limit: 1e4
+  }, db);
+  const outFile = join3(agentDir, "memories.json");
+  writeFileSync2(outFile, JSON.stringify(memories, null, 2), "utf-8");
+  if (memories.length > 0) {
+    const latest = memories.reduce((a, b) => new Date(a.updated_at).getTime() > new Date(b.updated_at).getTime() ? a : b);
+    setHighWaterMark(agentDir, latest.updated_at);
+  }
+  return memories.length;
+}
+function pullMemories(agentName, conflictResolution = "prefer-newer", db) {
+  const agentDir = getAgentSyncDir(agentName);
+  const inFile = join3(agentDir, "memories.json");
+  if (!existsSync3(inFile)) {
+    return { pulled: 0, conflicts: 0 };
+  }
+  const raw = readFileSync2(inFile, "utf-8");
+  let remoteMemories;
+  try {
+    remoteMemories = JSON.parse(raw);
+  } catch {
+    return { pulled: 0, conflicts: 0 };
+  }
+  let pulled = 0;
+  let conflicts = 0;
+  for (const remote of remoteMemories) {
+    const localMemories = listMemories({
+      search: remote.key,
+      scope: remote.scope,
+      agent_id: remote.agent_id || undefined,
+      project_id: remote.project_id || undefined,
+      limit: 1
+    }, db);
+    const local = localMemories.find((m) => m.key === remote.key);
+    if (local) {
+      const winner = resolveConflict(local, remote, conflictResolution);
+      if (winner === "remote") {
+        createMemory({
+          key: remote.key,
+          value: remote.value,
+          category: remote.category,
+          scope: remote.scope,
+          summary: remote.summary || undefined,
+          tags: remote.tags,
+          importance: remote.importance,
+          source: remote.source,
+          agent_id: remote.agent_id || undefined,
+          project_id: remote.project_id || undefined,
+          session_id: remote.session_id || undefined,
+          metadata: remote.metadata,
+          expires_at: remote.expires_at || undefined
+        }, "merge", db);
+        pulled++;
+      }
+      conflicts++;
+    } else {
+      createMemory({
+        key: remote.key,
+        value: remote.value,
+        category: remote.category,
+        scope: remote.scope,
+        summary: remote.summary || undefined,
+        tags: remote.tags,
+        importance: remote.importance,
+        source: remote.source,
+        agent_id: remote.agent_id || undefined,
+        project_id: remote.project_id || undefined,
+        session_id: remote.session_id || undefined,
+        metadata: remote.metadata,
+        expires_at: remote.expires_at || undefined
+      }, "create", db);
+      pulled++;
+    }
+  }
+  return { pulled, conflicts };
+}
+function syncMemories(agentName, direction = "both", options = {}) {
+  const result = {
+    pushed: 0,
+    pulled: 0,
+    conflicts: 0,
+    errors: []
+  };
+  try {
+    if (direction === "push" || direction === "both") {
+      result.pushed = pushMemories(agentName, options.agent_id, options.project_id, options.db);
+    }
+    if (direction === "pull" || direction === "both") {
+      const pullResult = pullMemories(agentName, options.conflict_resolution || "prefer-newer", options.db);
+      result.pulled = pullResult.pulled;
+      result.conflicts = pullResult.conflicts;
+    }
+  } catch (e) {
+    result.errors.push(e instanceof Error ? e.message : String(e));
+  }
+  return result;
+}
+var defaultSyncAgents = ["claude", "codex", "gemini"];
+// src/db/relations.ts
+function parseRelationRow(row) {
+  return {
+    id: row["id"],
+    source_entity_id: row["source_entity_id"],
+    target_entity_id: row["target_entity_id"],
+    relation_type: row["relation_type"],
+    weight: row["weight"],
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    created_at: row["created_at"]
+  };
+}
+function parseEntityRow3(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    type: row["type"],
+    description: row["description"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    project_id: row["project_id"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"]
+  };
+}
+function createRelation(input, db) {
+  const d = db || getDatabase();
+  const id = shortUuid();
+  const timestamp = now();
+  const weight = input.weight ?? 1;
+  const metadata = JSON.stringify(input.metadata ?? {});
+  d.run(`INSERT INTO relations (id, source_entity_id, target_entity_id, relation_type, weight, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(source_entity_id, target_entity_id, relation_type)
+     DO UPDATE SET weight = excluded.weight, metadata = excluded.metadata`, [id, input.source_entity_id, input.target_entity_id, input.relation_type, weight, metadata, timestamp]);
+  const row = d.query(`SELECT * FROM relations
+       WHERE source_entity_id = ? AND target_entity_id = ? AND relation_type = ?`).get(input.source_entity_id, input.target_entity_id, input.relation_type);
+  return parseRelationRow(row);
+}
+function getRelation(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM relations WHERE id = ?").get(id);
+  if (!row)
+    throw new Error(`Relation not found: ${id}`);
+  return parseRelationRow(row);
+}
+function listRelations(filter, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter.entity_id) {
+    const dir = filter.direction || "both";
+    if (dir === "outgoing") {
+      conditions.push("source_entity_id = ?");
+      params.push(filter.entity_id);
+    } else if (dir === "incoming") {
+      conditions.push("target_entity_id = ?");
+      params.push(filter.entity_id);
+    } else {
+      conditions.push("(source_entity_id = ? OR target_entity_id = ?)");
+      params.push(filter.entity_id, filter.entity_id);
+    }
+  }
+  if (filter.relation_type) {
+    conditions.push("relation_type = ?");
+    params.push(filter.relation_type);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = d.query(`SELECT * FROM relations ${where} ORDER BY created_at DESC`).all(...params);
+  return rows.map(parseRelationRow);
+}
+function deleteRelation(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM relations WHERE id = ?", [id]);
+  if (result.changes === 0)
+    throw new Error(`Relation not found: ${id}`);
+}
+function getRelatedEntities(entityId, relationType, db) {
+  const d = db || getDatabase();
+  let sql;
+  const params = [];
+  if (relationType) {
+    sql = `
+      SELECT DISTINCT e.* FROM entities e
+      JOIN relations r ON (
+        (r.source_entity_id = ? AND r.target_entity_id = e.id)
+        OR (r.target_entity_id = ? AND r.source_entity_id = e.id)
+      )
+      WHERE r.relation_type = ?
+    `;
+    params.push(entityId, entityId, relationType);
+  } else {
+    sql = `
+      SELECT DISTINCT e.* FROM entities e
+      JOIN relations r ON (
+        (r.source_entity_id = ? AND r.target_entity_id = e.id)
+        OR (r.target_entity_id = ? AND r.source_entity_id = e.id)
+      )
+    `;
+    params.push(entityId, entityId);
+  }
+  const rows = d.query(sql).all(...params);
+  return rows.map(parseEntityRow3);
+}
+function getEntityGraph(entityId, depth = 2, db) {
+  const d = db || getDatabase();
+  const entityRows = d.query(`WITH RECURSIVE graph(id, depth) AS (
+        VALUES(?, 0)
+        UNION
+        SELECT CASE WHEN r.source_entity_id = g.id THEN r.target_entity_id ELSE r.source_entity_id END, g.depth + 1
+        FROM relations r JOIN graph g ON (r.source_entity_id = g.id OR r.target_entity_id = g.id)
+        WHERE g.depth < ?
+      )
+      SELECT DISTINCT e.* FROM entities e JOIN graph g ON e.id = g.id`).all(entityId, depth);
+  const entities = entityRows.map(parseEntityRow3);
+  const entityIds = new Set(entities.map((e) => e.id));
+  if (entityIds.size === 0) {
+    return { entities: [], relations: [] };
+  }
+  const placeholders = Array.from(entityIds).map(() => "?").join(",");
+  const relationRows = d.query(`SELECT * FROM relations
+       WHERE source_entity_id IN (${placeholders})
+         AND target_entity_id IN (${placeholders})`).all(...Array.from(entityIds), ...Array.from(entityIds));
+  const relations = relationRows.map(parseRelationRow);
+  return { entities, relations };
+}
+function findPath(fromEntityId, toEntityId, maxDepth = 5, db) {
+  const d = db || getDatabase();
+  const rows = d.query(`WITH RECURSIVE path(id, trail, depth) AS (
+        SELECT ?, ?, 0
+        UNION
+        SELECT
+          CASE WHEN r.source_entity_id = p.id THEN r.target_entity_id ELSE r.source_entity_id END,
+          p.trail || ',' || CASE WHEN r.source_entity_id = p.id THEN r.target_entity_id ELSE r.source_entity_id END,
+          p.depth + 1
+        FROM relations r JOIN path p ON (r.source_entity_id = p.id OR r.target_entity_id = p.id)
+        WHERE p.depth < ?
+          AND INSTR(p.trail, CASE WHEN r.source_entity_id = p.id THEN r.target_entity_id ELSE r.source_entity_id END) = 0
+      )
+      SELECT trail FROM path WHERE id = ? ORDER BY depth ASC LIMIT 1`).get(fromEntityId, fromEntityId, maxDepth, toEntityId);
+  if (!rows)
+    return null;
+  const ids = rows.trail.split(",");
+  const entities = [];
+  for (const id of ids) {
+    const row = d.query("SELECT * FROM entities WHERE id = ?").get(id);
+    if (row)
+      entities.push(parseEntityRow3(row));
+  }
+  return entities.length > 0 ? entities : null;
+}
+// src/lib/providers/base.ts
+var DEFAULT_AUTO_MEMORY_CONFIG = {
+  provider: "anthropic",
+  model: "claude-haiku-4-5",
+  enabled: true,
+  minImportance: 4,
+  autoEntityLink: true,
+  fallback: ["cerebras", "openai"]
+};
+
+class BaseProvider {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  parseJSON(raw) {
+    try {
+      const cleaned = raw.replace(/^```(?:json)?\s*/m, "").replace(/\s*```$/m, "").trim();
+      return JSON.parse(cleaned);
+    } catch {
+      return null;
+    }
+  }
+  clampImportance(value) {
+    const n = Number(value);
+    if (isNaN(n))
+      return 5;
+    return Math.max(0, Math.min(10, Math.round(n)));
+  }
+  normaliseMemory(raw) {
+    if (!raw || typeof raw !== "object")
+      return null;
+    const m = raw;
+    if (typeof m.content !== "string" || !m.content.trim())
+      return null;
+    const validScopes = ["private", "shared", "global"];
+    const validCategories = [
+      "preference",
+      "fact",
+      "knowledge",
+      "history"
+    ];
+    return {
+      content: m.content.trim(),
+      category: validCategories.includes(m.category) ? m.category : "knowledge",
+      importance: this.clampImportance(m.importance),
+      tags: Array.isArray(m.tags) ? m.tags.filter((t) => typeof t === "string").map((t) => t.toLowerCase()) : [],
+      suggestedScope: validScopes.includes(m.suggestedScope) ? m.suggestedScope : "shared",
+      reasoning: typeof m.reasoning === "string" ? m.reasoning : undefined
+    };
+  }
+}
+var MEMORY_EXTRACTION_SYSTEM_PROMPT = `You are a precise memory extraction engine for an AI agent.
+Given text, extract facts worth remembering as structured JSON.
+Focus on: decisions made, preferences revealed, corrections, architectural choices, established facts, user preferences.
+Ignore: greetings, filler, questions without answers, temporary states.
+Output ONLY a JSON array \u2014 no markdown, no explanation.`;
+var MEMORY_EXTRACTION_USER_TEMPLATE = (text, context) => `Extract memories from this text.
+${context.projectName ? `Project: ${context.projectName}` : ""}
+${context.existingMemoriesSummary ? `Existing memories (avoid duplicates):
+${context.existingMemoriesSummary}` : ""}
+
+Text:
+${text}
+
+Return a JSON array of objects with these exact fields:
+- content: string (the memory, concise and specific)
+- category: "preference" | "fact" | "knowledge" | "history"
+- importance: number 0-10 (10 = critical, 0 = trivial)
+- tags: string[] (lowercase keywords)
+- suggestedScope: "private" | "shared" | "global"
+- reasoning: string (one sentence why this is worth remembering)
+
+Return [] if nothing is worth remembering.`;
+var ENTITY_EXTRACTION_SYSTEM_PROMPT = `You are a knowledge graph entity extractor.
+Given text, identify named entities and their relationships.
+Output ONLY valid JSON \u2014 no markdown, no explanation.`;
+var ENTITY_EXTRACTION_USER_TEMPLATE = (text) => `Extract entities and relations from this text.
+
+Text: ${text}
+
+Return JSON with this exact shape:
+{
+  "entities": [
+    { "name": string, "type": "person"|"project"|"tool"|"concept"|"file"|"api"|"pattern"|"organization", "confidence": 0-1 }
+  ],
+  "relations": [
+    { "from": string, "to": string, "type": "uses"|"knows"|"depends_on"|"created_by"|"related_to"|"contradicts"|"part_of"|"implements" }
+  ]
+}`;
+
+// src/lib/providers/anthropic.ts
+var ANTHROPIC_MODELS = {
+  default: "claude-haiku-4-5",
+  premium: "claude-sonnet-4-5"
+};
+
+class AnthropicProvider extends BaseProvider {
+  name = "anthropic";
+  baseUrl = "https://api.anthropic.com/v1";
+  constructor(config) {
+    const apiKey = config?.apiKey ?? process.env.ANTHROPIC_API_KEY ?? "";
+    super({
+      apiKey,
+      model: config?.model ?? ANTHROPIC_MODELS.default,
+      maxTokens: config?.maxTokens ?? 1024,
+      temperature: config?.temperature ?? 0,
+      timeoutMs: config?.timeoutMs ?? 15000
+    });
+  }
+  async extractMemories(text, context) {
+    if (!this.config.apiKey)
+      return [];
+    try {
+      const response = await this.callAPI(MEMORY_EXTRACTION_SYSTEM_PROMPT, MEMORY_EXTRACTION_USER_TEMPLATE(text, context));
+      const parsed = this.parseJSON(response);
+      if (!Array.isArray(parsed))
+        return [];
+      return parsed.map((item) => this.normaliseMemory(item)).filter((m) => m !== null);
+    } catch (err) {
+      console.error("[anthropic] extractMemories failed:", err);
+      return [];
+    }
+  }
+  async extractEntities(text) {
+    const empty = { entities: [], relations: [] };
+    if (!this.config.apiKey)
+      return empty;
+    try {
+      const response = await this.callAPI(ENTITY_EXTRACTION_SYSTEM_PROMPT, ENTITY_EXTRACTION_USER_TEMPLATE(text));
+      const parsed = this.parseJSON(response);
+      if (!parsed || typeof parsed !== "object")
+        return empty;
+      return {
+        entities: Array.isArray(parsed.entities) ? parsed.entities : [],
+        relations: Array.isArray(parsed.relations) ? parsed.relations : []
+      };
+    } catch (err) {
+      console.error("[anthropic] extractEntities failed:", err);
+      return empty;
+    }
+  }
+  async scoreImportance(content, _context) {
+    if (!this.config.apiKey)
+      return 5;
+    try {
+      const response = await this.callAPI("You are an importance scorer. Return only a single integer 0-10. No explanation.", `How important is this memory for an AI agent to retain long-term?
+
+"${content}"
+
+Return only a number 0-10.`);
+      return this.clampImportance(response.trim());
+    } catch {
+      return 5;
+    }
+  }
+  async callAPI(systemPrompt, userMessage) {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 15000);
+    try {
+      const res = await fetch(`${this.baseUrl}/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.config.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: this.config.model,
+          max_tokens: this.config.maxTokens ?? 1024,
+          temperature: this.config.temperature ?? 0,
+          system: systemPrompt,
+          messages: [{ role: "user", content: userMessage }]
+        }),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`Anthropic API ${res.status}: ${body.slice(0, 200)}`);
+      }
+      const data = await res.json();
+      return data.content?.[0]?.text ?? "";
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+}
+
+// src/lib/providers/openai-compat.ts
+class OpenAICompatProvider extends BaseProvider {
+  constructor(config) {
+    super(config);
+  }
+  async extractMemories(text, context) {
+    if (!this.config.apiKey)
+      return [];
+    try {
+      const response = await this.callWithRetry(MEMORY_EXTRACTION_SYSTEM_PROMPT, MEMORY_EXTRACTION_USER_TEMPLATE(text, context));
+      const parsed = this.parseJSON(response);
+      if (!Array.isArray(parsed))
+        return [];
+      return parsed.map((item) => this.normaliseMemory(item)).filter((m) => m !== null);
+    } catch (err) {
+      console.error(`[${this.name}] extractMemories failed:`, err);
+      return [];
+    }
+  }
+  async extractEntities(text) {
+    const empty = { entities: [], relations: [] };
+    if (!this.config.apiKey)
+      return empty;
+    try {
+      const response = await this.callWithRetry(ENTITY_EXTRACTION_SYSTEM_PROMPT, ENTITY_EXTRACTION_USER_TEMPLATE(text));
+      const parsed = this.parseJSON(response);
+      if (!parsed || typeof parsed !== "object")
+        return empty;
+      return {
+        entities: Array.isArray(parsed.entities) ? parsed.entities : [],
+        relations: Array.isArray(parsed.relations) ? parsed.relations : []
+      };
+    } catch (err) {
+      console.error(`[${this.name}] extractEntities failed:`, err);
+      return empty;
+    }
+  }
+  async scoreImportance(content, _context) {
+    if (!this.config.apiKey)
+      return 5;
+    try {
+      const response = await this.callWithRetry("You are an importance scorer. Return only a single integer 0-10. No explanation.", `How important is this memory for an AI agent to retain long-term?
+
+"${content}"
+
+Return only a number 0-10.`);
+      return this.clampImportance(response.trim());
+    } catch {
+      return 5;
+    }
+  }
+  async callWithRetry(systemPrompt, userMessage, retries = 3) {
+    let lastError = null;
+    for (let attempt = 0;attempt < retries; attempt++) {
+      try {
+        return await this.callAPI(systemPrompt, userMessage);
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        const isRateLimit = lastError.message.includes("429") || lastError.message.toLowerCase().includes("rate limit");
+        if (!isRateLimit || attempt === retries - 1)
+          throw lastError;
+        await new Promise((r) => setTimeout(r, 1000 * Math.pow(2, attempt)));
+      }
+    }
+    throw lastError ?? new Error("Unknown error");
+  }
+  async callAPI(systemPrompt, userMessage) {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 15000);
+    try {
+      const res = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          [this.authHeader]: `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.config.model,
+          max_tokens: this.config.maxTokens ?? 1024,
+          temperature: this.config.temperature ?? 0,
+          messages: [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: userMessage }
+          ]
+        }),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`${this.name} API ${res.status}: ${body.slice(0, 200)}`);
+      }
+      const data = await res.json();
+      return data.choices?.[0]?.message?.content ?? "";
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
 }
-function archiveStale(staleDays, db) {
-  const d = db || getDatabase();
-  const timestamp = now();
-  const cutoff = new Date(Date.now() - staleDays * 24 * 60 * 60 * 1000).toISOString();
-  const archiveWhere = `status = 'active' AND pinned = 0 AND COALESCE(accessed_at, created_at) < ?`;
-  const count = d.query(`SELECT COUNT(*) as c FROM memories WHERE ${archiveWhere}`).get(cutoff).c;
-  if (count > 0) {
-    d.run(`UPDATE memories SET status = 'archived', updated_at = ? WHERE ${archiveWhere}`, [timestamp, cutoff]);
+
+// src/lib/providers/openai.ts
+var OPENAI_MODELS = {
+  default: "gpt-4.1-nano",
+  mini: "gpt-4.1-mini",
+  full: "gpt-4.1"
+};
+
+class OpenAIProvider extends OpenAICompatProvider {
+  name = "openai";
+  baseUrl = "https://api.openai.com/v1";
+  authHeader = "Authorization";
+  constructor(config) {
+    super({
+      apiKey: config?.apiKey ?? process.env.OPENAI_API_KEY ?? "",
+      model: config?.model ?? OPENAI_MODELS.default,
+      maxTokens: config?.maxTokens ?? 1024,
+      temperature: config?.temperature ?? 0,
+      timeoutMs: config?.timeoutMs ?? 15000
+    });
   }
-  return count;
 }
-function archiveUnused(days, db) {
-  const d = db || getDatabase();
-  const timestamp = now();
-  const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
-  const unusedWhere = `status = 'active' AND pinned = 0 AND access_count = 0 AND created_at < ?`;
-  const count = d.query(`SELECT COUNT(*) as c FROM memories WHERE ${unusedWhere}`).get(cutoff).c;
-  if (count > 0) {
-    d.run(`UPDATE memories SET status = 'archived', updated_at = ? WHERE ${unusedWhere}`, [timestamp, cutoff]);
+
+// src/lib/providers/cerebras.ts
+var CEREBRAS_MODELS = {
+  default: "llama-3.3-70b",
+  fast: "llama3.1-8b"
+};
+
+class CerebrasProvider extends OpenAICompatProvider {
+  name = "cerebras";
+  baseUrl = "https://api.cerebras.ai/v1";
+  authHeader = "Authorization";
+  constructor(config) {
+    super({
+      apiKey: config?.apiKey ?? process.env.CEREBRAS_API_KEY ?? "",
+      model: config?.model ?? CEREBRAS_MODELS.default,
+      maxTokens: config?.maxTokens ?? 1024,
+      temperature: config?.temperature ?? 0,
+      timeoutMs: config?.timeoutMs ?? 1e4
+    });
   }
-  return count;
 }
-function deprioritizeStale(days, db) {
-  const d = db || getDatabase();
-  const timestamp = now();
-  const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
-  const deprioWhere = `status = 'active' AND pinned = 0 AND importance > 1 AND COALESCE(accessed_at, updated_at) < ?`;
-  const count = d.query(`SELECT COUNT(*) as c FROM memories WHERE ${deprioWhere}`).get(cutoff).c;
-  if (count > 0) {
-    d.run(`UPDATE memories
-       SET importance = MAX(importance - 1, 1),
-           version = version + 1,
-           updated_at = ?
-       WHERE ${deprioWhere}`, [timestamp, cutoff]);
+
+// src/lib/providers/grok.ts
+var GROK_MODELS = {
+  default: "grok-3-mini",
+  premium: "grok-3"
+};
+
+class GrokProvider extends OpenAICompatProvider {
+  name = "grok";
+  baseUrl = "https://api.x.ai/v1";
+  authHeader = "Authorization";
+  constructor(config) {
+    super({
+      apiKey: config?.apiKey ?? process.env.XAI_API_KEY ?? "",
+      model: config?.model ?? GROK_MODELS.default,
+      maxTokens: config?.maxTokens ?? 1024,
+      temperature: config?.temperature ?? 0,
+      timeoutMs: config?.timeoutMs ?? 15000
+    });
   }
-  return count;
 }
-function runCleanup(config, db) {
-  const d = db || getDatabase();
-  const expired = cleanExpiredMemories(d);
-  const evicted = enforceQuotas(config, d);
-  const archived = archiveStale(90, d);
-  const unused_archived = archiveUnused(config.auto_cleanup.unused_archive_days ?? 7, d);
-  const deprioritized = deprioritizeStale(config.auto_cleanup.stale_deprioritize_days ?? 14, d);
-  return { expired, evicted, archived, unused_archived, deprioritized };
+
+// src/lib/providers/registry.ts
+class ProviderRegistry {
+  config = { ...DEFAULT_AUTO_MEMORY_CONFIG };
+  _instances = new Map;
+  configure(partial) {
+    this.config = { ...this.config, ...partial };
+    this._instances.clear();
+  }
+  getConfig() {
+    return this.config;
+  }
+  getPrimary() {
+    return this.getProvider(this.config.provider);
+  }
+  getFallbacks() {
+    const fallbackNames = this.config.fallback ?? [];
+    return fallbackNames.filter((n) => n !== this.config.provider).map((n) => this.getProvider(n)).filter((p) => p !== null);
+  }
+  getAvailable() {
+    const primary = this.getPrimary();
+    if (primary)
+      return primary;
+    const fallbacks = this.getFallbacks();
+    return fallbacks[0] ?? null;
+  }
+  getProvider(name) {
+    const cached = this._instances.get(name);
+    if (cached)
+      return cached;
+    const provider = this.createProvider(name);
+    if (!provider)
+      return null;
+    if (!provider.config.apiKey)
+      return null;
+    this._instances.set(name, provider);
+    return provider;
+  }
+  health() {
+    const providers = ["anthropic", "openai", "cerebras", "grok"];
+    const result = {};
+    for (const name of providers) {
+      const p = this.createProvider(name);
+      result[name] = {
+        available: Boolean(p?.config.apiKey),
+        model: p?.config.model ?? "unknown"
+      };
+    }
+    return result;
+  }
+  createProvider(name) {
+    const modelOverride = name === this.config.provider ? this.config.model : undefined;
+    switch (name) {
+      case "anthropic":
+        return new AnthropicProvider(modelOverride ? { model: modelOverride } : undefined);
+      case "openai":
+        return new OpenAIProvider(modelOverride ? { model: modelOverride } : undefined);
+      case "cerebras":
+        return new CerebrasProvider(modelOverride ? { model: modelOverride } : undefined);
+      case "grok":
+        return new GrokProvider(modelOverride ? { model: modelOverride } : undefined);
+      default:
+        return null;
+    }
+  }
 }
-// src/lib/sync.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
-function getAgentSyncDir(agentName) {
-  const dir = join3(homedir2(), ".mementos", "agents", agentName);
-  if (!existsSync3(dir)) {
-    mkdirSync3(dir, { recursive: true });
+var providerRegistry = new ProviderRegistry;
+function autoConfigureFromEnv() {
+  const hasAnthropicKey = Boolean(process.env.ANTHROPIC_API_KEY);
+  const hasCerebrasKey = Boolean(process.env.CEREBRAS_API_KEY);
+  const hasOpenAIKey = Boolean(process.env.OPENAI_API_KEY);
+  const hasGrokKey = Boolean(process.env.XAI_API_KEY);
+  if (!hasAnthropicKey) {
+    if (hasCerebrasKey) {
+      providerRegistry.configure({ provider: "cerebras" });
+    } else if (hasOpenAIKey) {
+      providerRegistry.configure({ provider: "openai" });
+    } else if (hasGrokKey) {
+      providerRegistry.configure({ provider: "grok" });
+    }
   }
-  return dir;
+  const allProviders = ["anthropic", "cerebras", "openai", "grok"];
+  const available = allProviders.filter((p) => {
+    switch (p) {
+      case "anthropic":
+        return hasAnthropicKey;
+      case "cerebras":
+        return hasCerebrasKey;
+      case "openai":
+        return hasOpenAIKey;
+      case "grok":
+        return hasGrokKey;
+    }
+  });
+  const primary = providerRegistry.getConfig().provider;
+  const fallback = available.filter((p) => p !== primary);
+  providerRegistry.configure({ fallback });
 }
-function setHighWaterMark(agentDir, timestamp) {
-  const markFile = join3(agentDir, ".highwatermark");
-  writeFileSync2(markFile, timestamp, "utf-8");
+autoConfigureFromEnv();
+
+// src/lib/auto-memory-queue.ts
+var MAX_QUEUE_SIZE = 100;
+var CONCURRENCY = 3;
+
+class AutoMemoryQueue {
+  queue = [];
+  handler = null;
+  running = false;
+  activeCount = 0;
+  stats = {
+    pending: 0,
+    processing: 0,
+    processed: 0,
+    failed: 0,
+    dropped: 0
+  };
+  setHandler(handler) {
+    this.handler = handler;
+    if (!this.running)
+      this.startLoop();
+  }
+  enqueue(job) {
+    if (this.queue.length >= MAX_QUEUE_SIZE) {
+      this.queue.shift();
+      this.stats.dropped++;
+      this.stats.pending = Math.max(0, this.stats.pending - 1);
+    }
+    this.queue.push(job);
+    this.stats.pending++;
+    if (!this.running && this.handler)
+      this.startLoop();
+  }
+  getStats() {
+    return { ...this.stats, pending: this.queue.length };
+  }
+  startLoop() {
+    this.running = true;
+    this.loop();
+  }
+  async loop() {
+    while (this.queue.length > 0 || this.activeCount > 0) {
+      while (this.queue.length > 0 && this.activeCount < CONCURRENCY) {
+        const job = this.queue.shift();
+        if (!job)
+          break;
+        this.stats.pending = Math.max(0, this.stats.pending - 1);
+        this.activeCount++;
+        this.stats.processing = this.activeCount;
+        this.processJob(job);
+      }
+      await new Promise((r) => setImmediate(r));
+    }
+    this.running = false;
+  }
+  async processJob(job) {
+    if (!this.handler) {
+      this.activeCount--;
+      this.stats.processing = this.activeCount;
+      return;
+    }
+    try {
+      await this.handler(job);
+      this.stats.processed++;
+    } catch (err) {
+      this.stats.failed++;
+      console.error("[auto-memory-queue] job failed:", err);
+    } finally {
+      this.activeCount--;
+      this.stats.processing = this.activeCount;
+    }
+  }
 }
-function resolveConflict(local, remote, resolution) {
-  switch (resolution) {
-    case "prefer-local":
-      return "local";
-    case "prefer-remote":
-      return "remote";
-    case "prefer-newer":
-      return new Date(local.updated_at).getTime() >= new Date(remote.updated_at).getTime() ? "local" : "remote";
+var autoMemoryQueue = new AutoMemoryQueue;
+
+// src/lib/auto-memory.ts
+var DEDUP_SIMILARITY_THRESHOLD = 0.85;
+function isDuplicate(content, agentId, projectId) {
+  try {
+    const query = content.split(/\s+/).filter((w) => w.length > 3).slice(0, 10).join(" ");
+    if (!query)
+      return false;
+    const results = searchMemories(query, {
+      agent_id: agentId,
+      project_id: projectId,
+      limit: 3
+    });
+    if (results.length === 0)
+      return false;
+    const contentWords = new Set(content.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+    for (const result of results) {
+      const existingWords = new Set(result.memory.value.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+      if (contentWords.size === 0 || existingWords.size === 0)
+        continue;
+      const intersection = [...contentWords].filter((w) => existingWords.has(w)).length;
+      const union = new Set([...contentWords, ...existingWords]).size;
+      const similarity = intersection / union;
+      if (similarity >= DEDUP_SIMILARITY_THRESHOLD)
+        return true;
+    }
+    return false;
+  } catch {
+    return false;
   }
 }
-function pushMemories(agentName, agentId, projectId, db) {
-  const agentDir = getAgentSyncDir(agentName);
-  const memories = listMemories({
-    agent_id: agentId,
-    project_id: projectId,
-    status: "active",
-    limit: 1e4
-  }, db);
-  const outFile = join3(agentDir, "memories.json");
-  writeFileSync2(outFile, JSON.stringify(memories, null, 2), "utf-8");
-  if (memories.length > 0) {
-    const latest = memories.reduce((a, b) => new Date(a.updated_at).getTime() > new Date(b.updated_at).getTime() ? a : b);
-    setHighWaterMark(agentDir, latest.updated_at);
+async function linkEntitiesToMemory(memoryId, content, _agentId, projectId) {
+  const provider = providerRegistry.getAvailable();
+  if (!provider)
+    return;
+  try {
+    const { entities, relations } = await provider.extractEntities(content);
+    const entityIdMap = new Map;
+    for (const extracted of entities) {
+      if (extracted.confidence < 0.6)
+        continue;
+      try {
+        const existing = getEntityByName(extracted.name);
+        const entityId = existing ? existing.id : createEntity({
+          name: extracted.name,
+          type: extracted.type,
+          project_id: projectId
+        }).id;
+        entityIdMap.set(extracted.name, entityId);
+        linkEntityToMemory(entityId, memoryId, "subject");
+      } catch {}
+    }
+    for (const rel of relations) {
+      const fromId = entityIdMap.get(rel.from);
+      const toId = entityIdMap.get(rel.to);
+      if (!fromId || !toId)
+        continue;
+      try {
+        createRelation({
+          source_entity_id: fromId,
+          target_entity_id: toId,
+          relation_type: rel.type
+        });
+      } catch {}
+    }
+  } catch (err) {
+    console.error("[auto-memory] entity linking failed:", err);
   }
-  return memories.length;
 }
-function pullMemories(agentName, conflictResolution = "prefer-newer", db) {
-  const agentDir = getAgentSyncDir(agentName);
-  const inFile = join3(agentDir, "memories.json");
-  if (!existsSync3(inFile)) {
-    return { pulled: 0, conflicts: 0 };
+async function saveExtractedMemory(extracted, context) {
+  const minImportance = providerRegistry.getConfig().minImportance;
+  if (extracted.importance < minImportance)
+    return null;
+  if (!extracted.content.trim())
+    return null;
+  if (isDuplicate(extracted.content, context.agentId, context.projectId)) {
+    return null;
   }
-  const raw = readFileSync2(inFile, "utf-8");
-  let remoteMemories;
   try {
-    remoteMemories = JSON.parse(raw);
-  } catch {
-    return { pulled: 0, conflicts: 0 };
-  }
-  let pulled = 0;
-  let conflicts = 0;
-  for (const remote of remoteMemories) {
-    const localMemories = listMemories({
-      search: remote.key,
-      scope: remote.scope,
-      agent_id: remote.agent_id || undefined,
-      project_id: remote.project_id || undefined,
-      limit: 1
-    }, db);
-    const local = localMemories.find((m) => m.key === remote.key);
-    if (local) {
-      const winner = resolveConflict(local, remote, conflictResolution);
-      if (winner === "remote") {
-        createMemory({
-          key: remote.key,
-          value: remote.value,
-          category: remote.category,
-          scope: remote.scope,
-          summary: remote.summary || undefined,
-          tags: remote.tags,
-          importance: remote.importance,
-          source: remote.source,
-          agent_id: remote.agent_id || undefined,
-          project_id: remote.project_id || undefined,
-          session_id: remote.session_id || undefined,
-          metadata: remote.metadata,
-          expires_at: remote.expires_at || undefined
-        }, "merge", db);
-        pulled++;
+    const input = {
+      key: extracted.content.slice(0, 120).replace(/\s+/g, "-").toLowerCase(),
+      value: extracted.content,
+      category: extracted.category,
+      scope: extracted.suggestedScope,
+      importance: extracted.importance,
+      tags: [
+        ...extracted.tags,
+        "auto-extracted",
+        ...context.sessionId ? [`session:${context.sessionId}`] : []
+      ],
+      agent_id: context.agentId,
+      project_id: context.projectId,
+      session_id: context.sessionId,
+      metadata: {
+        reasoning: extracted.reasoning,
+        auto_extracted: true,
+        extracted_at: new Date().toISOString()
       }
-      conflicts++;
-    } else {
-      createMemory({
-        key: remote.key,
-        value: remote.value,
-        category: remote.category,
-        scope: remote.scope,
-        summary: remote.summary || undefined,
-        tags: remote.tags,
-        importance: remote.importance,
-        source: remote.source,
-        agent_id: remote.agent_id || undefined,
-        project_id: remote.project_id || undefined,
-        session_id: remote.session_id || undefined,
-        metadata: remote.metadata,
-        expires_at: remote.expires_at || undefined
-      }, "create", db);
-      pulled++;
-    }
+    };
+    const memory = createMemory(input, "merge");
+    return memory.id;
+  } catch (err) {
+    console.error("[auto-memory] saveExtractedMemory failed:", err);
+    return null;
   }
-  return { pulled, conflicts };
 }
-function syncMemories(agentName, direction = "both", options = {}) {
-  const result = {
-    pushed: 0,
-    pulled: 0,
-    conflicts: 0,
-    errors: []
+async function processJob(job) {
+  if (!providerRegistry.getConfig().enabled)
+    return;
+  const provider = providerRegistry.getAvailable();
+  if (!provider)
+    return;
+  const context = {
+    agentId: job.agentId,
+    projectId: job.projectId,
+    sessionId: job.sessionId
   };
+  let extracted = [];
   try {
-    if (direction === "push" || direction === "both") {
-      result.pushed = pushMemories(agentName, options.agent_id, options.project_id, options.db);
+    extracted = await provider.extractMemories(job.turn, context);
+  } catch {
+    const fallbacks = providerRegistry.getFallbacks();
+    for (const fallback of fallbacks) {
+      try {
+        extracted = await fallback.extractMemories(job.turn, context);
+        if (extracted.length > 0)
+          break;
+      } catch {
+        continue;
+      }
     }
-    if (direction === "pull" || direction === "both") {
-      const pullResult = pullMemories(agentName, options.conflict_resolution || "prefer-newer", options.db);
-      result.pulled = pullResult.pulled;
-      result.conflicts = pullResult.conflicts;
+  }
+  if (extracted.length === 0)
+    return;
+  for (const memory of extracted) {
+    const memoryId = await saveExtractedMemory(memory, context);
+    if (!memoryId)
+      continue;
+    if (providerRegistry.getConfig().autoEntityLink) {
+      linkEntitiesToMemory(memoryId, memory.content, job.agentId, job.projectId);
     }
-  } catch (e) {
-    result.errors.push(e instanceof Error ? e.message : String(e));
   }
-  return result;
 }
-var defaultSyncAgents = ["claude", "codex", "gemini"];
+autoMemoryQueue.setHandler(processJob);
+function processConversationTurn(turn, context, source = "turn") {
+  if (!turn?.trim())
+    return;
+  autoMemoryQueue.enqueue({
+    ...context,
+    turn,
+    timestamp: Date.now(),
+    source
+  });
+}
+function getAutoMemoryStats() {
+  return autoMemoryQueue.getStats();
+}
+function configureAutoMemory(config) {
+  providerRegistry.configure(config);
+}
+// src/lib/dedup.ts
+var DEFAULT_CONFIG2 = {
+  threshold: 0.8,
+  keepLonger: true
+};
+var _stats = { checked: 0, skipped: 0, updated: 0 };
+function getDedupStats() {
+  return { ..._stats };
+}
+function checkDuplicate(content, filter, config = DEFAULT_CONFIG2) {
+  _stats.checked++;
+  const query = content.split(/\s+/).filter((w) => w.length > 3).slice(0, 12).join(" ");
+  if (!query)
+    return "unique";
+  let results;
+  try {
+    results = searchMemories(query, { ...filter, limit: 5 });
+  } catch {
+    return "unique";
+  }
+  if (results.length === 0)
+    return "unique";
+  const contentWords = tokenize(content);
+  if (contentWords.size === 0)
+    return "unique";
+  for (const result of results) {
+    const existingWords = tokenize(result.memory.value);
+    if (existingWords.size === 0)
+      continue;
+    const similarity = jaccardSimilarity(contentWords, existingWords);
+    if (similarity >= config.threshold) {
+      if (config.keepLonger && content.length > result.memory.value.length) {
+        return { updateId: result.memory.id, existingContent: result.memory.value };
+      }
+      return "duplicate";
+    }
+  }
+  return "unique";
+}
+function dedup(content, filter, config = DEFAULT_CONFIG2) {
+  const result = checkDuplicate(content, filter, config);
+  if (result === "unique")
+    return "save";
+  if (result === "duplicate") {
+    _stats.skipped++;
+    return "skip";
+  }
+  try {
+    const existing = getMemory(result.updateId);
+    if (!existing)
+      return "save";
+    updateMemory(result.updateId, { value: content, version: existing.version });
+    _stats.updated++;
+  } catch {
+    return "save";
+  }
+  return "skip";
+}
+function tokenize(text) {
+  return new Set(text.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+}
+function jaccardSimilarity(a, b) {
+  if (a.size === 0 || b.size === 0)
+    return 0;
+  const intersection = [...a].filter((w) => b.has(w)).length;
+  const union = new Set([...a, ...b]).size;
+  return intersection / union;
+}
 export {
   withMemoryLock,
   uuid,
@@ -2670,13 +3363,16 @@ export {
   updateEntity,
   updateAgent,
   unlinkEntityFromMemory,
+  unfocus,
   touchMemory,
   touchAgent,
   syncMemories,
   shortUuid,
+  setFocus,
   setActiveProfile,
   searchMemories,
   runCleanup,
+  resolveProjectId,
   resolvePartialId,
   resetDatabase,
   releaseResourceLocks,
@@ -2686,8 +3382,10 @@ export {
   registerProject,
   registerAgent,
   redactSecrets,
+  providerRegistry,
+  processConversationTurn,
   parseRelationRow,
-  parseEntityRow,
+  parseEntityRow2 as parseEntityRow,
   now,
   mergeEntities,
   memoryLockId,
@@ -2701,6 +3399,7 @@ export {
   listAgents,
   listAgentLocks,
   linkEntityToMemory,
+  incrementRecallCount,
   getRelation,
   getRelatedEntities,
   getProject,
@@ -2709,17 +3408,20 @@ export {
   getMemory,
   getMemoriesForEntity,
   getMemoriesByKey,
+  getFocus,
   getEntityMemoryLinks,
   getEntityGraph,
   getEntityByName,
   getEntity,
   getEntitiesForMemory,
+  getDedupStats,
   getDbPath,
   getDatabase,
+  getAutoMemoryStats,
   getAgent,
   getActiveProfile,
+  focusFilterSQL,
   findPath,
-  extractEntities,
   enforceQuotas,
   deprioritizeStale,
   deleteRelation,
@@ -2727,10 +3429,12 @@ export {
   deleteMemory,
   deleteEntity,
   defaultSyncAgents,
+  dedup,
   createRelation,
   createMemory,
   createEntity,
   containsSecrets,
+  configureAutoMemory,
   closeDatabase,
   cleanExpiredMemories,
   cleanExpiredLocks,
@@ -2738,6 +3442,7 @@ export {
   checkLock,
   bulkLinkEntities,
   bulkDeleteMemories,
+  buildFocusFilter,
   archiveUnused,
   archiveStale,
   agentHoldsLock,