@hasna/mementos 0.6.0 → 0.7.0

package/dist/server/index.js

@@ -16,62 +16,68 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// src/server/index.ts
-import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname3, extname, join as join3, resolve as resolve3, sep } from "path";
-import { fileURLToPath } from "url";
-
 // src/types/index.ts
-class AgentConflictError extends Error {
-  conflict = true;
-  existing_id;
-  existing_name;
-  last_seen_at;
-  session_hint;
-  working_dir;
-  constructor(opts) {
-    const msg = `Agent "${opts.existing_name}" is already active (session hint: ${opts.session_hint ?? "unknown"}, last seen ${opts.last_seen_at}). Wait 30 minutes or use a different name.`;
-    super(msg);
-    this.name = "AgentConflictError";
-    this.existing_id = opts.existing_id;
-    this.existing_name = opts.existing_name;
-    this.last_seen_at = opts.last_seen_at;
-    this.session_hint = opts.session_hint;
-    this.working_dir = opts.working_dir ?? null;
-  }
-}
-class EntityNotFoundError extends Error {
-  constructor(id) {
-    super(`Entity not found: ${id}`);
-    this.name = "EntityNotFoundError";
-  }
-}
-
-class MemoryNotFoundError extends Error {
-  constructor(id) {
-    super(`Memory not found: ${id}`);
-    this.name = "MemoryNotFoundError";
-  }
-}
-
-class DuplicateMemoryError extends Error {
-  constructor(key, scope) {
-    super(`Memory already exists with key "${key}" in scope "${scope}"`);
-    this.name = "DuplicateMemoryError";
-  }
-}
-class VersionConflictError extends Error {
-  expected;
-  actual;
-  constructor(id, expected, actual) {
-    super(`Version conflict for memory ${id}: expected ${expected}, got ${actual}`);
-    this.name = "VersionConflictError";
-    this.expected = expected;
-    this.actual = actual;
-  }
-}
+var AgentConflictError, EntityNotFoundError, MemoryNotFoundError, DuplicateMemoryError, VersionConflictError;
+var init_types = __esm(() => {
+  AgentConflictError = class AgentConflictError extends Error {
+    conflict = true;
+    existing_id;
+    existing_name;
+    last_seen_at;
+    session_hint;
+    working_dir;
+    constructor(opts) {
+      const msg = `Agent "${opts.existing_name}" is already active (session hint: ${opts.session_hint ?? "unknown"}, last seen ${opts.last_seen_at}). Wait 30 minutes or use a different name.`;
+      super(msg);
+      this.name = "AgentConflictError";
+      this.existing_id = opts.existing_id;
+      this.existing_name = opts.existing_name;
+      this.last_seen_at = opts.last_seen_at;
+      this.session_hint = opts.session_hint;
+      this.working_dir = opts.working_dir ?? null;
+    }
+  };
+  EntityNotFoundError = class EntityNotFoundError extends Error {
+    constructor(id) {
+      super(`Entity not found: ${id}`);
+      this.name = "EntityNotFoundError";
+    }
+  };
+  MemoryNotFoundError = class MemoryNotFoundError extends Error {
+    constructor(id) {
+      super(`Memory not found: ${id}`);
+      this.name = "MemoryNotFoundError";
+    }
+  };
+  DuplicateMemoryError = class DuplicateMemoryError extends Error {
+    constructor(key, scope) {
+      super(`Memory already exists with key "${key}" in scope "${scope}"`);
+      this.name = "DuplicateMemoryError";
+    }
+  };
+  VersionConflictError = class VersionConflictError extends Error {
+    expected;
+    actual;
+    constructor(id, expected, actual) {
+      super(`Version conflict for memory ${id}: expected ${expected}, got ${actual}`);
+      this.name = "VersionConflictError";
+      this.expected = expected;
+      this.actual = actual;
+    }
+  };
+});
 
 // src/db/database.ts
 import { Database } from "bun:sqlite";
@@ -130,8 +136,48 @@ function ensureDir(filePath) {
     mkdirSync(dir, { recursive: true });
   }
 }
-var MIGRATIONS = [
-  `
+function getDatabase(dbPath) {
+  if (_db)
+    return _db;
+  const path = dbPath || getDbPath();
+  ensureDir(path);
+  _db = new Database(path, { create: true });
+  _db.run("PRAGMA journal_mode = WAL");
+  _db.run("PRAGMA busy_timeout = 5000");
+  _db.run("PRAGMA foreign_keys = ON");
+  runMigrations(_db);
+  return _db;
+}
+function runMigrations(db) {
+  try {
+    const result = db.query("SELECT MAX(id) as max_id FROM _migrations").get();
+    const currentLevel = result?.max_id ?? 0;
+    for (let i = currentLevel;i < MIGRATIONS.length; i++) {
+      try {
+        db.exec(MIGRATIONS[i]);
+      } catch {}
+    }
+  } catch {
+    for (const migration of MIGRATIONS) {
+      try {
+        db.exec(migration);
+      } catch {}
+    }
+  }
+}
+function now() {
+  return new Date().toISOString();
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function shortUuid() {
+  return crypto.randomUUID().slice(0, 8);
+}
+var MIGRATIONS, _db = null;
+var init_database = __esm(() => {
+  MIGRATIONS = [
+    `
   CREATE TABLE IF NOT EXISTS projects (
     id TEXT PRIMARY KEY,
     name TEXT NOT NULL,
@@ -218,7 +264,7 @@ var MIGRATIONS = [
 
   INSERT OR IGNORE INTO _migrations (id) VALUES (1);
   `,
-  `
+    `
   CREATE TABLE IF NOT EXISTS memory_versions (
     id TEXT PRIMARY KEY,
     memory_id TEXT NOT NULL,
@@ -240,7 +286,7 @@ var MIGRATIONS = [
 
   INSERT OR IGNORE INTO _migrations (id) VALUES (2);
   `,
-  `
+    `
   CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
     key, value, summary,
     content='memories',
@@ -264,7 +310,7 @@ var MIGRATIONS = [
 
   INSERT OR IGNORE INTO _migrations (id) VALUES (3);
   `,
-  `
+    `
   CREATE TABLE IF NOT EXISTS search_history (
     id TEXT PRIMARY KEY,
     query TEXT NOT NULL,
@@ -278,7 +324,7 @@ var MIGRATIONS = [
 
   INSERT OR IGNORE INTO _migrations (id) VALUES (4);
   `,
-  `
+    `
   CREATE TABLE IF NOT EXISTS entities (
     id TEXT PRIMARY KEY,
     name TEXT NOT NULL,
@@ -325,17 +371,17 @@ var MIGRATIONS = [
 
   INSERT OR IGNORE INTO _migrations (id) VALUES (5);
   `,
-  `
+    `
   ALTER TABLE agents ADD COLUMN active_project_id TEXT REFERENCES projects(id) ON DELETE SET NULL;
   CREATE INDEX IF NOT EXISTS idx_agents_active_project ON agents(active_project_id);
   INSERT OR IGNORE INTO _migrations (id) VALUES (6);
   `,
-  `
+    `
   ALTER TABLE agents ADD COLUMN session_id TEXT;
   CREATE INDEX IF NOT EXISTS idx_agents_session ON agents(session_id);
   INSERT OR IGNORE INTO _migrations (id) VALUES (7);
   `,
-  `
+    `
   CREATE TABLE IF NOT EXISTS resource_locks (
     id TEXT PRIMARY KEY,
     resource_type TEXT NOT NULL CHECK(resource_type IN ('project', 'memory', 'entity', 'agent', 'connector')),
@@ -352,71 +398,34 @@ var MIGRATIONS = [
   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);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS webhook_hooks (
+    id TEXT PRIMARY KEY,
+    type TEXT NOT NULL,
+    handler_url TEXT NOT NULL,
+    priority INTEGER NOT NULL DEFAULT 50,
+    blocking INTEGER NOT NULL DEFAULT 0,
+    agent_id TEXT,
+    project_id TEXT,
+    description TEXT,
+    enabled INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    invocation_count INTEGER NOT NULL DEFAULT 0,
+    failure_count INTEGER NOT NULL DEFAULT 0
+  );
+  CREATE INDEX IF NOT EXISTS idx_webhook_hooks_type ON webhook_hooks(type);
+  CREATE INDEX IF NOT EXISTS idx_webhook_hooks_enabled ON webhook_hooks(enabled);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (10);
   `
-];
-var _db = null;
-function getDatabase(dbPath) {
-  if (_db)
-    return _db;
-  const path = dbPath || getDbPath();
-  ensureDir(path);
-  _db = new Database(path, { create: true });
-  _db.run("PRAGMA journal_mode = WAL");
-  _db.run("PRAGMA busy_timeout = 5000");
-  _db.run("PRAGMA foreign_keys = ON");
-  runMigrations(_db);
-  return _db;
-}
-function runMigrations(db) {
-  try {
-    const result = db.query("SELECT MAX(id) as max_id FROM _migrations").get();
-    const currentLevel = result?.max_id ?? 0;
-    for (let i = currentLevel;i < MIGRATIONS.length; i++) {
-      try {
-        db.exec(MIGRATIONS[i]);
-      } catch {}
-    }
-  } catch {
-    for (const migration of MIGRATIONS) {
-      try {
-        db.exec(migration);
-      } catch {}
-    }
-  }
-}
-function now() {
-  return new Date().toISOString();
-}
-function uuid() {
-  return crypto.randomUUID();
-}
-function shortUuid() {
-  return crypto.randomUUID().slice(0, 8);
-}
+  ];
+});
 
 // src/lib/redact.ts
-var REDACTED = "[REDACTED]";
-var SECRET_PATTERNS = [
-  { name: "openai_key", pattern: /sk-[a-zA-Z0-9_-]{20,}/g },
-  { name: "anthropic_key", pattern: /sk-ant-[a-zA-Z0-9_-]{20,}/g },
-  { name: "generic_key", pattern: /(?:pk|tok|key|token|api[_-]?key)[_-][a-zA-Z0-9_-]{16,}/gi },
-  { name: "aws_key", pattern: /AKIA[A-Z0-9]{16}/g },
-  { name: "aws_secret", pattern: /(?<=AWS_SECRET_ACCESS_KEY\s*=\s*)[A-Za-z0-9/+=]{40}/g },
-  { name: "github_token", pattern: /gh[ps]_[a-zA-Z0-9]{36,}/g },
-  { name: "github_oauth", pattern: /gho_[a-zA-Z0-9]{36,}/g },
-  { name: "npm_token", pattern: /npm_[a-zA-Z0-9]{36,}/g },
-  { name: "bearer", pattern: /Bearer\s+[a-zA-Z0-9_\-.]{20,}/g },
-  { name: "conn_string", pattern: /(?:postgres|postgresql|mysql|mongodb|redis|amqp|mqtt):\/\/[^\s"'`]+@[^\s"'`]+/gi },
-  { name: "env_secret", pattern: /(?:SECRET|TOKEN|PASSWORD|PASSPHRASE|API_KEY|PRIVATE_KEY|AUTH|CREDENTIAL)[_A-Z]*\s*=\s*["']?[^\s"'\n]{8,}["']?/gi },
-  { name: "stripe_key", pattern: /(?:sk|pk|rk)_(?:test|live)_[a-zA-Z0-9]{20,}/g },
-  { name: "slack_token", pattern: /xox[bpras]-[a-zA-Z0-9-]{20,}/g },
-  { name: "jwt", pattern: /eyJ[a-zA-Z0-9_-]{10,}\.eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/g },
-  { name: "hex_secret", pattern: /(?<=(?:key|token|secret|password|hash)\s*[:=]\s*["']?)[0-9a-f]{32,}(?=["']?)/gi }
-];
 function redactSecrets(text) {
   let result = text;
   for (const { pattern } of SECRET_PATTERNS) {
@@ -425,6 +434,109 @@ function redactSecrets(text) {
   }
   return result;
 }
+var REDACTED = "[REDACTED]", SECRET_PATTERNS;
+var init_redact = __esm(() => {
+  SECRET_PATTERNS = [
+    { name: "openai_key", pattern: /sk-[a-zA-Z0-9_-]{20,}/g },
+    { name: "anthropic_key", pattern: /sk-ant-[a-zA-Z0-9_-]{20,}/g },
+    { name: "generic_key", pattern: /(?:pk|tok|key|token|api[_-]?key)[_-][a-zA-Z0-9_-]{16,}/gi },
+    { name: "aws_key", pattern: /AKIA[A-Z0-9]{16}/g },
+    { name: "aws_secret", pattern: /(?<=AWS_SECRET_ACCESS_KEY\s*=\s*)[A-Za-z0-9/+=]{40}/g },
+    { name: "github_token", pattern: /gh[ps]_[a-zA-Z0-9]{36,}/g },
+    { name: "github_oauth", pattern: /gho_[a-zA-Z0-9]{36,}/g },
+    { name: "npm_token", pattern: /npm_[a-zA-Z0-9]{36,}/g },
+    { name: "bearer", pattern: /Bearer\s+[a-zA-Z0-9_\-.]{20,}/g },
+    { name: "conn_string", pattern: /(?:postgres|postgresql|mysql|mongodb|redis|amqp|mqtt):\/\/[^\s"'`]+@[^\s"'`]+/gi },
+    { name: "env_secret", pattern: /(?:SECRET|TOKEN|PASSWORD|PASSPHRASE|API_KEY|PRIVATE_KEY|AUTH|CREDENTIAL)[_A-Z]*\s*=\s*["']?[^\s"'\n]{8,}["']?/gi },
+    { name: "stripe_key", pattern: /(?:sk|pk|rk)_(?:test|live)_[a-zA-Z0-9]{20,}/g },
+    { name: "slack_token", pattern: /xox[bpras]-[a-zA-Z0-9-]{20,}/g },
+    { name: "jwt", pattern: /eyJ[a-zA-Z0-9_-]{10,}\.eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/g },
+    { name: "hex_secret", pattern: /(?<=(?:key|token|secret|password|hash)\s*[:=]\s*["']?)[0-9a-f]{32,}(?=["']?)/gi }
+  ];
+});
+
+// src/lib/hooks.ts
+function generateHookId() {
+  return `hook_${++_idCounter}_${Date.now().toString(36)}`;
+}
+
+class HookRegistry {
+  hooks = new Map;
+  register(reg) {
+    const id = generateHookId();
+    const hook = {
+      ...reg,
+      id,
+      priority: reg.priority ?? 50
+    };
+    this.hooks.set(id, hook);
+    return id;
+  }
+  unregister(hookId) {
+    const hook = this.hooks.get(hookId);
+    if (!hook)
+      return false;
+    if (hook.builtin)
+      return false;
+    this.hooks.delete(hookId);
+    return true;
+  }
+  list(type) {
+    const all = [...this.hooks.values()];
+    if (!type)
+      return all;
+    return all.filter((h) => h.type === type);
+  }
+  async runHooks(type, context) {
+    const matching = this.getMatchingHooks(type, context);
+    if (matching.length === 0)
+      return true;
+    matching.sort((a, b) => a.priority - b.priority);
+    for (const hook of matching) {
+      if (hook.blocking) {
+        try {
+          const result = await hook.handler(context);
+          if (result === false)
+            return false;
+        } catch (err) {
+          console.error(`[hooks] blocking hook ${hook.id} (${type}) threw:`, err);
+        }
+      } else {
+        Promise.resolve().then(() => hook.handler(context)).catch((err) => console.error(`[hooks] non-blocking hook ${hook.id} (${type}) threw:`, err));
+      }
+    }
+    return true;
+  }
+  getMatchingHooks(type, context) {
+    const ctx = context;
+    return [...this.hooks.values()].filter((hook) => {
+      if (hook.type !== type)
+        return false;
+      if (hook.agentId && hook.agentId !== ctx.agentId)
+        return false;
+      if (hook.projectId && hook.projectId !== ctx.projectId)
+        return false;
+      return true;
+    });
+  }
+  stats() {
+    const all = [...this.hooks.values()];
+    const byType = {};
+    for (const hook of all) {
+      byType[hook.type] = (byType[hook.type] ?? 0) + 1;
+    }
+    return {
+      total: all.length,
+      byType,
+      blocking: all.filter((h) => h.blocking).length,
+      nonBlocking: all.filter((h) => !h.blocking).length
+    };
+  }
+}
+var _idCounter = 0, hookRegistry;
+var init_hooks = __esm(() => {
+  hookRegistry = new HookRegistry;
+});
 
 // src/db/entity-memories.ts
 function parseEntityMemoryRow(row) {
@@ -475,8 +587,28 @@ function getEntityMemoryLinks(entityId, memoryId, db) {
   const rows = d.query(sql).all(...params);
   return rows.map(parseEntityMemoryRow);
 }
+var init_entity_memories = __esm(() => {
+  init_database();
+  init_memories();
+});
 
 // src/db/memories.ts
+var exports_memories = {};
+__export(exports_memories, {
+  updateMemory: () => updateMemory,
+  touchMemory: () => touchMemory,
+  parseMemoryRow: () => parseMemoryRow,
+  listMemories: () => listMemories,
+  incrementRecallCount: () => incrementRecallCount,
+  getMemoryVersions: () => getMemoryVersions,
+  getMemoryByKey: () => getMemoryByKey,
+  getMemory: () => getMemory,
+  getMemoriesByKey: () => getMemoriesByKey,
+  deleteMemory: () => deleteMemory,
+  createMemory: () => createMemory,
+  cleanExpiredMemories: () => cleanExpiredMemories,
+  bulkDeleteMemories: () => bulkDeleteMemories
+});
 function runEntityExtraction(_memory, _projectId, _d) {}
 function parseMemoryRow(row) {
   return {
@@ -579,9 +711,15 @@ function createMemory(input, dedupeMode = "merge", db) {
     insertTag.run(id, tag);
   }
   const memory = getMemory(id, d);
-  try {
-    runEntityExtraction(memory, input.project_id, d);
-  } catch {}
+  runEntityExtraction(memory, input.project_id, d);
+  hookRegistry.runHooks("PostMemorySave", {
+    memory,
+    wasUpdated: false,
+    agentId: input.agent_id,
+    projectId: input.project_id,
+    sessionId: input.session_id,
+    timestamp: Date.now()
+  });
   return memory;
 }
 function getMemory(id, db) {
@@ -591,6 +729,52 @@ function getMemory(id, db) {
     return null;
   return parseMemoryRow(row);
 }
+function getMemoryByKey(key, scope, agentId, projectId, sessionId, 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);
+  }
+  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 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);
+}
 function listMemories(filter, db) {
   const d = db || getDatabase();
   const conditions = [];
@@ -759,26 +943,65 @@ function updateMemory(id, input, db) {
   params.push(id);
   d.run(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`, params);
   const updated = getMemory(id, d);
-  try {
-    if (input.value !== undefined) {
+  if (input.value !== undefined) {
+    try {
       const oldLinks = getEntityMemoryLinks(undefined, updated.id, d);
       for (const link of oldLinks) {
         unlinkEntityFromMemory(link.entity_id, updated.id, d);
       }
-      runEntityExtraction(updated, existing.project_id || undefined, d);
-    }
-  } catch {}
+    } catch {}
+  }
+  hookRegistry.runHooks("PostMemoryUpdate", {
+    memory: updated,
+    previousValue: existing.value,
+    agentId: existing.agent_id ?? undefined,
+    projectId: existing.project_id ?? undefined,
+    sessionId: existing.session_id ?? undefined,
+    timestamp: Date.now()
+  });
   return updated;
 }
 function deleteMemory(id, db) {
   const d = db || getDatabase();
   const result = d.run("DELETE FROM memories WHERE id = ?", [id]);
+  if (result.changes > 0) {
+    hookRegistry.runHooks("PostMemoryDelete", {
+      memoryId: id,
+      timestamp: Date.now()
+    });
+  }
   return result.changes > 0;
 }
+function bulkDeleteMemories(ids, db) {
+  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]);
 }
+function incrementRecallCount(id, db) {
+  const d = db || getDatabase();
+  try {
+    d.run("UPDATE memories SET recall_count = recall_count + 1, access_count = access_count + 1, accessed_at = ? WHERE id = ?", [now(), id]);
+    const row = d.query("SELECT recall_count, importance FROM memories WHERE id = ?").get(id);
+    if (!row)
+      return;
+    const promotions = Math.floor(row.recall_count / RECALL_PROMOTE_THRESHOLD);
+    if (promotions > 0 && row.importance < 10) {
+      const newImportance = Math.min(10, row.importance + 1);
+      d.run("UPDATE memories SET importance = ? WHERE id = ? AND importance < 10", [newImportance, id]);
+    }
+  } catch {}
+}
 function cleanExpiredMemories(db) {
   const d = db || getDatabase();
   const timestamp = now();
@@ -811,994 +1034,595 @@ function getMemoryVersions(memoryId, db) {
     return [];
   }
 }
+var RECALL_PROMOTE_THRESHOLD = 3;
+var init_memories = __esm(() => {
+  init_types();
+  init_database();
+  init_redact();
+  init_hooks();
+  init_entity_memories();
+});
 
-// src/db/agents.ts
-var CONFLICT_WINDOW_MS = 30 * 60 * 1000;
-function parseAgentRow(row) {
+// src/db/entities.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) {
+function createEntity(input, 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);
+  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 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]);
+    const sets = ["updated_at = ?"];
+    const params = [timestamp];
+    if (input.description !== undefined) {
+      sets.push("description = ?");
+      params.push(input.description);
     }
-    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]);
+    if (input.metadata !== undefined) {
+      sets.push("metadata = ?");
+      params.push(metadataJson);
     }
-    return getAgent(existingId, d);
+    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 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 getAgent(idOrName, 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;
+  d.run(`INSERT INTO entities (id, name, type, description, metadata, project_id, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.name,
+    input.type,
+    input.description || null,
+    metadataJson,
+    input.project_id || null,
+    timestamp,
+    timestamp
+  ]);
+  hookRegistry.runHooks("PostEntityCreate", {
+    entityId: id,
+    name: input.name,
+    entityType: input.type,
+    projectId: input.project_id,
+    timestamp: Date.now()
+  });
+  return getEntity(id, d);
 }
-function listAgents(db) {
+function getEntity(id, db) {
   const d = db || getDatabase();
-  const rows = d.query("SELECT * FROM agents ORDER BY last_seen_at DESC").all();
-  return rows.map(parseAgentRow);
+  const row = d.query("SELECT * FROM entities WHERE id = ?").get(id);
+  if (!row)
+    throw new EntityNotFoundError(id);
+  return parseEntityRow(row);
 }
-function listAgentsByProject(projectId, db) {
+function getEntityByName(name, type, projectId, 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);
+  let sql = "SELECT * FROM entities WHERE name = ?";
+  const params = [name];
+  if (type) {
+    sql += " AND type = ?";
+    params.push(type);
+  }
+  if (projectId !== undefined) {
+    sql += " AND project_id = ?";
+    params.push(projectId);
+  }
+  sql += " LIMIT 1";
+  const row = d.query(sql).get(...params);
+  if (!row)
+    return null;
+  return parseEntityRow(row);
 }
-function updateAgent(id, updates, db) {
+function listEntities(filter = {}, 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 conditions = [];
+  const params = [];
+  if (filter.type) {
+    conditions.push("type = ?");
+    params.push(filter.type);
   }
-  if (updates.description !== undefined) {
-    d.run("UPDATE agents SET description = ? WHERE id = ?", [updates.description, agent.id]);
+  if (filter.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filter.project_id);
   }
-  if (updates.role !== undefined) {
-    d.run("UPDATE agents SET role = ? WHERE id = ?", [updates.role, agent.id]);
+  if (filter.search) {
+    conditions.push("(name LIKE ? OR description LIKE ?)");
+    const term = `%${filter.search}%`;
+    params.push(term, term);
   }
-  if (updates.metadata !== undefined) {
-    d.run("UPDATE agents SET metadata = ? WHERE id = ?", [JSON.stringify(updates.metadata), agent.id]);
+  let sql = "SELECT * FROM entities";
+  if (conditions.length > 0) {
+    sql += ` WHERE ${conditions.join(" AND ")}`;
   }
-  if ("active_project_id" in updates) {
-    d.run("UPDATE agents SET active_project_id = ? WHERE id = ?", [updates.active_project_id ?? null, agent.id]);
+  sql += " ORDER BY updated_at DESC";
+  if (filter.limit) {
+    sql += " LIMIT ?";
+    params.push(filter.limit);
   }
-  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [timestamp, agent.id]);
-  return getAgent(agent.id, d);
-}
-
-// 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"]
-  };
+  if (filter.offset) {
+    sql += " OFFSET ?";
+    params.push(filter.offset);
+  }
+  const rows = d.query(sql).all(...params);
+  return rows.map(parseEntityRow);
 }
-function acquireLock(agentId, resourceType, resourceId, lockType = "exclusive", ttlSeconds = 300, db) {
+function updateEntity(id, input, 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 });
+  const existing = d.query("SELECT id FROM entities WHERE id = ?").get(id);
+  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 (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;
-    }
+  if (input.type !== undefined) {
+    sets.push("type = ?");
+    params.push(input.type);
   }
-  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 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 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);
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  params.push(id);
+  d.run(`UPDATE entities SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getEntity(id, d);
 }
-function listAgentLocks(agentId, db) {
+function deleteEntity(id, 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);
+  const result = d.run("DELETE FROM entities WHERE id = ?", [id]);
+  if (result.changes === 0)
+    throw new EntityNotFoundError(id);
 }
-function cleanExpiredLocks(db) {
+function mergeEntities(sourceId, targetId, db) {
   const d = db || getDatabase();
-  const result = d.run("DELETE FROM resource_locks WHERE expires_at <= datetime('now')");
-  return result.changes;
+  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);
 }
+var init_entities = __esm(() => {
+  init_database();
+  init_types();
+  init_hooks();
+});
 
-// src/db/projects.ts
-function parseProjectRow(row) {
+// src/lib/search.ts
+function parseMemoryRow2(row) {
   return {
     id: row["id"],
-    name: row["name"],
-    path: row["path"],
-    description: row["description"] || null,
-    memory_prefix: row["memory_prefix"] || null,
+    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 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 preprocessQuery(query) {
+  let q = query.trim();
+  q = q.replace(/\s+/g, " ");
+  q = q.normalize("NFC");
+  return q;
 }
-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 escapeLikePattern(s) {
+  return s.replace(/%/g, "\\%").replace(/_/g, "\\_");
 }
-function listProjects(db) {
-  const d = db || getDatabase();
-  const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
-  return rows.map(parseProjectRow);
+function removeStopWords(tokens) {
+  if (tokens.length <= 1)
+    return tokens;
+  const filtered = tokens.filter((t) => !STOP_WORDS.has(t.toLowerCase()));
+  return filtered.length > 0 ? filtered : tokens;
 }
-
-// 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";
-function findFileWalkingUp(filename) {
-  let dir = process.cwd();
-  while (true) {
-    const candidate = join2(dir, filename);
-    if (existsSync2(candidate)) {
-      return candidate;
+function extractHighlights(memory, queryLower) {
+  const highlights = [];
+  const tokens = queryLower.split(/\s+/).filter(Boolean);
+  for (const field of ["key", "value", "summary"]) {
+    const text = field === "summary" ? memory.summary : memory[field];
+    if (!text)
+      continue;
+    const textLower = text.toLowerCase();
+    const searchTerms = [queryLower, ...tokens].filter(Boolean);
+    for (const term of searchTerms) {
+      const idx = textLower.indexOf(term);
+      if (idx !== -1) {
+        const start = Math.max(0, idx - 30);
+        const end = Math.min(text.length, idx + term.length + 30);
+        const prefix = start > 0 ? "..." : "";
+        const suffix = end < text.length ? "..." : "";
+        highlights.push({
+          field,
+          snippet: prefix + text.slice(start, end) + suffix
+        });
+        break;
+      }
     }
-    const parent = dirname2(dir);
-    if (parent === dir) {
-      return null;
+  }
+  for (const tag of memory.tags) {
+    if (tag.toLowerCase().includes(queryLower) || tokens.some((t) => tag.toLowerCase().includes(t))) {
+      highlights.push({ field: "tag", snippet: tag });
     }
-    dir = parent;
   }
+  return highlights;
 }
-function findGitRoot2() {
-  let dir = process.cwd();
-  while (true) {
-    if (existsSync2(join2(dir, ".git"))) {
-      return dir;
+function determineMatchType(memory, queryLower) {
+  if (memory.key.toLowerCase() === queryLower)
+    return "exact";
+  if (memory.tags.some((t) => t.toLowerCase() === queryLower))
+    return "tag";
+  if (memory.tags.some((t) => t.toLowerCase().includes(queryLower)))
+    return "tag";
+  return "fuzzy";
+}
+function computeScore(memory, queryLower) {
+  const fieldScores = [];
+  const keyLower = memory.key.toLowerCase();
+  if (keyLower === queryLower) {
+    fieldScores.push(10);
+  } else if (keyLower.includes(queryLower)) {
+    fieldScores.push(7);
+  }
+  if (memory.tags.some((t) => t.toLowerCase() === queryLower)) {
+    fieldScores.push(6);
+  } else if (memory.tags.some((t) => t.toLowerCase().includes(queryLower))) {
+    fieldScores.push(3);
+  }
+  if (memory.summary && memory.summary.toLowerCase().includes(queryLower)) {
+    fieldScores.push(4);
+  }
+  if (memory.value.toLowerCase().includes(queryLower)) {
+    fieldScores.push(3);
+  }
+  const metadataStr = JSON.stringify(memory.metadata).toLowerCase();
+  if (metadataStr !== "{}" && metadataStr.includes(queryLower)) {
+    fieldScores.push(2);
+  }
+  fieldScores.sort((a, b) => b - a);
+  const diminishingMultipliers = [1, 0.5, 0.25, 0.15, 0.15];
+  let score = 0;
+  for (let i = 0;i < fieldScores.length; i++) {
+    score += fieldScores[i] * (diminishingMultipliers[i] ?? 0.15);
+  }
+  const { phrases } = extractQuotedPhrases(queryLower);
+  for (const phrase of phrases) {
+    if (keyLower.includes(phrase))
+      score += 8;
+    if (memory.value.toLowerCase().includes(phrase))
+      score += 5;
+    if (memory.summary && memory.summary.toLowerCase().includes(phrase))
+      score += 4;
+  }
+  const { remainder } = extractQuotedPhrases(queryLower);
+  const tokens = removeStopWords(remainder.split(/\s+/).filter(Boolean));
+  if (tokens.length > 1) {
+    let tokenScore = 0;
+    for (const token of tokens) {
+      if (keyLower === token) {
+        tokenScore += 10 / tokens.length;
+      } else if (keyLower.includes(token)) {
+        tokenScore += 7 / tokens.length;
+      }
+      if (memory.tags.some((t) => t.toLowerCase() === token)) {
+        tokenScore += 6 / tokens.length;
+      } else if (memory.tags.some((t) => t.toLowerCase().includes(token))) {
+        tokenScore += 3 / tokens.length;
+      }
+      if (memory.summary && memory.summary.toLowerCase().includes(token)) {
+        tokenScore += 4 / tokens.length;
+      }
+      if (memory.value.toLowerCase().includes(token)) {
+        tokenScore += 3 / tokens.length;
+      }
+      if (metadataStr !== "{}" && metadataStr.includes(token)) {
+        tokenScore += 2 / tokens.length;
+      }
     }
-    const parent = dirname2(dir);
-    if (parent === dir) {
-      return null;
+    if (score > 0) {
+      score += tokenScore * 0.3;
+    } else {
+      score += tokenScore;
     }
-    dir = parent;
   }
+  return score;
 }
-function profilesDir() {
-  return join2(homedir(), ".mementos", "profiles");
+function extractQuotedPhrases(query) {
+  const phrases = [];
+  const remainder = query.replace(/"([^"]+)"/g, (_match, phrase) => {
+    phrases.push(phrase);
+    return "";
+  });
+  return { phrases, remainder: remainder.trim() };
 }
-function globalConfigPath() {
-  return join2(homedir(), ".mementos", "config.json");
+function escapeFts5Query(query) {
+  const { phrases, remainder } = extractQuotedPhrases(query);
+  const parts = [];
+  for (const phrase of phrases) {
+    parts.push(`"${phrase.replace(/"/g, '""')}"`);
+  }
+  const tokens = removeStopWords(remainder.split(/\s+/).filter(Boolean));
+  for (const t of tokens) {
+    parts.push(`"${t.replace(/"/g, '""')}"`);
+  }
+  return parts.join(" ");
 }
-function readGlobalConfig() {
-  const p = globalConfigPath();
-  if (!existsSync2(p))
-    return {};
+function hasFts5Table(d) {
   try {
-    return JSON.parse(readFileSync(p, "utf-8"));
+    const row = d.query("SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'").get();
+    return !!row;
   } catch {
-    return {};
+    return false;
   }
 }
-function getActiveProfile() {
-  const envProfile = process.env["MEMENTOS_PROFILE"];
-  if (envProfile)
-    return envProfile.trim();
-  const cfg = readGlobalConfig();
-  return cfg["active_profile"] || null;
-}
-function listProfiles() {
-  const dir = profilesDir();
-  if (!existsSync2(dir))
-    return [];
-  return readdirSync(dir).filter((f) => f.endsWith(".db")).map((f) => basename(f, ".db")).sort();
-}
-function getDbPath2() {
-  const envDbPath = process.env["MEMENTOS_DB_PATH"];
-  if (envDbPath) {
-    const resolved = resolve2(envDbPath);
-    ensureDir2(dirname2(resolved));
-    return resolved;
-  }
-  const profile = getActiveProfile();
-  if (profile) {
-    const profilePath = join2(profilesDir(), `${profile}.db`);
-    ensureDir2(dirname2(profilePath));
-    return profilePath;
+function buildFilterConditions(filter) {
+  const conditions = [];
+  const params = [];
+  conditions.push("m.status = 'active'");
+  conditions.push("(m.expires_at IS NULL OR m.expires_at >= datetime('now'))");
+  if (!filter)
+    return { conditions, params };
+  if (filter.scope) {
+    if (Array.isArray(filter.scope)) {
+      conditions.push(`m.scope IN (${filter.scope.map(() => "?").join(",")})`);
+      params.push(...filter.scope);
+    } else {
+      conditions.push("m.scope = ?");
+      params.push(filter.scope);
+    }
   }
-  const dbScope = process.env["MEMENTOS_DB_SCOPE"];
-  if (dbScope === "project") {
-    const gitRoot = findGitRoot2();
-    if (gitRoot) {
-      const dbPath = join2(gitRoot, ".mementos", "mementos.db");
-      ensureDir2(dirname2(dbPath));
-      return dbPath;
+  if (filter.category) {
+    if (Array.isArray(filter.category)) {
+      conditions.push(`m.category IN (${filter.category.map(() => "?").join(",")})`);
+      params.push(...filter.category);
+    } else {
+      conditions.push("m.category = ?");
+      params.push(filter.category);
     }
   }
-  const found = findFileWalkingUp(join2(".mementos", "mementos.db"));
-  if (found) {
-    return found;
-  }
-  const fallback = join2(homedir(), ".mementos", "mementos.db");
-  ensureDir2(dirname2(fallback));
-  return fallback;
-}
-function ensureDir2(dir) {
-  if (!existsSync2(dir)) {
-    mkdirSync2(dir, { recursive: true });
-  }
-}
-
-// src/db/entities.ts
-function parseEntityRow(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);
+  if (filter.source) {
+    if (Array.isArray(filter.source)) {
+      conditions.push(`m.source IN (${filter.source.map(() => "?").join(",")})`);
+      params.push(...filter.source);
+    } else {
+      conditions.push("m.source = ?");
+      params.push(filter.source);
     }
-    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 (?, ?, ?, ?, ?, ?, ?, ?)`, [
-    id,
-    input.name,
-    input.type,
-    input.description || null,
-    metadataJson,
-    input.project_id || null,
-    timestamp,
-    timestamp
-  ]);
-  return getEntity(id, d);
-}
-function getEntity(id, db) {
-  const d = db || getDatabase();
-  const row = d.query("SELECT * FROM entities WHERE id = ?").get(id);
-  if (!row)
-    throw new EntityNotFoundError(id);
-  return parseEntityRow(row);
-}
-function getEntityByName(name, type, projectId, db) {
-  const d = db || getDatabase();
-  let sql = "SELECT * FROM entities WHERE name = ?";
-  const params = [name];
-  if (type) {
-    sql += " AND type = ?";
-    params.push(type);
   }
-  if (projectId !== undefined) {
-    sql += " AND project_id = ?";
-    params.push(projectId);
-  }
-  sql += " LIMIT 1";
-  const row = d.query(sql).get(...params);
-  if (!row)
-    return null;
-  return parseEntityRow(row);
-}
-function listEntities(filter = {}, db) {
-  const d = db || getDatabase();
-  const conditions = [];
-  const params = [];
-  if (filter.type) {
-    conditions.push("type = ?");
-    params.push(filter.type);
+  if (filter.status) {
+    conditions.shift();
+    if (Array.isArray(filter.status)) {
+      conditions.push(`m.status IN (${filter.status.map(() => "?").join(",")})`);
+      params.push(...filter.status);
+    } else {
+      conditions.push("m.status = ?");
+      params.push(filter.status);
+    }
   }
   if (filter.project_id) {
-    conditions.push("project_id = ?");
+    conditions.push("m.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);
+  if (filter.agent_id) {
+    conditions.push("m.agent_id = ?");
+    params.push(filter.agent_id);
   }
-  let sql = "SELECT * FROM entities";
-  if (conditions.length > 0) {
-    sql += ` WHERE ${conditions.join(" AND ")}`;
+  if (filter.session_id) {
+    conditions.push("m.session_id = ?");
+    params.push(filter.session_id);
   }
-  sql += " ORDER BY updated_at DESC";
-  if (filter.limit) {
-    sql += " LIMIT ?";
-    params.push(filter.limit);
+  if (filter.min_importance) {
+    conditions.push("m.importance >= ?");
+    params.push(filter.min_importance);
   }
-  if (filter.offset) {
-    sql += " OFFSET ?";
-    params.push(filter.offset);
+  if (filter.pinned !== undefined) {
+    conditions.push("m.pinned = ?");
+    params.push(filter.pinned ? 1 : 0);
   }
-  const rows = d.query(sql).all(...params);
-  return rows.map(parseEntityRow);
-}
-function updateEntity(id, input, db) {
-  const d = db || getDatabase();
-  const existing = d.query("SELECT id FROM entities WHERE id = ?").get(id);
-  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 (filter.tags && filter.tags.length > 0) {
+    for (const tag of filter.tags) {
+      conditions.push("m.id IN (SELECT memory_id FROM memory_tags WHERE tag = ?)");
+      params.push(tag);
+    }
   }
-  if (input.type !== undefined) {
-    sets.push("type = ?");
-    params.push(input.type);
+  return { conditions, params };
+}
+function searchWithFts5(d, query, queryLower, filter, graphBoostedIds) {
+  const ftsQuery = escapeFts5Query(query);
+  if (!ftsQuery)
+    return null;
+  try {
+    const { conditions, params } = buildFilterConditions(filter);
+    const queryParam = `%${query}%`;
+    const ftsCondition = `(m.rowid IN (SELECT f.rowid FROM memories_fts f WHERE memories_fts MATCH ?) ` + `OR m.id IN (SELECT memory_id FROM memory_tags WHERE tag LIKE ?) ` + `OR m.metadata LIKE ?)`;
+    const allConditions = [ftsCondition, ...conditions];
+    const allParams = [ftsQuery, queryParam, queryParam, ...params];
+    const candidateSql = `SELECT m.* FROM memories m WHERE ${allConditions.join(" AND ")}`;
+    const rows = d.query(candidateSql).all(...allParams);
+    return scoreResults(rows, queryLower, graphBoostedIds);
+  } catch {
+    return null;
   }
-  if (input.description !== undefined) {
-    sets.push("description = ?");
-    params.push(input.description);
+}
+function searchWithLike(d, query, queryLower, filter, graphBoostedIds) {
+  const { conditions, params } = buildFilterConditions(filter);
+  const rawTokens = query.trim().split(/\s+/).filter(Boolean);
+  const tokens = removeStopWords(rawTokens);
+  const escapedQuery = escapeLikePattern(query);
+  const likePatterns = [`%${escapedQuery}%`];
+  if (tokens.length > 1) {
+    for (const t of tokens)
+      likePatterns.push(`%${escapeLikePattern(t)}%`);
   }
-  if (input.metadata !== undefined) {
-    sets.push("metadata = ?");
-    params.push(JSON.stringify(input.metadata));
+  const fieldClauses = [];
+  for (const pattern of likePatterns) {
+    fieldClauses.push("m.key LIKE ? ESCAPE '\\'");
+    params.push(pattern);
+    fieldClauses.push("m.value LIKE ? ESCAPE '\\'");
+    params.push(pattern);
+    fieldClauses.push("m.summary LIKE ? ESCAPE '\\'");
+    params.push(pattern);
+    fieldClauses.push("m.metadata LIKE ? ESCAPE '\\'");
+    params.push(pattern);
+    fieldClauses.push("m.id IN (SELECT memory_id FROM memory_tags WHERE tag LIKE ? ESCAPE '\\')");
+    params.push(pattern);
   }
-  params.push(id);
-  d.run(`UPDATE entities SET ${sets.join(", ")} WHERE id = ?`, params);
-  return getEntity(id, d);
+  conditions.push(`(${fieldClauses.join(" OR ")})`);
+  const sql = `SELECT DISTINCT m.* FROM memories m WHERE ${conditions.join(" AND ")}`;
+  const rows = d.query(sql).all(...params);
+  return scoreResults(rows, queryLower, graphBoostedIds);
 }
-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 generateTrigrams(s) {
+  const lower = s.toLowerCase();
+  const trigrams = new Set;
+  for (let i = 0;i <= lower.length - 3; i++) {
+    trigrams.add(lower.slice(i, i + 3));
+  }
+  return trigrams;
 }
-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);
+function trigramSimilarity(a, b) {
+  const triA = generateTrigrams(a);
+  const triB = generateTrigrams(b);
+  if (triA.size === 0 || triB.size === 0)
+    return 0;
+  let intersection = 0;
+  for (const t of triA) {
+    if (triB.has(t))
+      intersection++;
+  }
+  const union = triA.size + triB.size - intersection;
+  return union === 0 ? 0 : intersection / union;
 }
-
-// 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, "\\_");
-}
-var STOP_WORDS = new Set([
-  "a",
-  "an",
-  "the",
-  "is",
-  "are",
-  "was",
-  "were",
-  "be",
-  "been",
-  "being",
-  "have",
-  "has",
-  "had",
-  "do",
-  "does",
-  "did",
-  "will",
-  "would",
-  "could",
-  "should",
-  "may",
-  "might",
-  "shall",
-  "can",
-  "need",
-  "dare",
-  "ought",
-  "used",
-  "to",
-  "of",
-  "in",
-  "for",
-  "on",
-  "with",
-  "at",
-  "by",
-  "from",
-  "as",
-  "into",
-  "through",
-  "during",
-  "before",
-  "after",
-  "above",
-  "below",
-  "between",
-  "out",
-  "off",
-  "over",
-  "under",
-  "again",
-  "further",
-  "then",
-  "once",
-  "here",
-  "there",
-  "when",
-  "where",
-  "why",
-  "how",
-  "all",
-  "each",
-  "every",
-  "both",
-  "few",
-  "more",
-  "most",
-  "other",
-  "some",
-  "such",
-  "no",
-  "not",
-  "only",
-  "own",
-  "same",
-  "so",
-  "than",
-  "too",
-  "very",
-  "just",
-  "because",
-  "but",
-  "and",
-  "or",
-  "if",
-  "while",
-  "that",
-  "this",
-  "it"
-]);
-function removeStopWords(tokens) {
-  if (tokens.length <= 1)
-    return tokens;
-  const filtered = tokens.filter((t) => !STOP_WORDS.has(t.toLowerCase()));
-  return filtered.length > 0 ? filtered : tokens;
-}
-function extractHighlights(memory, queryLower) {
-  const highlights = [];
-  const tokens = queryLower.split(/\s+/).filter(Boolean);
-  for (const field of ["key", "value", "summary"]) {
-    const text = field === "summary" ? memory.summary : memory[field];
-    if (!text)
-      continue;
-    const textLower = text.toLowerCase();
-    const searchTerms = [queryLower, ...tokens].filter(Boolean);
-    for (const term of searchTerms) {
-      const idx = textLower.indexOf(term);
-      if (idx !== -1) {
-        const start = Math.max(0, idx - 30);
-        const end = Math.min(text.length, idx + term.length + 30);
-        const prefix = start > 0 ? "..." : "";
-        const suffix = end < text.length ? "..." : "";
-        highlights.push({
-          field,
-          snippet: prefix + text.slice(start, end) + suffix
-        });
-        break;
-      }
+function searchWithFuzzy(d, query, filter, graphBoostedIds) {
+  const { conditions, params } = buildFilterConditions(filter);
+  const sql = `SELECT m.* FROM memories m WHERE ${conditions.join(" AND ")}`;
+  const rows = d.query(sql).all(...params);
+  const MIN_SIMILARITY = 0.3;
+  const results = [];
+  for (const row of rows) {
+    const memory = parseMemoryRow2(row);
+    let bestSimilarity = 0;
+    bestSimilarity = Math.max(bestSimilarity, trigramSimilarity(query, memory.key));
+    bestSimilarity = Math.max(bestSimilarity, trigramSimilarity(query, memory.value.slice(0, 200)));
+    if (memory.summary) {
+      bestSimilarity = Math.max(bestSimilarity, trigramSimilarity(query, memory.summary));
     }
-  }
-  for (const tag of memory.tags) {
-    if (tag.toLowerCase().includes(queryLower) || tokens.some((t) => tag.toLowerCase().includes(t))) {
-      highlights.push({ field: "tag", snippet: tag });
+    for (const tag of memory.tags) {
+      bestSimilarity = Math.max(bestSimilarity, trigramSimilarity(query, tag));
+    }
+    if (bestSimilarity >= MIN_SIMILARITY) {
+      const graphBoost = graphBoostedIds?.has(memory.id) ? 2 : 0;
+      const score = bestSimilarity * 5 * memory.importance / 10 + graphBoost;
+      results.push({ memory, score, match_type: "fuzzy" });
     }
   }
-  return highlights;
-}
-function determineMatchType(memory, queryLower) {
-  if (memory.key.toLowerCase() === queryLower)
-    return "exact";
-  if (memory.tags.some((t) => t.toLowerCase() === queryLower))
-    return "tag";
-  if (memory.tags.some((t) => t.toLowerCase().includes(queryLower)))
-    return "tag";
-  return "fuzzy";
+  results.sort((a, b) => b.score - a.score);
+  return results;
 }
-function computeScore(memory, queryLower) {
-  const fieldScores = [];
-  const keyLower = memory.key.toLowerCase();
-  if (keyLower === queryLower) {
-    fieldScores.push(10);
-  } else if (keyLower.includes(queryLower)) {
-    fieldScores.push(7);
-  }
-  if (memory.tags.some((t) => t.toLowerCase() === queryLower)) {
-    fieldScores.push(6);
-  } else if (memory.tags.some((t) => t.toLowerCase().includes(queryLower))) {
-    fieldScores.push(3);
-  }
-  if (memory.summary && memory.summary.toLowerCase().includes(queryLower)) {
-    fieldScores.push(4);
-  }
-  if (memory.value.toLowerCase().includes(queryLower)) {
-    fieldScores.push(3);
-  }
-  const metadataStr = JSON.stringify(memory.metadata).toLowerCase();
-  if (metadataStr !== "{}" && metadataStr.includes(queryLower)) {
-    fieldScores.push(2);
-  }
-  fieldScores.sort((a, b) => b - a);
-  const diminishingMultipliers = [1, 0.5, 0.25, 0.15, 0.15];
-  let score = 0;
-  for (let i = 0;i < fieldScores.length; i++) {
-    score += fieldScores[i] * (diminishingMultipliers[i] ?? 0.15);
-  }
-  const { phrases } = extractQuotedPhrases(queryLower);
-  for (const phrase of phrases) {
-    if (keyLower.includes(phrase))
-      score += 8;
-    if (memory.value.toLowerCase().includes(phrase))
-      score += 5;
-    if (memory.summary && memory.summary.toLowerCase().includes(phrase))
-      score += 4;
-  }
-  const { remainder } = extractQuotedPhrases(queryLower);
-  const tokens = removeStopWords(remainder.split(/\s+/).filter(Boolean));
-  if (tokens.length > 1) {
-    let tokenScore = 0;
-    for (const token of tokens) {
-      if (keyLower === token) {
-        tokenScore += 10 / tokens.length;
-      } else if (keyLower.includes(token)) {
-        tokenScore += 7 / tokens.length;
-      }
-      if (memory.tags.some((t) => t.toLowerCase() === token)) {
-        tokenScore += 6 / tokens.length;
-      } else if (memory.tags.some((t) => t.toLowerCase().includes(token))) {
-        tokenScore += 3 / tokens.length;
-      }
-      if (memory.summary && memory.summary.toLowerCase().includes(token)) {
-        tokenScore += 4 / tokens.length;
-      }
-      if (memory.value.toLowerCase().includes(token)) {
-        tokenScore += 3 / tokens.length;
-      }
-      if (metadataStr !== "{}" && metadataStr.includes(token)) {
-        tokenScore += 2 / tokens.length;
-      }
+function getGraphBoostedMemoryIds(query, d) {
+  const boostedIds = new Set;
+  try {
+    const matchingEntities = listEntities({ search: query, limit: 10 }, d);
+    const exactMatch = getEntityByName(query, undefined, undefined, d);
+    if (exactMatch && !matchingEntities.find((e) => e.id === exactMatch.id)) {
+      matchingEntities.push(exactMatch);
     }
-    if (score > 0) {
-      score += tokenScore * 0.3;
-    } else {
-      score += tokenScore;
+    for (const entity of matchingEntities) {
+      const memories = getMemoriesForEntity(entity.id, d);
+      for (const mem of memories) {
+        boostedIds.add(mem.id);
+      }
     }
-  }
-  return score;
-}
-function extractQuotedPhrases(query) {
-  const phrases = [];
-  const remainder = query.replace(/"([^"]+)"/g, (_match, phrase) => {
-    phrases.push(phrase);
-    return "";
-  });
-  return { phrases, remainder: remainder.trim() };
+  } catch {}
+  return boostedIds;
 }
-function escapeFts5Query(query) {
-  const { phrases, remainder } = extractQuotedPhrases(query);
-  const parts = [];
-  for (const phrase of phrases) {
-    parts.push(`"${phrase.replace(/"/g, '""')}"`);
-  }
-  const tokens = removeStopWords(remainder.split(/\s+/).filter(Boolean));
-  for (const t of tokens) {
-    parts.push(`"${t.replace(/"/g, '""')}"`);
-  }
-  return parts.join(" ");
+function computeRecencyBoost(memory) {
+  if (memory.pinned)
+    return 1;
+  const mostRecent = memory.accessed_at || memory.updated_at;
+  if (!mostRecent)
+    return 0;
+  const daysSinceAccess = (Date.now() - Date.parse(mostRecent)) / (1000 * 60 * 60 * 24);
+  return Math.max(0, 1 - daysSinceAccess / 30);
 }
-function hasFts5Table(d) {
-  try {
-    const row = d.query("SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'").get();
-    return !!row;
-  } catch {
-    return false;
+function scoreResults(rows, queryLower, graphBoostedIds) {
+  const scored = [];
+  for (const row of rows) {
+    const memory = parseMemoryRow2(row);
+    const rawScore = computeScore(memory, queryLower);
+    if (rawScore === 0)
+      continue;
+    const weightedScore = rawScore * memory.importance / 10;
+    const recencyBoost = computeRecencyBoost(memory);
+    const accessBoost = Math.min(memory.access_count / 20, 0.2);
+    const graphBoost = graphBoostedIds?.has(memory.id) ? 2 : 0;
+    const finalScore = (weightedScore + graphBoost) * (1 + recencyBoost * 0.3) * (1 + accessBoost);
+    const matchType = determineMatchType(memory, queryLower);
+    scored.push({
+      memory,
+      score: finalScore,
+      match_type: matchType,
+      highlights: extractHighlights(memory, queryLower)
+    });
   }
+  scored.sort((a, b) => {
+    if (b.score !== a.score)
+      return b.score - a.score;
+    return b.memory.importance - a.memory.importance;
+  });
+  return scored;
 }
-function buildFilterConditions(filter) {
-  const conditions = [];
-  const params = [];
-  conditions.push("m.status = 'active'");
-  conditions.push("(m.expires_at IS NULL OR m.expires_at >= datetime('now'))");
-  if (!filter)
-    return { conditions, params };
-  if (filter.scope) {
-    if (Array.isArray(filter.scope)) {
-      conditions.push(`m.scope IN (${filter.scope.map(() => "?").join(",")})`);
-      params.push(...filter.scope);
+function searchMemories(query, filter, db) {
+  const d = db || getDatabase();
+  query = preprocessQuery(query);
+  if (!query)
+    return [];
+  const queryLower = query.toLowerCase();
+  const graphBoostedIds = getGraphBoostedMemoryIds(query, d);
+  let scored;
+  if (hasFts5Table(d)) {
+    const ftsResult = searchWithFts5(d, query, queryLower, filter, graphBoostedIds);
+    if (ftsResult !== null) {
+      scored = ftsResult;
     } else {
-      conditions.push("m.scope = ?");
-      params.push(filter.scope);
-    }
-  }
-  if (filter.category) {
-    if (Array.isArray(filter.category)) {
-      conditions.push(`m.category IN (${filter.category.map(() => "?").join(",")})`);
-      params.push(...filter.category);
-    } else {
-      conditions.push("m.category = ?");
-      params.push(filter.category);
-    }
-  }
-  if (filter.source) {
-    if (Array.isArray(filter.source)) {
-      conditions.push(`m.source IN (${filter.source.map(() => "?").join(",")})`);
-      params.push(...filter.source);
-    } else {
-      conditions.push("m.source = ?");
-      params.push(filter.source);
-    }
-  }
-  if (filter.status) {
-    conditions.shift();
-    if (Array.isArray(filter.status)) {
-      conditions.push(`m.status IN (${filter.status.map(() => "?").join(",")})`);
-      params.push(...filter.status);
-    } else {
-      conditions.push("m.status = ?");
-      params.push(filter.status);
-    }
-  }
-  if (filter.project_id) {
-    conditions.push("m.project_id = ?");
-    params.push(filter.project_id);
-  }
-  if (filter.agent_id) {
-    conditions.push("m.agent_id = ?");
-    params.push(filter.agent_id);
-  }
-  if (filter.session_id) {
-    conditions.push("m.session_id = ?");
-    params.push(filter.session_id);
-  }
-  if (filter.min_importance) {
-    conditions.push("m.importance >= ?");
-    params.push(filter.min_importance);
-  }
-  if (filter.pinned !== undefined) {
-    conditions.push("m.pinned = ?");
-    params.push(filter.pinned ? 1 : 0);
-  }
-  if (filter.tags && filter.tags.length > 0) {
-    for (const tag of filter.tags) {
-      conditions.push("m.id IN (SELECT memory_id FROM memory_tags WHERE tag = ?)");
-      params.push(tag);
-    }
-  }
-  return { conditions, params };
-}
-function searchWithFts5(d, query, queryLower, filter, graphBoostedIds) {
-  const ftsQuery = escapeFts5Query(query);
-  if (!ftsQuery)
-    return null;
-  try {
-    const { conditions, params } = buildFilterConditions(filter);
-    const queryParam = `%${query}%`;
-    const ftsCondition = `(m.rowid IN (SELECT f.rowid FROM memories_fts f WHERE memories_fts MATCH ?) ` + `OR m.id IN (SELECT memory_id FROM memory_tags WHERE tag LIKE ?) ` + `OR m.metadata LIKE ?)`;
-    const allConditions = [ftsCondition, ...conditions];
-    const allParams = [ftsQuery, queryParam, queryParam, ...params];
-    const candidateSql = `SELECT m.* FROM memories m WHERE ${allConditions.join(" AND ")}`;
-    const rows = d.query(candidateSql).all(...allParams);
-    return scoreResults(rows, queryLower, graphBoostedIds);
-  } catch {
-    return null;
-  }
-}
-function searchWithLike(d, query, queryLower, filter, graphBoostedIds) {
-  const { conditions, params } = buildFilterConditions(filter);
-  const rawTokens = query.trim().split(/\s+/).filter(Boolean);
-  const tokens = removeStopWords(rawTokens);
-  const escapedQuery = escapeLikePattern(query);
-  const likePatterns = [`%${escapedQuery}%`];
-  if (tokens.length > 1) {
-    for (const t of tokens)
-      likePatterns.push(`%${escapeLikePattern(t)}%`);
-  }
-  const fieldClauses = [];
-  for (const pattern of likePatterns) {
-    fieldClauses.push("m.key LIKE ? ESCAPE '\\'");
-    params.push(pattern);
-    fieldClauses.push("m.value LIKE ? ESCAPE '\\'");
-    params.push(pattern);
-    fieldClauses.push("m.summary LIKE ? ESCAPE '\\'");
-    params.push(pattern);
-    fieldClauses.push("m.metadata LIKE ? ESCAPE '\\'");
-    params.push(pattern);
-    fieldClauses.push("m.id IN (SELECT memory_id FROM memory_tags WHERE tag LIKE ? ESCAPE '\\')");
-    params.push(pattern);
-  }
-  conditions.push(`(${fieldClauses.join(" OR ")})`);
-  const sql = `SELECT DISTINCT m.* FROM memories m WHERE ${conditions.join(" AND ")}`;
-  const rows = d.query(sql).all(...params);
-  return scoreResults(rows, queryLower, graphBoostedIds);
-}
-function generateTrigrams(s) {
-  const lower = s.toLowerCase();
-  const trigrams = new Set;
-  for (let i = 0;i <= lower.length - 3; i++) {
-    trigrams.add(lower.slice(i, i + 3));
-  }
-  return trigrams;
-}
-function trigramSimilarity(a, b) {
-  const triA = generateTrigrams(a);
-  const triB = generateTrigrams(b);
-  if (triA.size === 0 || triB.size === 0)
-    return 0;
-  let intersection = 0;
-  for (const t of triA) {
-    if (triB.has(t))
-      intersection++;
-  }
-  const union = triA.size + triB.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-function searchWithFuzzy(d, query, filter, graphBoostedIds) {
-  const { conditions, params } = buildFilterConditions(filter);
-  const sql = `SELECT m.* FROM memories m WHERE ${conditions.join(" AND ")}`;
-  const rows = d.query(sql).all(...params);
-  const MIN_SIMILARITY = 0.3;
-  const results = [];
-  for (const row of rows) {
-    const memory = parseMemoryRow2(row);
-    let bestSimilarity = 0;
-    bestSimilarity = Math.max(bestSimilarity, trigramSimilarity(query, memory.key));
-    bestSimilarity = Math.max(bestSimilarity, trigramSimilarity(query, memory.value.slice(0, 200)));
-    if (memory.summary) {
-      bestSimilarity = Math.max(bestSimilarity, trigramSimilarity(query, memory.summary));
-    }
-    for (const tag of memory.tags) {
-      bestSimilarity = Math.max(bestSimilarity, trigramSimilarity(query, tag));
-    }
-    if (bestSimilarity >= MIN_SIMILARITY) {
-      const graphBoost = graphBoostedIds?.has(memory.id) ? 2 : 0;
-      const score = bestSimilarity * 5 * memory.importance / 10 + graphBoost;
-      results.push({ memory, score, match_type: "fuzzy" });
-    }
-  }
-  results.sort((a, b) => b.score - a.score);
-  return results;
-}
-function getGraphBoostedMemoryIds(query, d) {
-  const boostedIds = new Set;
-  try {
-    const matchingEntities = listEntities({ search: query, limit: 10 }, d);
-    const exactMatch = getEntityByName(query, undefined, undefined, d);
-    if (exactMatch && !matchingEntities.find((e) => e.id === exactMatch.id)) {
-      matchingEntities.push(exactMatch);
-    }
-    for (const entity of matchingEntities) {
-      const memories = getMemoriesForEntity(entity.id, d);
-      for (const mem of memories) {
-        boostedIds.add(mem.id);
-      }
-    }
-  } catch {}
-  return boostedIds;
-}
-function computeRecencyBoost(memory) {
-  if (memory.pinned)
-    return 1;
-  const mostRecent = memory.accessed_at || memory.updated_at;
-  if (!mostRecent)
-    return 0;
-  const daysSinceAccess = (Date.now() - Date.parse(mostRecent)) / (1000 * 60 * 60 * 24);
-  return Math.max(0, 1 - daysSinceAccess / 30);
-}
-function scoreResults(rows, queryLower, graphBoostedIds) {
-  const scored = [];
-  for (const row of rows) {
-    const memory = parseMemoryRow2(row);
-    const rawScore = computeScore(memory, queryLower);
-    if (rawScore === 0)
-      continue;
-    const weightedScore = rawScore * memory.importance / 10;
-    const recencyBoost = computeRecencyBoost(memory);
-    const accessBoost = Math.min(memory.access_count / 20, 0.2);
-    const graphBoost = graphBoostedIds?.has(memory.id) ? 2 : 0;
-    const finalScore = (weightedScore + graphBoost) * (1 + recencyBoost * 0.3) * (1 + accessBoost);
-    const matchType = determineMatchType(memory, queryLower);
-    scored.push({
-      memory,
-      score: finalScore,
-      match_type: matchType,
-      highlights: extractHighlights(memory, queryLower)
-    });
-  }
-  scored.sort((a, b) => {
-    if (b.score !== a.score)
-      return b.score - a.score;
-    return b.memory.importance - a.memory.importance;
-  });
-  return scored;
-}
-function searchMemories(query, filter, db) {
-  const d = db || getDatabase();
-  query = preprocessQuery(query);
-  if (!query)
-    return [];
-  const queryLower = query.toLowerCase();
-  const graphBoostedIds = getGraphBoostedMemoryIds(query, d);
-  let scored;
-  if (hasFts5Table(d)) {
-    const ftsResult = searchWithFts5(d, query, queryLower, filter, graphBoostedIds);
-    if (ftsResult !== null) {
-      scored = ftsResult;
-    } else {
-      scored = searchWithLike(d, query, queryLower, filter, graphBoostedIds);
+      scored = searchWithLike(d, query, queryLower, filter, graphBoostedIds);
     }
   } else {
     scored = searchWithLike(d, query, queryLower, filter, graphBoostedIds);
@@ -1837,6 +1661,103 @@ 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 {}
 }
+var STOP_WORDS;
+var init_search = __esm(() => {
+  init_database();
+  init_entities();
+  init_entity_memories();
+  STOP_WORDS = new Set([
+    "a",
+    "an",
+    "the",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "shall",
+    "can",
+    "need",
+    "dare",
+    "ought",
+    "used",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "between",
+    "out",
+    "off",
+    "over",
+    "under",
+    "again",
+    "further",
+    "then",
+    "once",
+    "here",
+    "there",
+    "when",
+    "where",
+    "why",
+    "how",
+    "all",
+    "each",
+    "every",
+    "both",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "no",
+    "not",
+    "only",
+    "own",
+    "same",
+    "so",
+    "than",
+    "too",
+    "very",
+    "just",
+    "because",
+    "but",
+    "and",
+    "or",
+    "if",
+    "while",
+    "that",
+    "this",
+    "it"
+  ]);
+});
 
 // src/db/relations.ts
 function parseRelationRow(row) {
@@ -1874,7 +1795,15 @@ function createRelation(input, db) {
      DO UPDATE SET weight = excluded.weight, metadata = excluded.metadata`, [id, input.source_entity_id, input.target_entity_id, input.relation_type, weight, metadata, timestamp]);
   const row = d.query(`SELECT * FROM relations
        WHERE source_entity_id = ? AND target_entity_id = ? AND relation_type = ?`).get(input.source_entity_id, input.target_entity_id, input.relation_type);
-  return parseRelationRow(row);
+  const relation = parseRelationRow(row);
+  hookRegistry.runHooks("PostRelationCreate", {
+    relationId: relation.id,
+    sourceEntityId: relation.source_entity_id,
+    targetEntityId: relation.target_entity_id,
+    relationType: relation.relation_type,
+    timestamp: Date.now()
+  });
+  return relation;
 }
 function getRelation(id, db) {
   const d = db || getDatabase();
@@ -1961,732 +1890,1318 @@ function findPath(fromEntityId, toEntityId, maxDepth = 5, db) {
   }
   return entities.length > 0 ? entities : null;
 }
+var init_relations = __esm(() => {
+  init_database();
+  init_hooks();
+});
 
-// src/lib/duration.ts
-var UNIT_MS = {
-  s: 1000,
-  m: 60000,
-  h: 3600000,
-  d: 86400000,
-  w: 604800000
-};
-var DURATION_RE = /^(\d+[smhdw])+$/;
-var SEGMENT_RE = /(\d+)([smhdw])/g;
-function parseDuration(input) {
-  if (typeof input === "number")
-    return input;
-  const trimmed = input.trim();
-  if (trimmed === "")
-    throw new Error("Invalid duration: empty string");
-  if (/^\d+$/.test(trimmed)) {
-    return parseInt(trimmed, 10);
+// src/lib/providers/base.ts
+class BaseProvider {
+  config;
+  constructor(config) {
+    this.config = config;
   }
-  if (!DURATION_RE.test(trimmed)) {
-    throw new Error(`Invalid duration format: "${trimmed}". Use combinations of Ns, Nm, Nh, Nd, Nw (e.g. "1d12h", "30m") or plain milliseconds.`);
+  parseJSON(raw) {
+    try {
+      const cleaned = raw.replace(/^```(?:json)?\s*/m, "").replace(/\s*```$/m, "").trim();
+      return JSON.parse(cleaned);
+    } catch {
+      return null;
+    }
   }
-  let total = 0;
-  let match;
-  SEGMENT_RE.lastIndex = 0;
-  while ((match = SEGMENT_RE.exec(trimmed)) !== null) {
-    const value = parseInt(match[1], 10);
-    const unit = match[2];
-    total += value * UNIT_MS[unit];
+  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 DEFAULT_AUTO_MEMORY_CONFIG, 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.`, 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.`, 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.`, 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" }
+  ]
+}`;
+var init_base = __esm(() => {
+  DEFAULT_AUTO_MEMORY_CONFIG = {
+    provider: "anthropic",
+    model: "claude-haiku-4-5",
+    enabled: true,
+    minImportance: 4,
+    autoEntityLink: true,
+    fallback: ["cerebras", "openai"]
+  };
+});
+
+// src/lib/providers/anthropic.ts
+var ANTHROPIC_MODELS, AnthropicProvider;
+var init_anthropic = __esm(() => {
+  init_base();
+  ANTHROPIC_MODELS = {
+    default: "claude-haiku-4-5",
+    premium: "claude-sonnet-4-5"
+  };
+  AnthropicProvider = 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
+var OpenAICompatProvider;
+var init_openai_compat = __esm(() => {
+  init_base();
+  OpenAICompatProvider = 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);
+      }
+    }
+  };
+});
+
+// src/lib/providers/openai.ts
+var OPENAI_MODELS, OpenAIProvider;
+var init_openai = __esm(() => {
+  init_openai_compat();
+  OPENAI_MODELS = {
+    default: "gpt-4.1-nano",
+    mini: "gpt-4.1-mini",
+    full: "gpt-4.1"
+  };
+  OpenAIProvider = 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
+      });
+    }
+  };
+});
+
+// src/lib/providers/cerebras.ts
+var CEREBRAS_MODELS, CerebrasProvider;
+var init_cerebras = __esm(() => {
+  init_openai_compat();
+  CEREBRAS_MODELS = {
+    default: "llama-3.3-70b",
+    fast: "llama3.1-8b"
+  };
+  CerebrasProvider = 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
+      });
+    }
+  };
+});
+
+// src/lib/providers/grok.ts
+var GROK_MODELS, GrokProvider;
+var init_grok = __esm(() => {
+  init_openai_compat();
+  GROK_MODELS = {
+    default: "grok-3-mini",
+    premium: "grok-3"
+  };
+  GrokProvider = 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
+      });
+    }
+  };
+});
+
+// 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;
+    }
+  }
+}
+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" });
+    }
+  }
+  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 });
+}
+var providerRegistry;
+var init_registry = __esm(() => {
+  init_anthropic();
+  init_openai();
+  init_cerebras();
+  init_grok();
+  init_base();
+  providerRegistry = new ProviderRegistry;
+  autoConfigureFromEnv();
+});
+
+// src/lib/auto-memory-queue.ts
+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;
   }
-  if (total === 0) {
-    throw new Error(`Invalid duration: "${trimmed}" resolves to 0ms`);
+  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;
+    }
   }
-  return total;
 }
-var FORMAT_UNITS = [
-  ["w", UNIT_MS["w"]],
-  ["d", UNIT_MS["d"]],
-  ["h", UNIT_MS["h"]],
-  ["m", UNIT_MS["m"]],
-  ["s", UNIT_MS["s"]]
-];
-
-// 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"]
-};
+var MAX_QUEUE_SIZE = 100, CONCURRENCY = 3, autoMemoryQueue;
+var init_auto_memory_queue = __esm(() => {
+  autoMemoryQueue = new AutoMemoryQueue;
+});
 
-class BaseProvider {
-  config;
-  constructor(config) {
-    this.config = config;
+// src/lib/auto-memory.ts
+var exports_auto_memory = {};
+__export(exports_auto_memory, {
+  processConversationTurn: () => processConversationTurn,
+  getAutoMemoryStats: () => getAutoMemoryStats,
+  configureAutoMemory: () => configureAutoMemory
+});
+function isDuplicate(content, agentId, projectId) {
+  try {
+    const query = content.split(/\s+/).filter((w) => w.length > 3).slice(0, 10).join(" ");
+    if (!query)
+      return false;
+    const results = searchMemories(query, {
+      agent_id: agentId,
+      project_id: projectId,
+      limit: 3
+    });
+    if (results.length === 0)
+      return false;
+    const contentWords = new Set(content.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+    for (const result of results) {
+      const existingWords = new Set(result.memory.value.toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+      if (contentWords.size === 0 || existingWords.size === 0)
+        continue;
+      const intersection = [...contentWords].filter((w) => existingWords.has(w)).length;
+      const union = new Set([...contentWords, ...existingWords]).size;
+      const similarity = intersection / union;
+      if (similarity >= DEDUP_SIMILARITY_THRESHOLD)
+        return true;
+    }
+    return false;
+  } catch {
+    return false;
   }
-  parseJSON(raw) {
-    try {
-      const cleaned = raw.replace(/^```(?:json)?\s*/m, "").replace(/\s*```$/m, "").trim();
-      return JSON.parse(cleaned);
-    } catch {
-      return null;
+}
+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);
   }
-  clampImportance(value) {
-    const n = Number(value);
-    if (isNaN(n))
-      return 5;
-    return Math.max(0, Math.min(10, Math.round(n)));
+}
+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;
   }
-  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
+  try {
+    const input = {
+      key: extracted.content.slice(0, 120).replace(/\s+/g, "-").toLowerCase(),
+      value: extracted.content,
+      category: extracted.category,
+      scope: extracted.suggestedScope,
+      importance: extracted.importance,
+      tags: [
+        ...extracted.tags,
+        "auto-extracted",
+        ...context.sessionId ? [`session:${context.sessionId}`] : []
+      ],
+      agent_id: context.agentId,
+      project_id: context.projectId,
+      session_id: context.sessionId,
+      metadata: {
+        reasoning: extracted.reasoning,
+        auto_extracted: true,
+        extracted_at: new Date().toISOString()
+      }
     };
+    const memory = createMemory(input, "merge");
+    return memory.id;
+  } catch (err) {
+    console.error("[auto-memory] saveExtractedMemory failed:", err);
+    return null;
   }
 }
-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" }
-  ]
-}`;
+async function processJob(job) {
+  if (!providerRegistry.getConfig().enabled)
+    return;
+  const provider = providerRegistry.getAvailable();
+  if (!provider)
+    return;
+  const context = {
+    agentId: job.agentId,
+    projectId: job.projectId,
+    sessionId: job.sessionId
+  };
+  let extracted = [];
+  try {
+    extracted = await provider.extractMemories(job.turn, context);
+  } catch {
+    const fallbacks = providerRegistry.getFallbacks();
+    for (const fallback of fallbacks) {
+      try {
+        extracted = await fallback.extractMemories(job.turn, context);
+        if (extracted.length > 0)
+          break;
+      } catch {
+        continue;
+      }
+    }
+  }
+  if (extracted.length === 0)
+    return;
+  for (const memory of extracted) {
+    const memoryId = await saveExtractedMemory(memory, context);
+    if (!memoryId)
+      continue;
+    if (providerRegistry.getConfig().autoEntityLink) {
+      linkEntitiesToMemory(memoryId, memory.content, job.agentId, job.projectId);
+    }
+  }
+}
+function processConversationTurn(turn, context, source = "turn") {
+  if (!turn?.trim())
+    return;
+  autoMemoryQueue.enqueue({
+    ...context,
+    turn,
+    timestamp: Date.now(),
+    source
+  });
+}
+function getAutoMemoryStats() {
+  return autoMemoryQueue.getStats();
+}
+function configureAutoMemory(config) {
+  providerRegistry.configure(config);
+}
+var DEDUP_SIMILARITY_THRESHOLD = 0.85;
+var init_auto_memory = __esm(() => {
+  init_memories();
+  init_search();
+  init_entities();
+  init_relations();
+  init_entity_memories();
+  init_registry();
+  init_auto_memory_queue();
+  autoMemoryQueue.setHandler(processJob);
+});
 
-// src/lib/providers/anthropic.ts
-var ANTHROPIC_MODELS = {
-  default: "claude-haiku-4-5",
-  premium: "claude-sonnet-4-5"
-};
+// src/server/index.ts
+init_memories();
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname3, extname, join as join3, resolve as resolve3, sep } from "path";
+import { fileURLToPath } from "url";
 
-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 [];
+// src/db/agents.ts
+init_types();
+init_database();
+var CONFLICT_WINDOW_MS = 30 * 60 * 1000;
+function parseAgentRow(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    session_id: row["session_id"] || null,
+    description: row["description"] || null,
+    role: row["role"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    active_project_id: row["active_project_id"] || null,
+    created_at: row["created_at"],
+    last_seen_at: row["last_seen_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
+        });
+      }
     }
-  }
-  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;
+    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]);
     }
-  }
-  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;
+    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);
   }
-  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 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 getAgent(idOrName, 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;
+}
+function listAgents(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM agents ORDER BY last_seen_at DESC").all();
+  return rows.map(parseAgentRow);
+}
+function listAgentsByProject(projectId, 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);
+}
+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}`);
       }
-      const data = await res.json();
-      return data.content?.[0]?.text ?? "";
-    } finally {
-      clearTimeout(timeout);
+      d.run("UPDATE agents SET name = ? WHERE id = ?", [normalizedNewName, agent.id]);
     }
   }
+  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/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 [];
-    }
+// src/db/locks.ts
+init_database();
+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 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 });
   }
-  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;
+  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;
     }
   }
-  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?
+  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 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 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 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;
+}
 
-"${content}"
+// src/db/projects.ts
+init_database();
+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;
+}
+function listProjects(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
+  return rows.map(parseProjectRow);
+}
 
-Return only a number 0-10.`);
-      return this.clampImportance(response.trim());
-    } catch {
-      return 5;
+// 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";
+function findFileWalkingUp(filename) {
+  let dir = process.cwd();
+  while (true) {
+    const candidate = join2(dir, filename);
+    if (existsSync2(candidate)) {
+      return candidate;
     }
-  }
-  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)));
-      }
+    const parent = dirname2(dir);
+    if (parent === dir) {
+      return null;
     }
-    throw lastError ?? new Error("Unknown error");
+    dir = parent;
   }
-  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 findGitRoot2() {
+  let dir = process.cwd();
+  while (true) {
+    if (existsSync2(join2(dir, ".git"))) {
+      return dir;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) {
+      return null;
     }
+    dir = parent;
   }
 }
-
-// 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
-    });
-  }
+function profilesDir() {
+  return join2(homedir(), ".mementos", "profiles");
 }
-
-// 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
-    });
-  }
+function globalConfigPath() {
+  return join2(homedir(), ".mementos", "config.json");
 }
-
-// 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
-    });
+function readGlobalConfig() {
+  const p = globalConfigPath();
+  if (!existsSync2(p))
+    return {};
+  try {
+    return JSON.parse(readFileSync(p, "utf-8"));
+  } catch {
+    return {};
   }
 }
-
-// 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();
+function getActiveProfile() {
+  const envProfile = process.env["MEMENTOS_PROFILE"];
+  if (envProfile)
+    return envProfile.trim();
+  const cfg = readGlobalConfig();
+  return cfg["active_profile"] || null;
+}
+function listProfiles() {
+  const dir = profilesDir();
+  if (!existsSync2(dir))
+    return [];
+  return readdirSync(dir).filter((f) => f.endsWith(".db")).map((f) => basename(f, ".db")).sort();
+}
+function getDbPath2() {
+  const envDbPath = process.env["MEMENTOS_DB_PATH"];
+  if (envDbPath) {
+    const resolved = resolve2(envDbPath);
+    ensureDir2(dirname2(resolved));
+    return resolved;
   }
-  getConfig() {
-    return this.config;
+  const profile = getActiveProfile();
+  if (profile) {
+    const profilePath = join2(profilesDir(), `${profile}.db`);
+    ensureDir2(dirname2(profilePath));
+    return profilePath;
   }
-  getPrimary() {
-    return this.getProvider(this.config.provider);
+  const dbScope = process.env["MEMENTOS_DB_SCOPE"];
+  if (dbScope === "project") {
+    const gitRoot = findGitRoot2();
+    if (gitRoot) {
+      const dbPath = join2(gitRoot, ".mementos", "mementos.db");
+      ensureDir2(dirname2(dbPath));
+      return dbPath;
+    }
   }
-  getFallbacks() {
-    const fallbackNames = this.config.fallback ?? [];
-    return fallbackNames.filter((n) => n !== this.config.provider).map((n) => this.getProvider(n)).filter((p) => p !== null);
+  const found = findFileWalkingUp(join2(".mementos", "mementos.db"));
+  if (found) {
+    return found;
   }
-  getAvailable() {
-    const primary = this.getPrimary();
-    if (primary)
-      return primary;
-    const fallbacks = this.getFallbacks();
-    return fallbacks[0] ?? null;
+  const fallback = join2(homedir(), ".mementos", "mementos.db");
+  ensureDir2(dirname2(fallback));
+  return fallback;
+}
+function ensureDir2(dir) {
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
   }
-  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;
+}
+
+// src/server/index.ts
+init_database();
+init_search();
+init_types();
+init_entities();
+init_relations();
+init_entity_memories();
+
+// src/lib/duration.ts
+var UNIT_MS = {
+  s: 1000,
+  m: 60000,
+  h: 3600000,
+  d: 86400000,
+  w: 604800000
+};
+var DURATION_RE = /^(\d+[smhdw])+$/;
+var SEGMENT_RE = /(\d+)([smhdw])/g;
+function parseDuration(input) {
+  if (typeof input === "number")
+    return input;
+  const trimmed = input.trim();
+  if (trimmed === "")
+    throw new Error("Invalid duration: empty string");
+  if (/^\d+$/.test(trimmed)) {
+    return parseInt(trimmed, 10);
   }
-  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;
+  if (!DURATION_RE.test(trimmed)) {
+    throw new Error(`Invalid duration format: "${trimmed}". Use combinations of Ns, Nm, Nh, Nd, Nw (e.g. "1d12h", "30m") or plain milliseconds.`);
   }
-  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;
-    }
+  let total = 0;
+  let match;
+  SEGMENT_RE.lastIndex = 0;
+  while ((match = SEGMENT_RE.exec(trimmed)) !== null) {
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    total += value * UNIT_MS[unit];
   }
-}
-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" });
-    }
+  if (total === 0) {
+    throw new Error(`Invalid duration: "${trimmed}" resolves to 0ms`);
   }
-  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 });
+  return total;
 }
-autoConfigureFromEnv();
+var FORMAT_UNITS = [
+  ["w", UNIT_MS["w"]],
+  ["d", UNIT_MS["d"]],
+  ["h", UNIT_MS["h"]],
+  ["m", UNIT_MS["m"]],
+  ["s", UNIT_MS["s"]]
+];
 
-// src/lib/auto-memory-queue.ts
-var MAX_QUEUE_SIZE = 100;
-var CONCURRENCY = 3;
+// src/server/index.ts
+init_auto_memory();
+init_registry();
+init_hooks();
 
-class AutoMemoryQueue {
-  queue = [];
-  handler = null;
-  running = false;
-  activeCount = 0;
-  stats = {
-    pending: 0,
-    processing: 0,
-    processed: 0,
-    failed: 0,
-    dropped: 0
+// src/lib/built-in-hooks.ts
+init_hooks();
+
+// src/db/webhook_hooks.ts
+init_database();
+function parseRow(row) {
+  return {
+    id: row["id"],
+    type: row["type"],
+    handlerUrl: row["handler_url"],
+    priority: row["priority"],
+    blocking: Boolean(row["blocking"]),
+    agentId: row["agent_id"] || undefined,
+    projectId: row["project_id"] || undefined,
+    description: row["description"] || undefined,
+    enabled: Boolean(row["enabled"]),
+    createdAt: row["created_at"],
+    invocationCount: row["invocation_count"],
+    failureCount: row["failure_count"]
   };
-  setHandler(handler) {
-    this.handler = handler;
-    if (!this.running)
-      this.startLoop();
+}
+function createWebhookHook(input, db) {
+  const d = db || getDatabase();
+  const id = shortUuid();
+  const timestamp = now();
+  d.run(`INSERT INTO webhook_hooks
+       (id, type, handler_url, priority, blocking, agent_id, project_id, description, enabled, created_at, invocation_count, failure_count)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, 0, 0)`, [
+    id,
+    input.type,
+    input.handlerUrl,
+    input.priority ?? 50,
+    input.blocking ? 1 : 0,
+    input.agentId ?? null,
+    input.projectId ?? null,
+    input.description ?? null,
+    timestamp
+  ]);
+  return getWebhookHook(id, d);
+}
+function getWebhookHook(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM webhook_hooks WHERE id = ?").get(id);
+  return row ? parseRow(row) : null;
+}
+function listWebhookHooks(filter = {}, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter.type) {
+    conditions.push("type = ?");
+    params.push(filter.type);
   }
-  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();
+  if (filter.enabled !== undefined) {
+    conditions.push("enabled = ?");
+    params.push(filter.enabled ? 1 : 0);
   }
-  getStats() {
-    return { ...this.stats, pending: this.queue.length };
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = d.query(`SELECT * FROM webhook_hooks ${where} ORDER BY priority ASC, created_at ASC`).all(...params);
+  return rows.map(parseRow);
+}
+function updateWebhookHook(id, updates, db) {
+  const d = db || getDatabase();
+  const existing = getWebhookHook(id, d);
+  if (!existing)
+    return null;
+  const sets = [];
+  const params = [];
+  if (updates.enabled !== undefined) {
+    sets.push("enabled = ?");
+    params.push(updates.enabled ? 1 : 0);
   }
-  startLoop() {
-    this.running = true;
-    this.loop();
+  if (updates.description !== undefined) {
+    sets.push("description = ?");
+    params.push(updates.description);
   }
-  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;
+  if (updates.priority !== undefined) {
+    sets.push("priority = ?");
+    params.push(updates.priority);
   }
-  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;
-    }
+  if (sets.length > 0) {
+    params.push(id);
+    d.run(`UPDATE webhook_hooks SET ${sets.join(", ")} WHERE id = ?`, params);
   }
+  return getWebhookHook(id, d);
 }
-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 deleteWebhookHook(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM webhook_hooks WHERE id = ?", [id]);
+  return result.changes > 0;
 }
-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);
+function recordWebhookInvocation(id, success, db) {
+  const d = db || getDatabase();
+  if (success) {
+    d.run("UPDATE webhook_hooks SET invocation_count = invocation_count + 1 WHERE id = ?", [id]);
+  } else {
+    d.run("UPDATE webhook_hooks SET invocation_count = invocation_count + 1, failure_count = failure_count + 1 WHERE id = ?", [id]);
   }
 }
-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;
+
+// src/lib/built-in-hooks.ts
+var _processConversationTurn = null;
+async function getAutoMemory() {
+  if (!_processConversationTurn) {
+    const mod = await Promise.resolve().then(() => (init_auto_memory(), exports_auto_memory));
+    _processConversationTurn = mod.processConversationTurn;
+  }
+  return _processConversationTurn;
+}
+hookRegistry.register({
+  type: "PostMemorySave",
+  blocking: false,
+  builtin: true,
+  priority: 100,
+  description: "Trigger async LLM entity extraction when a memory is saved",
+  handler: async (ctx) => {
+    if (ctx.wasUpdated)
+      return;
+    const processConversationTurn2 = await getAutoMemory();
+    processConversationTurn2(`${ctx.memory.key}: ${ctx.memory.value}`, {
+      agentId: ctx.agentId,
+      projectId: ctx.projectId,
+      sessionId: ctx.sessionId
+    });
   }
-  try {
-    const input = {
-      key: extracted.content.slice(0, 120).replace(/\s+/g, "-").toLowerCase(),
-      value: extracted.content,
-      category: extracted.category,
-      scope: extracted.suggestedScope,
-      importance: extracted.importance,
-      tags: [
-        ...extracted.tags,
-        "auto-extracted",
-        ...context.sessionId ? [`session:${context.sessionId}`] : []
-      ],
-      agent_id: context.agentId,
-      project_id: context.projectId,
-      session_id: context.sessionId,
-      metadata: {
-        reasoning: extracted.reasoning,
-        auto_extracted: true,
-        extracted_at: new Date().toISOString()
-      }
-    };
-    const memory = createMemory(input, "merge");
-    return memory.id;
-  } catch (err) {
-    console.error("[auto-memory] saveExtractedMemory failed:", err);
-    return null;
+});
+hookRegistry.register({
+  type: "OnSessionStart",
+  blocking: false,
+  builtin: true,
+  priority: 100,
+  description: "Record session start as a history memory for analytics",
+  handler: async (ctx) => {
+    const { createMemory: createMemory2 } = await Promise.resolve().then(() => (init_memories(), exports_memories));
+    try {
+      createMemory2({
+        key: `session-start-${ctx.agentId}`,
+        value: `Agent ${ctx.agentId} started session on project ${ctx.projectId} at ${new Date(ctx.timestamp).toISOString()}`,
+        category: "history",
+        scope: "shared",
+        importance: 3,
+        source: "system",
+        agent_id: ctx.agentId,
+        project_id: ctx.projectId,
+        session_id: ctx.sessionId
+      });
+    } catch {}
   }
-}
-async function processJob(job) {
-  if (!providerRegistry.getConfig().enabled)
-    return;
-  const provider = providerRegistry.getAvailable();
-  if (!provider)
+});
+var _webhooksLoaded = false;
+function loadWebhooksFromDb() {
+  if (_webhooksLoaded)
     return;
-  const context = {
-    agentId: job.agentId,
-    projectId: job.projectId,
-    sessionId: job.sessionId
-  };
-  let extracted = [];
+  _webhooksLoaded = true;
   try {
-    extracted = await provider.extractMemories(job.turn, context);
-  } catch {
-    const fallbacks = providerRegistry.getFallbacks();
-    for (const fallback of fallbacks) {
-      try {
-        extracted = await fallback.extractMemories(job.turn, context);
-        if (extracted.length > 0)
-          break;
-      } catch {
-        continue;
-      }
+    const webhooks = listWebhookHooks({ enabled: true });
+    for (const wh of webhooks) {
+      hookRegistry.register({
+        type: wh.type,
+        blocking: wh.blocking,
+        priority: wh.priority,
+        agentId: wh.agentId,
+        projectId: wh.projectId,
+        description: wh.description ?? `Webhook: ${wh.handlerUrl}`,
+        handler: makeWebhookHandler(wh.id, wh.handlerUrl)
+      });
     }
-  }
-  if (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);
+    if (webhooks.length > 0) {
+      console.log(`[hooks] Loaded ${webhooks.length} webhook(s) from DB`);
     }
+  } catch (err) {
+    console.error("[hooks] Failed to load webhooks from DB:", err);
   }
 }
-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 makeWebhookHandler(webhookId, url) {
+  return async (context) => {
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(context),
+        signal: AbortSignal.timeout(1e4)
+      });
+      recordWebhookInvocation(webhookId, res.ok);
+    } catch {
+      recordWebhookInvocation(webhookId, false);
+    }
+  };
 }
-function configureAutoMemory(config) {
-  providerRegistry.configure(config);
+function reloadWebhooks() {
+  _webhooksLoaded = false;
+  loadWebhooksFromDb();
 }
 
 // src/server/index.ts
@@ -3700,7 +4215,73 @@ addRoute("POST", "/api/auto-memory/test", async (req) => {
     note: "DRY RUN \u2014 nothing was saved"
   });
 });
+addRoute("GET", "/api/hooks", (_req, url) => {
+  const type = url.searchParams.get("type") ?? undefined;
+  const hooks = hookRegistry.list(type);
+  return json(hooks.map((h) => ({
+    id: h.id,
+    type: h.type,
+    blocking: h.blocking,
+    priority: h.priority,
+    builtin: h.builtin ?? false,
+    agentId: h.agentId,
+    projectId: h.projectId,
+    description: h.description
+  })));
+});
+addRoute("GET", "/api/hooks/stats", () => json(hookRegistry.stats()));
+addRoute("GET", "/api/webhooks", (_req, url) => {
+  const type = url.searchParams.get("type") ?? undefined;
+  const enabledParam = url.searchParams.get("enabled");
+  const enabled = enabledParam !== null ? enabledParam === "true" : undefined;
+  return json(listWebhookHooks({
+    type,
+    enabled
+  }));
+});
+addRoute("POST", "/api/webhooks", async (req) => {
+  const body = await readJson(req) ?? {};
+  if (!body.type || !body.handler_url) {
+    return errorResponse("type and handler_url are required", 400);
+  }
+  const wh = createWebhookHook({
+    type: body.type,
+    handlerUrl: body.handler_url,
+    priority: body.priority,
+    blocking: body.blocking,
+    agentId: body.agent_id,
+    projectId: body.project_id,
+    description: body.description
+  });
+  reloadWebhooks();
+  return json(wh, 201);
+});
+addRoute("GET", "/api/webhooks/:id", (_req, _url, params) => {
+  const wh = getWebhookHook(params["id"]);
+  if (!wh)
+    return errorResponse("Webhook not found", 404);
+  return json(wh);
+});
+addRoute("PATCH", "/api/webhooks/:id", async (req, _url, params) => {
+  const body = await readJson(req) ?? {};
+  const updated = updateWebhookHook(params["id"], {
+    enabled: body.enabled,
+    priority: body.priority,
+    description: body.description
+  });
+  if (!updated)
+    return errorResponse("Webhook not found", 404);
+  reloadWebhooks();
+  return json(updated);
+});
+addRoute("DELETE", "/api/webhooks/:id", (_req, _url, params) => {
+  const deleted = deleteWebhookHook(params["id"]);
+  if (!deleted)
+    return errorResponse("Webhook not found", 404);
+  return new Response(null, { status: 204 });
+});
 function startServer(port) {
+  loadWebhooksFromDb();
   const hostname = process.env["MEMENTOS_HOST"] ?? "127.0.0.1";
   Bun.serve({
     port,