@hasna/mementos 0.3.9 → 0.4.2

package/dist/index.js

@@ -1,5 +1,12 @@
 // @bun
 // src/types/index.ts
+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}`);
@@ -182,6 +189,113 @@ 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,
+    version INTEGER NOT NULL,
+    value TEXT NOT NULL,
+    importance INTEGER NOT NULL,
+    scope TEXT NOT NULL,
+    category TEXT NOT NULL,
+    tags TEXT NOT NULL DEFAULT '[]',
+    summary TEXT,
+    pinned INTEGER NOT NULL DEFAULT 0,
+    status TEXT NOT NULL DEFAULT 'active',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(memory_id, version)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_memory_versions_memory ON memory_versions(memory_id);
+  CREATE INDEX IF NOT EXISTS idx_memory_versions_version ON memory_versions(memory_id, version);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (2);
+  `,
+  `
+  CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+    key, value, summary,
+    content='memories',
+    content_rowid='rowid'
+  );
+
+  CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+    INSERT INTO memories_fts(rowid, key, value, summary) VALUES (new.rowid, new.key, new.value, new.summary);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, key, value, summary) VALUES('delete', old.rowid, old.key, old.value, old.summary);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, key, value, summary) VALUES('delete', old.rowid, old.key, old.value, old.summary);
+    INSERT INTO memories_fts(rowid, key, value, summary) VALUES (new.rowid, new.key, new.value, new.summary);
+  END;
+
+  INSERT INTO memories_fts(memories_fts) VALUES('rebuild');
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (3);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS search_history (
+    id TEXT PRIMARY KEY,
+    query TEXT NOT NULL,
+    result_count INTEGER NOT NULL DEFAULT 0,
+    agent_id TEXT,
+    project_id TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_search_history_query ON search_history(query);
+  CREATE INDEX IF NOT EXISTS idx_search_history_created ON search_history(created_at);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (4);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS entities (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    type TEXT NOT NULL CHECK (type IN ('person','project','tool','concept','file','api','pattern','organization')),
+    description TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    project_id TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE SET NULL
+  );
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_entities_unique_name_type_project
+    ON entities(name, type, COALESCE(project_id, ''));
+  CREATE INDEX IF NOT EXISTS idx_entities_name ON entities(name);
+  CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
+  CREATE INDEX IF NOT EXISTS idx_entities_project ON entities(project_id);
+
+  CREATE TABLE IF NOT EXISTS relations (
+    id TEXT PRIMARY KEY,
+    source_entity_id TEXT NOT NULL,
+    target_entity_id TEXT NOT NULL,
+    relation_type TEXT NOT NULL CHECK (relation_type IN ('uses','knows','depends_on','created_by','related_to','contradicts','part_of','implements')),
+    weight REAL NOT NULL DEFAULT 1.0,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(source_entity_id, target_entity_id, relation_type),
+    FOREIGN KEY (source_entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+    FOREIGN KEY (target_entity_id) REFERENCES entities(id) ON DELETE CASCADE
+  );
+  CREATE INDEX IF NOT EXISTS idx_relations_source ON relations(source_entity_id);
+  CREATE INDEX IF NOT EXISTS idx_relations_target ON relations(target_entity_id);
+  CREATE INDEX IF NOT EXISTS idx_relations_type ON relations(relation_type);
+
+  CREATE TABLE IF NOT EXISTS entity_memories (
+    entity_id TEXT NOT NULL,
+    memory_id TEXT NOT NULL,
+    role TEXT NOT NULL DEFAULT 'context' CHECK (role IN ('subject','object','context')),
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (entity_id, memory_id),
+    FOREIGN KEY (entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+    FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+  );
+  CREATE INDEX IF NOT EXISTS idx_entity_memories_memory ON entity_memories(memory_id);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (5);
   `
 ];
 var _db = null;
@@ -279,176 +393,924 @@ function containsSecrets(text) {
   return false;
 }
 
-// src/db/memories.ts
-function parseMemoryRow(row) {
+// src/db/agents.ts
+function parseAgentRow(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,
+    name: row["name"],
+    description: row["description"] || null,
+    role: row["role"] || 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
+    last_seen_at: row["last_seen_at"]
   };
 }
-function createMemory(input, dedupeMode = "merge", db) {
+function registerAgent(name, description, role, db) {
   const d = db || getDatabase();
   const timestamp = now();
-  let expiresAt = input.expires_at || null;
-  if (input.ttl_ms && !expiresAt) {
-    expiresAt = new Date(Date.now() + input.ttl_ms).toISOString();
-  }
-  const id = uuid();
-  const tags = input.tags || [];
-  const tagsJson = JSON.stringify(tags);
-  const metadataJson = JSON.stringify(input.metadata || {});
-  const safeValue = redactSecrets(input.value);
-  const safeSummary = input.summary ? redactSecrets(input.summary) : null;
-  if (dedupeMode === "merge") {
-    const existing = d.query(`SELECT id, version FROM memories
-         WHERE key = ? AND scope = ?
-           AND COALESCE(agent_id, '') = ?
-           AND COALESCE(project_id, '') = ?
-           AND COALESCE(session_id, '') = ?`).get(input.key, input.scope || "private", input.agent_id || "", input.project_id || "", input.session_id || "");
-    if (existing) {
-      d.run(`UPDATE memories SET
-           value = ?, category = ?, summary = ?, tags = ?,
-           importance = ?, metadata = ?, expires_at = ?,
-           pinned = COALESCE(pinned, 0),
-           version = version + 1, updated_at = ?
-         WHERE id = ?`, [
-        safeValue,
-        input.category || "knowledge",
-        safeSummary,
-        tagsJson,
-        input.importance ?? 5,
-        metadataJson,
-        expiresAt,
-        timestamp,
-        existing.id
+  const normalizedName = name.trim().toLowerCase();
+  const existing = d.query("SELECT * FROM agents WHERE LOWER(name) = ?").get(normalizedName);
+  if (existing) {
+    const existingId = existing["id"];
+    d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [
+      timestamp,
+      existingId
+    ]);
+    if (description) {
+      d.run("UPDATE agents SET description = ? WHERE id = ?", [
+        description,
+        existingId
       ]);
-      d.run("DELETE FROM memory_tags WHERE memory_id = ?", [existing.id]);
-      const insertTag2 = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
-      for (const tag of tags) {
-        insertTag2.run(existing.id, tag);
-      }
-      return getMemory(existing.id, d);
     }
+    if (role) {
+      d.run("UPDATE agents SET role = ? WHERE id = ?", [
+        role,
+        existingId
+      ]);
+    }
+    return getAgent(existingId, d);
   }
-  d.run(`INSERT INTO memories (id, key, value, category, scope, summary, tags, importance, source, status, pinned, agent_id, project_id, session_id, metadata, access_count, version, expires_at, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', 0, ?, ?, ?, ?, 0, 1, ?, ?, ?)`, [
-    id,
-    input.key,
-    input.value,
-    input.category || "knowledge",
-    input.scope || "private",
-    input.summary || null,
-    tagsJson,
-    input.importance ?? 5,
-    input.source || "agent",
-    input.agent_id || null,
-    input.project_id || null,
-    input.session_id || null,
-    metadataJson,
-    expiresAt,
-    timestamp,
-    timestamp
-  ]);
-  const insertTag = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
-  for (const tag of tags) {
-    insertTag.run(id, tag);
-  }
-  return getMemory(id, d);
+  const id = shortUuid();
+  d.run("INSERT INTO agents (id, name, description, role, created_at, last_seen_at) VALUES (?, ?, ?, ?, ?, ?)", [id, normalizedName, description || null, role || "agent", timestamp, timestamp]);
+  return getAgent(id, d);
 }
-function getMemory(id, db) {
+function getAgent(idOrName, db) {
   const d = db || getDatabase();
-  const row = d.query("SELECT * FROM memories WHERE id = ?").get(id);
-  if (!row)
-    return null;
-  return parseMemoryRow(row);
+  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 getMemoryByKey(key, scope, agentId, projectId, sessionId, db) {
+function listAgents(db) {
   const d = db || getDatabase();
-  let sql = "SELECT * FROM memories WHERE key = ?";
-  const params = [key];
-  if (scope) {
-    sql += " AND scope = ?";
-    params.push(scope);
+  const rows = d.query("SELECT * FROM agents ORDER BY last_seen_at DESC").all();
+  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}`);
+      }
+      d.run("UPDATE agents SET name = ? WHERE id = ?", [normalizedNewName, agent.id]);
+    }
   }
-  if (agentId) {
-    sql += " AND agent_id = ?";
-    params.push(agentId);
+  if (updates.description !== undefined) {
+    d.run("UPDATE agents SET description = ? WHERE id = ?", [updates.description, agent.id]);
   }
-  if (projectId) {
-    sql += " AND project_id = ?";
-    params.push(projectId);
+  if (updates.role !== undefined) {
+    d.run("UPDATE agents SET role = ? WHERE id = ?", [updates.role, agent.id]);
   }
-  if (sessionId) {
-    sql += " AND session_id = ?";
-    params.push(sessionId);
+  if (updates.metadata !== undefined) {
+    d.run("UPDATE agents SET metadata = ? WHERE id = ?", [JSON.stringify(updates.metadata), agent.id]);
   }
-  sql += " AND status = 'active' ORDER BY importance DESC LIMIT 1";
-  const row = d.query(sql).get(...params);
-  if (!row)
-    return null;
-  return parseMemoryRow(row);
+  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [timestamp, agent.id]);
+  return getAgent(agent.id, d);
 }
-function listMemories(filter, db) {
+
+// src/db/projects.ts
+function parseProjectRow(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    path: row["path"],
+    description: row["description"] || null,
+    memory_prefix: row["memory_prefix"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"]
+  };
+}
+function registerProject(name, path, description, memoryPrefix, db) {
   const d = db || getDatabase();
-  const conditions = [];
-  const params = [];
-  if (filter) {
-    if (filter.scope) {
-      if (Array.isArray(filter.scope)) {
-        conditions.push(`scope IN (${filter.scope.map(() => "?").join(",")})`);
-        params.push(...filter.scope);
-      } else {
-        conditions.push("scope = ?");
-        params.push(filter.scope);
-      }
-    }
-    if (filter.category) {
-      if (Array.isArray(filter.category)) {
-        conditions.push(`category IN (${filter.category.map(() => "?").join(",")})`);
-        params.push(...filter.category);
-      } else {
-        conditions.push("category = ?");
-        params.push(filter.category);
-      }
-    }
-    if (filter.source) {
-      if (Array.isArray(filter.source)) {
-        conditions.push(`source IN (${filter.source.map(() => "?").join(",")})`);
-        params.push(...filter.source);
-      } else {
-        conditions.push("source = ?");
-        params.push(filter.source);
-      }
-    }
-    if (filter.status) {
-      if (Array.isArray(filter.status)) {
-        conditions.push(`status IN (${filter.status.map(() => "?").join(",")})`);
-        params.push(...filter.status);
-      } else {
-        conditions.push("status = ?");
-        params.push(filter.status);
-      }
-    } else {
-      conditions.push("status = 'active'");
+  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);
+  return null;
+}
+function listProjects(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
+  return rows.map(parseProjectRow);
+}
+
+// src/lib/extractor.ts
+var TECH_KEYWORDS = new Set([
+  "typescript",
+  "javascript",
+  "python",
+  "rust",
+  "go",
+  "java",
+  "ruby",
+  "swift",
+  "kotlin",
+  "react",
+  "vue",
+  "angular",
+  "svelte",
+  "nextjs",
+  "bun",
+  "node",
+  "deno",
+  "sqlite",
+  "postgres",
+  "mysql",
+  "redis",
+  "docker",
+  "kubernetes",
+  "git",
+  "npm",
+  "yarn",
+  "pnpm",
+  "webpack",
+  "vite",
+  "tailwind",
+  "prisma",
+  "drizzle",
+  "zod",
+  "commander",
+  "express",
+  "fastify",
+  "hono"
+]);
+var FILE_PATH_RE = /(?:^|\s)((?:\/|\.\/|~\/)?(?:[\w.-]+\/)+[\w.-]+\.\w+)/g;
+var URL_RE = /https?:\/\/[^\s)]+/g;
+var NPM_PACKAGE_RE = /@[\w-]+\/[\w.-]+/g;
+var PASCAL_CASE_RE = /\b([A-Z][a-z]+(?:[A-Z][a-z]+)+)\b/g;
+function getSearchText(memory) {
+  const parts = [memory.key, memory.value];
+  if (memory.summary)
+    parts.push(memory.summary);
+  return parts.join(" ");
+}
+function extractEntities(memory, db) {
+  const text = getSearchText(memory);
+  const entityMap = new Map;
+  function add(name, type, confidence) {
+    const normalized = name.toLowerCase();
+    if (normalized.length < 3)
+      return;
+    const existing = entityMap.get(normalized);
+    if (!existing || existing.confidence < confidence) {
+      entityMap.set(normalized, { name: normalized, type, confidence });
+    }
+  }
+  for (const match of text.matchAll(FILE_PATH_RE)) {
+    add(match[1].trim(), "file", 0.9);
+  }
+  for (const match of text.matchAll(URL_RE)) {
+    add(match[0], "api", 0.8);
+  }
+  for (const match of text.matchAll(NPM_PACKAGE_RE)) {
+    add(match[0], "tool", 0.85);
+  }
+  try {
+    const d = db || getDatabase();
+    const agents = listAgents(d);
+    const textLower2 = text.toLowerCase();
+    for (const agent of agents) {
+      const nameLower = agent.name.toLowerCase();
+      if (nameLower.length >= 3 && textLower2.includes(nameLower)) {
+        add(agent.name, "person", 0.95);
+      }
+    }
+  } catch {}
+  try {
+    const d = db || getDatabase();
+    const projects = listProjects(d);
+    const textLower2 = text.toLowerCase();
+    for (const project of projects) {
+      const nameLower = project.name.toLowerCase();
+      if (nameLower.length >= 3 && textLower2.includes(nameLower)) {
+        add(project.name, "project", 0.95);
+      }
+    }
+  } catch {}
+  const textLower = text.toLowerCase();
+  for (const keyword of TECH_KEYWORDS) {
+    const re = new RegExp(`\\b${keyword}\\b`, "i");
+    if (re.test(textLower)) {
+      add(keyword, "tool", 0.7);
+    }
+  }
+  for (const match of text.matchAll(PASCAL_CASE_RE)) {
+    add(match[1], "concept", 0.5);
+  }
+  return Array.from(entityMap.values()).sort((a, b) => b.confidence - a.confidence);
+}
+
+// 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);
+    }
+    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.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filter.project_id);
+  }
+  if (filter.search) {
+    conditions.push("(name LIKE ? OR description LIKE ?)");
+    const term = `%${filter.search}%`;
+    params.push(term, term);
+  }
+  let sql = "SELECT * FROM entities";
+  if (conditions.length > 0) {
+    sql += ` WHERE ${conditions.join(" AND ")}`;
+  }
+  sql += " ORDER BY updated_at DESC";
+  if (filter.limit) {
+    sql += " LIMIT ?";
+    params.push(filter.limit);
+  }
+  if (filter.offset) {
+    sql += " OFFSET ?";
+    params.push(filter.offset);
+  }
+  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 (input.type !== undefined) {
+    sets.push("type = ?");
+    params.push(input.type);
+  }
+  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 deleteEntity(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM entities WHERE id = ?", [id]);
+  if (result.changes === 0)
+    throw new EntityNotFoundError(id);
+}
+function mergeEntities(sourceId, targetId, db) {
+  const d = db || getDatabase();
+  getEntity(sourceId, d);
+  getEntity(targetId, d);
+  d.run(`UPDATE OR IGNORE relations SET source_entity_id = ? WHERE source_entity_id = ?`, [targetId, sourceId]);
+  d.run(`UPDATE OR IGNORE relations SET target_entity_id = ? WHERE target_entity_id = ?`, [targetId, sourceId]);
+  d.run("DELETE FROM relations WHERE source_entity_id = ? OR target_entity_id = ?", [
+    sourceId,
+    sourceId
+  ]);
+  d.run(`UPDATE OR IGNORE entity_memories SET entity_id = ? WHERE entity_id = ?`, [targetId, sourceId]);
+  d.run("DELETE FROM entity_memories WHERE entity_id = ?", [sourceId]);
+  d.run("DELETE FROM entities WHERE id = ?", [sourceId]);
+  d.run("UPDATE entities SET updated_at = ? WHERE id = ?", [now(), targetId]);
+  return getEntity(targetId, d);
+}
+
+// src/db/entity-memories.ts
+function parseEntityRow2(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    type: row["type"],
+    description: row["description"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    project_id: row["project_id"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"]
+  };
+}
+function parseEntityMemoryRow(row) {
+  return {
+    entity_id: row["entity_id"],
+    memory_id: row["memory_id"],
+    role: row["role"],
+    created_at: row["created_at"]
+  };
+}
+function linkEntityToMemory(entityId, memoryId, role = "context", db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  d.run(`INSERT OR IGNORE INTO entity_memories (entity_id, memory_id, role, created_at)
+     VALUES (?, ?, ?, ?)`, [entityId, memoryId, role, timestamp]);
+  const row = d.query("SELECT * FROM entity_memories WHERE entity_id = ? AND memory_id = ?").get(entityId, memoryId);
+  return parseEntityMemoryRow(row);
+}
+function unlinkEntityFromMemory(entityId, memoryId, db) {
+  const d = db || getDatabase();
+  d.run("DELETE FROM entity_memories WHERE entity_id = ? AND memory_id = ?", [entityId, memoryId]);
+}
+function getMemoriesForEntity(entityId, db) {
+  const d = db || getDatabase();
+  const rows = d.query(`SELECT m.* FROM memories m
+       INNER JOIN entity_memories em ON em.memory_id = m.id
+       WHERE em.entity_id = ?
+       ORDER BY m.importance DESC, m.created_at DESC`).all(entityId);
+  return rows.map(parseMemoryRow);
+}
+function getEntitiesForMemory(memoryId, db) {
+  const d = db || getDatabase();
+  const rows = d.query(`SELECT e.* FROM entities e
+       INNER JOIN entity_memories em ON em.entity_id = e.id
+       WHERE em.memory_id = ?
+       ORDER BY e.name ASC`).all(memoryId);
+  return rows.map(parseEntityRow2);
+}
+function bulkLinkEntities(entityIds, memoryId, role = "context", db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  const tx = d.transaction(() => {
+    const stmt = d.prepare(`INSERT OR IGNORE INTO entity_memories (entity_id, memory_id, role, created_at)
+       VALUES (?, ?, ?, ?)`);
+    for (const entityId of entityIds) {
+      stmt.run(entityId, memoryId, role, timestamp);
+    }
+  });
+  tx();
+}
+function getEntityMemoryLinks(entityId, memoryId, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (entityId) {
+    conditions.push("entity_id = ?");
+    params.push(entityId);
+  }
+  if (memoryId) {
+    conditions.push("memory_id = ?");
+    params.push(memoryId);
+  }
+  let sql = "SELECT * FROM entity_memories";
+  if (conditions.length > 0) {
+    sql += ` WHERE ${conditions.join(" AND ")}`;
+  }
+  sql += " ORDER BY created_at DESC";
+  const rows = d.query(sql).all(...params);
+  return rows.map(parseEntityMemoryRow);
+}
+
+// src/db/relations.ts
+function parseRelationRow(row) {
+  return {
+    id: row["id"],
+    source_entity_id: row["source_entity_id"],
+    target_entity_id: row["target_entity_id"],
+    relation_type: row["relation_type"],
+    weight: row["weight"],
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    created_at: row["created_at"]
+  };
+}
+function parseEntityRow3(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    type: row["type"],
+    description: row["description"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    project_id: row["project_id"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"]
+  };
+}
+function createRelation(input, db) {
+  const d = db || getDatabase();
+  const id = shortUuid();
+  const timestamp = now();
+  const weight = input.weight ?? 1;
+  const metadata = JSON.stringify(input.metadata ?? {});
+  d.run(`INSERT INTO relations (id, source_entity_id, target_entity_id, relation_type, weight, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(source_entity_id, target_entity_id, relation_type)
+     DO UPDATE SET weight = excluded.weight, metadata = excluded.metadata`, [id, input.source_entity_id, input.target_entity_id, input.relation_type, weight, metadata, timestamp]);
+  const row = d.query(`SELECT * FROM relations
+       WHERE source_entity_id = ? AND target_entity_id = ? AND relation_type = ?`).get(input.source_entity_id, input.target_entity_id, input.relation_type);
+  return parseRelationRow(row);
+}
+function getRelation(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM relations WHERE id = ?").get(id);
+  if (!row)
+    throw new Error(`Relation not found: ${id}`);
+  return parseRelationRow(row);
+}
+function listRelations(filter, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter.entity_id) {
+    const dir = filter.direction || "both";
+    if (dir === "outgoing") {
+      conditions.push("source_entity_id = ?");
+      params.push(filter.entity_id);
+    } else if (dir === "incoming") {
+      conditions.push("target_entity_id = ?");
+      params.push(filter.entity_id);
+    } else {
+      conditions.push("(source_entity_id = ? OR target_entity_id = ?)");
+      params.push(filter.entity_id, filter.entity_id);
+    }
+  }
+  if (filter.relation_type) {
+    conditions.push("relation_type = ?");
+    params.push(filter.relation_type);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = d.query(`SELECT * FROM relations ${where} ORDER BY created_at DESC`).all(...params);
+  return rows.map(parseRelationRow);
+}
+function deleteRelation(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM relations WHERE id = ?", [id]);
+  if (result.changes === 0)
+    throw new Error(`Relation not found: ${id}`);
+}
+function getRelatedEntities(entityId, relationType, db) {
+  const d = db || getDatabase();
+  let sql;
+  const params = [];
+  if (relationType) {
+    sql = `
+      SELECT DISTINCT e.* FROM entities e
+      JOIN relations r ON (
+        (r.source_entity_id = ? AND r.target_entity_id = e.id)
+        OR (r.target_entity_id = ? AND r.source_entity_id = e.id)
+      )
+      WHERE r.relation_type = ?
+    `;
+    params.push(entityId, entityId, relationType);
+  } else {
+    sql = `
+      SELECT DISTINCT e.* FROM entities e
+      JOIN relations r ON (
+        (r.source_entity_id = ? AND r.target_entity_id = e.id)
+        OR (r.target_entity_id = ? AND r.source_entity_id = e.id)
+      )
+    `;
+    params.push(entityId, entityId);
+  }
+  const rows = d.query(sql).all(...params);
+  return rows.map(parseEntityRow3);
+}
+function getEntityGraph(entityId, depth = 2, db) {
+  const d = db || getDatabase();
+  const entityRows = d.query(`WITH RECURSIVE graph(id, depth) AS (
+        VALUES(?, 0)
+        UNION
+        SELECT CASE WHEN r.source_entity_id = g.id THEN r.target_entity_id ELSE r.source_entity_id END, g.depth + 1
+        FROM relations r JOIN graph g ON (r.source_entity_id = g.id OR r.target_entity_id = g.id)
+        WHERE g.depth < ?
+      )
+      SELECT DISTINCT e.* FROM entities e JOIN graph g ON e.id = g.id`).all(entityId, depth);
+  const entities = entityRows.map(parseEntityRow3);
+  const entityIds = new Set(entities.map((e) => e.id));
+  if (entityIds.size === 0) {
+    return { entities: [], relations: [] };
+  }
+  const placeholders = Array.from(entityIds).map(() => "?").join(",");
+  const relationRows = d.query(`SELECT * FROM relations
+       WHERE source_entity_id IN (${placeholders})
+         AND target_entity_id IN (${placeholders})`).all(...Array.from(entityIds), ...Array.from(entityIds));
+  const relations = relationRows.map(parseRelationRow);
+  return { entities, relations };
+}
+function findPath(fromEntityId, toEntityId, maxDepth = 5, db) {
+  const d = db || getDatabase();
+  const rows = d.query(`WITH RECURSIVE path(id, trail, depth) AS (
+        SELECT ?, ?, 0
+        UNION
+        SELECT
+          CASE WHEN r.source_entity_id = p.id THEN r.target_entity_id ELSE r.source_entity_id END,
+          p.trail || ',' || CASE WHEN r.source_entity_id = p.id THEN r.target_entity_id ELSE r.source_entity_id END,
+          p.depth + 1
+        FROM relations r JOIN path p ON (r.source_entity_id = p.id OR r.target_entity_id = p.id)
+        WHERE p.depth < ?
+          AND INSTR(p.trail, CASE WHEN r.source_entity_id = p.id THEN r.target_entity_id ELSE r.source_entity_id END) = 0
+      )
+      SELECT trail FROM path WHERE id = ? ORDER BY depth ASC LIMIT 1`).get(fromEntityId, fromEntityId, maxDepth, toEntityId);
+  if (!rows)
+    return null;
+  const ids = rows.trail.split(",");
+  const entities = [];
+  for (const id of ids) {
+    const row = d.query("SELECT * FROM entities WHERE id = ?").get(id);
+    if (row)
+      entities.push(parseEntityRow3(row));
+  }
+  return entities.length > 0 ? entities : null;
+}
+
+// src/lib/config.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync } from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+var DEFAULT_CONFIG = {
+  default_scope: "private",
+  default_category: "knowledge",
+  default_importance: 5,
+  max_entries: 1000,
+  max_entries_per_scope: {
+    global: 500,
+    shared: 300,
+    private: 200
+  },
+  injection: {
+    max_tokens: 500,
+    min_importance: 5,
+    categories: ["preference", "fact"],
+    refresh_interval: 5
+  },
+  extraction: {
+    enabled: true,
+    min_confidence: 0.5
+  },
+  sync_agents: ["claude", "codex", "gemini"],
+  auto_cleanup: {
+    enabled: true,
+    expired_check_interval: 3600,
+    unused_archive_days: 7,
+    stale_deprioritize_days: 14
+  }
+};
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = result[key];
+    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(targetVal, sourceVal);
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+var VALID_SCOPES = ["global", "shared", "private"];
+var VALID_CATEGORIES = [
+  "preference",
+  "fact",
+  "knowledge",
+  "history"
+];
+function isValidScope(value) {
+  return VALID_SCOPES.includes(value);
+}
+function isValidCategory(value) {
+  return VALID_CATEGORIES.includes(value);
+}
+function loadConfig() {
+  const configPath = join2(homedir(), ".mementos", "config.json");
+  let fileConfig = {};
+  if (existsSync2(configPath)) {
+    try {
+      const raw = readFileSync(configPath, "utf-8");
+      fileConfig = JSON.parse(raw);
+    } catch {}
+  }
+  const merged = deepMerge(DEFAULT_CONFIG, fileConfig);
+  const envScope = process.env["MEMENTOS_DEFAULT_SCOPE"];
+  if (envScope && isValidScope(envScope)) {
+    merged.default_scope = envScope;
+  }
+  const envCategory = process.env["MEMENTOS_DEFAULT_CATEGORY"];
+  if (envCategory && isValidCategory(envCategory)) {
+    merged.default_category = envCategory;
+  }
+  const envImportance = process.env["MEMENTOS_DEFAULT_IMPORTANCE"];
+  if (envImportance) {
+    const parsed = parseInt(envImportance, 10);
+    if (!Number.isNaN(parsed) && parsed >= 1 && parsed <= 10) {
+      merged.default_importance = parsed;
+    }
+  }
+  return merged;
+}
+
+// src/db/memories.ts
+function runEntityExtraction(memory, projectId, d) {
+  const config = loadConfig();
+  if (config.extraction?.enabled === false)
+    return;
+  const extracted = extractEntities(memory, d);
+  const minConfidence = config.extraction?.min_confidence ?? 0.5;
+  const entityIds = [];
+  for (const ext of extracted) {
+    if (ext.confidence >= minConfidence) {
+      const entity = createEntity({ name: ext.name, type: ext.type, project_id: projectId }, d);
+      linkEntityToMemory(entity.id, memory.id, "context", d);
+      entityIds.push(entity.id);
+    }
+  }
+  for (let i = 0;i < entityIds.length; i++) {
+    for (let j = i + 1;j < entityIds.length; j++) {
+      try {
+        createRelation({ source_entity_id: entityIds[i], target_entity_id: entityIds[j], relation_type: "related_to" }, d);
+      } catch {}
+    }
+  }
+}
+function parseMemoryRow(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 createMemory(input, dedupeMode = "merge", db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  let expiresAt = input.expires_at || null;
+  if (input.ttl_ms && !expiresAt) {
+    expiresAt = new Date(Date.now() + input.ttl_ms).toISOString();
+  }
+  const id = uuid();
+  const tags = input.tags || [];
+  const tagsJson = JSON.stringify(tags);
+  const metadataJson = JSON.stringify(input.metadata || {});
+  const safeValue = redactSecrets(input.value);
+  const safeSummary = input.summary ? redactSecrets(input.summary) : null;
+  if (dedupeMode === "merge") {
+    const existing = d.query(`SELECT id, version FROM memories
+         WHERE key = ? AND scope = ?
+           AND COALESCE(agent_id, '') = ?
+           AND COALESCE(project_id, '') = ?
+           AND COALESCE(session_id, '') = ?`).get(input.key, input.scope || "private", input.agent_id || "", input.project_id || "", input.session_id || "");
+    if (existing) {
+      d.run(`UPDATE memories SET
+           value = ?, category = ?, summary = ?, tags = ?,
+           importance = ?, metadata = ?, expires_at = ?,
+           pinned = COALESCE(pinned, 0),
+           version = version + 1, updated_at = ?
+         WHERE id = ?`, [
+        safeValue,
+        input.category || "knowledge",
+        safeSummary,
+        tagsJson,
+        input.importance ?? 5,
+        metadataJson,
+        expiresAt,
+        timestamp,
+        existing.id
+      ]);
+      d.run("DELETE FROM memory_tags WHERE memory_id = ?", [existing.id]);
+      const insertTag2 = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
+      for (const tag of tags) {
+        insertTag2.run(existing.id, tag);
+      }
+      const merged = getMemory(existing.id, d);
+      try {
+        const oldLinks = getEntityMemoryLinks(undefined, merged.id, d);
+        for (const link of oldLinks) {
+          unlinkEntityFromMemory(link.entity_id, merged.id, d);
+        }
+        runEntityExtraction(merged, input.project_id, d);
+      } catch {}
+      return merged;
+    }
+  }
+  d.run(`INSERT INTO memories (id, key, value, category, scope, summary, tags, importance, source, status, pinned, agent_id, project_id, session_id, metadata, access_count, version, expires_at, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', 0, ?, ?, ?, ?, 0, 1, ?, ?, ?)`, [
+    id,
+    input.key,
+    input.value,
+    input.category || "knowledge",
+    input.scope || "private",
+    input.summary || null,
+    tagsJson,
+    input.importance ?? 5,
+    input.source || "agent",
+    input.agent_id || null,
+    input.project_id || null,
+    input.session_id || null,
+    metadataJson,
+    expiresAt,
+    timestamp,
+    timestamp
+  ]);
+  const insertTag = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
+  for (const tag of tags) {
+    insertTag.run(id, tag);
+  }
+  const memory = getMemory(id, d);
+  try {
+    runEntityExtraction(memory, input.project_id, d);
+  } catch {}
+  return memory;
+}
+function getMemory(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM memories WHERE id = ?").get(id);
+  if (!row)
+    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 listMemories(filter, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter) {
+    if (filter.scope) {
+      if (Array.isArray(filter.scope)) {
+        conditions.push(`scope IN (${filter.scope.map(() => "?").join(",")})`);
+        params.push(...filter.scope);
+      } else {
+        conditions.push("scope = ?");
+        params.push(filter.scope);
+      }
+    }
+    if (filter.category) {
+      if (Array.isArray(filter.category)) {
+        conditions.push(`category IN (${filter.category.map(() => "?").join(",")})`);
+        params.push(...filter.category);
+      } else {
+        conditions.push("category = ?");
+        params.push(filter.category);
+      }
+    }
+    if (filter.source) {
+      if (Array.isArray(filter.source)) {
+        conditions.push(`source IN (${filter.source.map(() => "?").join(",")})`);
+        params.push(...filter.source);
+      } else {
+        conditions.push("source = ?");
+        params.push(filter.source);
+      }
+    }
+    if (filter.status) {
+      if (Array.isArray(filter.status)) {
+        conditions.push(`status IN (${filter.status.map(() => "?").join(",")})`);
+        params.push(...filter.status);
+      } else {
+        conditions.push("status = ?");
+        params.push(filter.status);
+      }
+    } else {
+      conditions.push("status = 'active'");
     }
     if (filter.project_id) {
       conditions.push("project_id = ?");
@@ -508,6 +1370,23 @@ function updateMemory(id, input, db) {
   if (existing.version !== input.version) {
     throw new VersionConflictError(id, input.version, existing.version);
   }
+  try {
+    d.run(`INSERT OR IGNORE INTO memory_versions (id, memory_id, version, value, importance, scope, category, tags, summary, pinned, status, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      uuid(),
+      existing.id,
+      existing.version,
+      existing.value,
+      existing.importance,
+      existing.scope,
+      existing.category,
+      JSON.stringify(existing.tags),
+      existing.summary,
+      existing.pinned ? 1 : 0,
+      existing.status,
+      existing.updated_at
+    ]);
+  } catch {}
   const sets = ["version = version + 1", "updated_at = ?"];
   const params = [now()];
   if (input.value !== undefined) {
@@ -557,156 +1436,48 @@ function updateMemory(id, input, db) {
   }
   params.push(id);
   d.run(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`, params);
-  return getMemory(id, d);
-}
-function deleteMemory(id, db) {
-  const d = db || getDatabase();
-  const result = d.run("DELETE FROM memories WHERE id = ?", [id]);
-  return result.changes > 0;
-}
-function bulkDeleteMemories(ids, db) {
-  const d = db || getDatabase();
-  if (ids.length === 0)
-    return 0;
-  const placeholders = ids.map(() => "?").join(",");
-  const result = d.run(`DELETE FROM memories WHERE id IN (${placeholders})`, ids);
-  return result.changes;
-}
-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 cleanExpiredMemories(db) {
-  const d = db || getDatabase();
-  const timestamp = now();
-  const result = d.run("DELETE FROM memories WHERE expires_at IS NOT NULL AND expires_at < ?", [timestamp]);
-  return result.changes;
-}
-// src/db/agents.ts
-function parseAgentRow(row) {
-  return {
-    id: row["id"],
-    name: row["name"],
-    description: row["description"] || null,
-    role: row["role"] || null,
-    metadata: JSON.parse(row["metadata"] || "{}"),
-    created_at: row["created_at"],
-    last_seen_at: row["last_seen_at"]
-  };
-}
-function registerAgent(name, description, role, db) {
-  const d = db || getDatabase();
-  const timestamp = now();
-  const existing = d.query("SELECT * FROM agents WHERE name = ?").get(name);
-  if (existing) {
-    const existingId = existing["id"];
-    d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [
-      timestamp,
-      existingId
-    ]);
-    if (description) {
-      d.run("UPDATE agents SET description = ? WHERE id = ?", [
-        description,
-        existingId
-      ]);
-    }
-    if (role) {
-      d.run("UPDATE agents SET role = ? WHERE id = ?", [
-        role,
-        existingId
-      ]);
-    }
-    return getAgent(existingId, d);
-  }
-  const id = shortUuid();
-  d.run("INSERT INTO agents (id, name, description, role, created_at, last_seen_at) VALUES (?, ?, ?, ?, ?, ?)", [id, name, description || null, role || "agent", 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 name = ?").get(idOrName);
-  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 updateAgent(id, updates, db) {
-  const d = db || getDatabase();
-  const agent = getAgent(id, d);
-  if (!agent)
-    return null;
-  const timestamp = now();
-  if (updates.name && updates.name !== agent.name) {
-    const existing = d.query("SELECT id FROM agents WHERE name = ? AND id != ?").get(updates.name, agent.id);
-    if (existing) {
-      throw new Error(`Agent name already taken: ${updates.name}`);
-    }
-    d.run("UPDATE agents SET name = ? WHERE id = ?", [updates.name, 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]);
-  }
-  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [timestamp, agent.id]);
-  return getAgent(agent.id, d);
+  const updated = getMemory(id, d);
+  try {
+    if (input.value !== undefined) {
+      const oldLinks = getEntityMemoryLinks(undefined, updated.id, d);
+      for (const link of oldLinks) {
+        unlinkEntityFromMemory(link.entity_id, updated.id, d);
+      }
+      runEntityExtraction(updated, existing.project_id || undefined, d);
+    }
+  } catch {}
+  return updated;
 }
-// src/db/projects.ts
-function parseProjectRow(row) {
-  return {
-    id: row["id"],
-    name: row["name"],
-    path: row["path"],
-    description: row["description"] || null,
-    memory_prefix: row["memory_prefix"] || null,
-    created_at: row["created_at"],
-    updated_at: row["updated_at"]
-  };
+function deleteMemory(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM memories WHERE id = ?", [id]);
+  return result.changes > 0;
 }
-function registerProject(name, path, description, memoryPrefix, db) {
+function bulkDeleteMemories(ids, 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);
+  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);
   }
-  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);
+  return count;
 }
-function getProject(idOrPath, db) {
+function touchMemory(id, 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);
-  return null;
+  d.run("UPDATE memories SET access_count = access_count + 1, accessed_at = ? WHERE id = ?", [now(), id]);
 }
-function listProjects(db) {
+function cleanExpiredMemories(db) {
   const d = db || getDatabase();
-  const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
-  return rows.map(parseProjectRow);
+  const timestamp = now();
+  const countRow = d.query("SELECT COUNT(*) as c FROM memories WHERE expires_at IS NOT NULL AND expires_at < ?").get(timestamp);
+  const count = countRow.c;
+  if (count > 0) {
+    d.run("DELETE FROM memories WHERE expires_at IS NOT NULL AND expires_at < ?", [timestamp]);
+  }
+  return count;
 }
 // src/lib/search.ts
 function parseMemoryRow2(row) {
@@ -734,109 +1505,442 @@ function parseMemoryRow2(row) {
     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;
+      }
+    }
+  }
+  for (const tag of memory.tags) {
+    if (tag.toLowerCase().includes(queryLower) || tokens.some((t) => tag.toLowerCase().includes(t))) {
+      highlights.push({ field: "tag", snippet: tag });
+    }
+  }
+  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";
 }
 function computeScore(memory, queryLower) {
-  let score = 0;
+  const fieldScores = [];
   const keyLower = memory.key.toLowerCase();
   if (keyLower === queryLower) {
-    score += 10;
+    fieldScores.push(10);
   } else if (keyLower.includes(queryLower)) {
-    score += 7;
+    fieldScores.push(7);
   }
   if (memory.tags.some((t) => t.toLowerCase() === queryLower)) {
-    score += 6;
+    fieldScores.push(6);
+  } else if (memory.tags.some((t) => t.toLowerCase().includes(queryLower))) {
+    fieldScores.push(3);
   }
   if (memory.summary && memory.summary.toLowerCase().includes(queryLower)) {
-    score += 4;
+    fieldScores.push(4);
   }
   if (memory.value.toLowerCase().includes(queryLower)) {
-    score += 3;
+    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;
+      }
+    }
+    if (score > 0) {
+      score += tokenScore * 0.3;
+    } else {
+      score += tokenScore;
+    }
   }
   return score;
 }
-function searchMemories(query, filter, db) {
-  const d = db || getDatabase();
-  const queryLower = query.toLowerCase();
-  const queryParam = `%${query}%`;
+function extractQuotedPhrases(query) {
+  const phrases = [];
+  const remainder = query.replace(/"([^"]+)"/g, (_match, phrase) => {
+    phrases.push(phrase);
+    return "";
+  });
+  return { phrases, remainder: remainder.trim() };
+}
+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 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 buildFilterConditions(filter) {
   const conditions = [];
   const params = [];
   conditions.push("m.status = 'active'");
   conditions.push("(m.expires_at IS NULL OR m.expires_at >= datetime('now'))");
-  conditions.push(`(m.key LIKE ? OR m.value LIKE ? OR m.summary LIKE ? OR m.id IN (SELECT memory_id FROM memory_tags WHERE tag LIKE ?))`);
-  params.push(queryParam, queryParam, queryParam, queryParam);
-  if (filter) {
-    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);
-      }
+  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);
     }
-    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.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.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.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.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);
     }
-    if (filter.agent_id) {
-      conditions.push("m.agent_id = ?");
-      params.push(filter.agent_id);
+  }
+  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));
     }
-    if (filter.session_id) {
-      conditions.push("m.session_id = ?");
-      params.push(filter.session_id);
+    for (const tag of memory.tags) {
+      bestSimilarity = Math.max(bestSimilarity, trigramSimilarity(query, tag));
     }
-    if (filter.min_importance) {
-      conditions.push("m.importance >= ?");
-      params.push(filter.min_importance);
+    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" });
     }
-    if (filter.pinned !== undefined) {
-      conditions.push("m.pinned = ?");
-      params.push(filter.pinned ? 1 : 0);
+  }
+  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);
     }
-    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);
+    for (const entity of matchingEntities) {
+      const memories = getMemoriesForEntity(entity.id, d);
+      for (const mem of memories) {
+        boostedIds.add(mem.id);
       }
     }
-  }
-  const sql = `SELECT m.* FROM memories m WHERE ${conditions.join(" AND ")}`;
-  const rows = d.query(sql).all(...params);
+  } 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);
@@ -844,11 +1948,16 @@ function searchMemories(query, filter, db) {
     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: weightedScore,
-      match_type: matchType
+      score: finalScore,
+      match_type: matchType,
+      highlights: extractHighlights(memory, queryLower)
     });
   }
   scored.sort((a, b) => {
@@ -856,90 +1965,53 @@ function searchMemories(query, filter, db) {
       return b.score - a.score;
     return b.memory.importance - a.memory.importance;
   });
-  const offset = filter?.offset ?? 0;
-  const limit = filter?.limit ?? scored.length;
-  return scored.slice(offset, offset + limit);
+  return scored;
 }
-// src/lib/config.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync } from "fs";
-import { homedir } from "os";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
-var DEFAULT_CONFIG = {
-  default_scope: "private",
-  default_category: "knowledge",
-  default_importance: 5,
-  max_entries: 1000,
-  max_entries_per_scope: {
-    global: 500,
-    shared: 300,
-    private: 200
-  },
-  injection: {
-    max_tokens: 500,
-    min_importance: 5,
-    categories: ["preference", "fact"],
-    refresh_interval: 5
-  },
-  sync_agents: ["claude", "codex", "gemini"],
-  auto_cleanup: {
-    enabled: true,
-    expired_check_interval: 3600,
-    unused_archive_days: 7,
-    stale_deprioritize_days: 14
-  }
-};
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    const sourceVal = source[key];
-    const targetVal = result[key];
-    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
-      result[key] = deepMerge(targetVal, sourceVal);
+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 {
-      result[key] = sourceVal;
+      scored = searchWithLike(d, query, queryLower, filter, graphBoostedIds);
     }
-  }
-  return result;
-}
-var VALID_SCOPES = ["global", "shared", "private"];
-var VALID_CATEGORIES = [
-  "preference",
-  "fact",
-  "knowledge",
-  "history"
-];
-function isValidScope(value) {
-  return VALID_SCOPES.includes(value);
-}
-function isValidCategory(value) {
-  return VALID_CATEGORIES.includes(value);
-}
-function loadConfig() {
-  const configPath = join2(homedir(), ".mementos", "config.json");
-  let fileConfig = {};
-  if (existsSync2(configPath)) {
-    try {
-      const raw = readFileSync(configPath, "utf-8");
-      fileConfig = JSON.parse(raw);
-    } catch {}
-  }
-  const merged = deepMerge(DEFAULT_CONFIG, fileConfig);
-  const envScope = process.env["MEMENTOS_DEFAULT_SCOPE"];
-  if (envScope && isValidScope(envScope)) {
-    merged.default_scope = envScope;
-  }
-  const envCategory = process.env["MEMENTOS_DEFAULT_CATEGORY"];
-  if (envCategory && isValidCategory(envCategory)) {
-    merged.default_category = envCategory;
-  }
-  const envImportance = process.env["MEMENTOS_DEFAULT_IMPORTANCE"];
-  if (envImportance) {
-    const parsed = parseInt(envImportance, 10);
-    if (!Number.isNaN(parsed) && parsed >= 1 && parsed <= 10) {
-      merged.default_importance = parsed;
+  } else {
+    scored = searchWithLike(d, query, queryLower, filter, graphBoostedIds);
+  }
+  if (scored.length < 3) {
+    const fuzzyResults = searchWithFuzzy(d, query, filter, graphBoostedIds);
+    const seenIds = new Set(scored.map((r) => r.memory.id));
+    for (const fr of fuzzyResults) {
+      if (!seenIds.has(fr.memory.id)) {
+        scored.push(fr);
+        seenIds.add(fr.memory.id);
+      }
     }
+    scored.sort((a, b) => {
+      if (b.score !== a.score)
+        return b.score - a.score;
+      return b.memory.importance - a.memory.importance;
+    });
   }
-  return merged;
+  const offset = filter?.offset ?? 0;
+  const limit = filter?.limit ?? scored.length;
+  const finalResults = scored.slice(offset, offset + limit);
+  logSearchQuery(query, scored.length, filter?.agent_id, filter?.project_id, d);
+  return finalResults;
+}
+function logSearchQuery(query, resultCount, agentId, projectId, db) {
+  try {
+    const d = db || getDatabase();
+    const id = crypto.randomUUID().slice(0, 8);
+    d.run("INSERT INTO search_history (id, query, result_count, agent_id, project_id) VALUES (?, ?, ?, ?, ?)", [id, query, resultCount, agentId || null, projectId || null]);
+  } catch {}
 }
 // src/lib/injector.ts
 class MemoryInjector {
@@ -1100,13 +2172,13 @@ function enforceQuotas(config, db) {
     if (count <= limit)
       continue;
     const excess = count - limit;
-    const result = d.run(`DELETE FROM memories WHERE id IN (
-        SELECT id FROM memories
+    const subquery = `SELECT id FROM memories
         WHERE scope = ? AND status = 'active' AND pinned = 0
         ORDER BY importance ASC, created_at ASC
-        LIMIT ?
-      )`, [scope, excess]);
-    totalEvicted += result.changes;
+        LIMIT ?`;
+    const delCount = d.query(`SELECT COUNT(*) as c FROM (${subquery})`).get(scope, excess).c;
+    d.run(`DELETE FROM memories WHERE id IN (${subquery})`, [scope, excess]);
+    totalEvicted += delCount;
   }
   return totalEvicted;
 }
@@ -1114,38 +2186,38 @@ function archiveStale(staleDays, db) {
   const d = db || getDatabase();
   const timestamp = now();
   const cutoff = new Date(Date.now() - staleDays * 24 * 60 * 60 * 1000).toISOString();
-  const result = d.run(`UPDATE memories
-     SET status = 'archived', updated_at = ?
-     WHERE status = 'active'
-       AND pinned = 0
-       AND COALESCE(accessed_at, created_at) < ?`, [timestamp, cutoff]);
-  return result.changes;
+  const archiveWhere = `status = 'active' AND pinned = 0 AND COALESCE(accessed_at, created_at) < ?`;
+  const count = d.query(`SELECT COUNT(*) as c FROM memories WHERE ${archiveWhere}`).get(cutoff).c;
+  if (count > 0) {
+    d.run(`UPDATE memories SET status = 'archived', updated_at = ? WHERE ${archiveWhere}`, [timestamp, cutoff]);
+  }
+  return count;
 }
 function archiveUnused(days, db) {
   const d = db || getDatabase();
   const timestamp = now();
   const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
-  const result = d.run(`UPDATE memories
-     SET status = 'archived', updated_at = ?
-     WHERE status = 'active'
-       AND pinned = 0
-       AND access_count = 0
-       AND created_at < ?`, [timestamp, cutoff]);
-  return result.changes;
+  const unusedWhere = `status = 'active' AND pinned = 0 AND access_count = 0 AND created_at < ?`;
+  const count = d.query(`SELECT COUNT(*) as c FROM memories WHERE ${unusedWhere}`).get(cutoff).c;
+  if (count > 0) {
+    d.run(`UPDATE memories SET status = 'archived', updated_at = ? WHERE ${unusedWhere}`, [timestamp, cutoff]);
+  }
+  return count;
 }
 function deprioritizeStale(days, db) {
   const d = db || getDatabase();
   const timestamp = now();
   const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
-  const result = d.run(`UPDATE memories
-     SET importance = MAX(importance - 1, 1),
-         version = version + 1,
-         updated_at = ?
-     WHERE status = 'active'
-       AND pinned = 0
-       AND importance > 1
-       AND COALESCE(accessed_at, updated_at) < ?`, [timestamp, cutoff]);
-  return result.changes;
+  const deprioWhere = `status = 'active' AND pinned = 0 AND importance > 1 AND COALESCE(accessed_at, updated_at) < ?`;
+  const count = d.query(`SELECT COUNT(*) as c FROM memories WHERE ${deprioWhere}`).get(cutoff).c;
+  if (count > 0) {
+    d.run(`UPDATE memories
+       SET importance = MAX(importance - 1, 1),
+           version = version + 1,
+           updated_at = ?
+       WHERE ${deprioWhere}`, [timestamp, cutoff]);
+  }
+  return count;
 }
 function runCleanup(config, db) {
   const d = db || getDatabase();
@@ -1288,7 +2360,9 @@ var defaultSyncAgents = ["claude", "codex", "gemini"];
 export {
   uuid,
   updateMemory,
+  updateEntity,
   updateAgent,
+  unlinkEntityFromMemory,
   touchMemory,
   syncMemories,
   shortUuid,
@@ -1299,25 +2373,46 @@ export {
   registerProject,
   registerAgent,
   redactSecrets,
+  parseRelationRow,
+  parseEntityRow,
   now,
+  mergeEntities,
   loadConfig,
+  listRelations,
   listProjects,
   listMemories,
+  listEntities,
   listAgents,
+  linkEntityToMemory,
+  getRelation,
+  getRelatedEntities,
   getProject,
   getMemoryByKey,
   getMemory,
+  getMemoriesForEntity,
+  getEntityMemoryLinks,
+  getEntityGraph,
+  getEntityByName,
+  getEntity,
+  getEntitiesForMemory,
   getDbPath,
   getDatabase,
   getAgent,
+  findPath,
+  extractEntities,
   enforceQuotas,
   deprioritizeStale,
+  deleteRelation,
   deleteMemory,
+  deleteEntity,
   defaultSyncAgents,
+  createRelation,
   createMemory,
+  createEntity,
   containsSecrets,
   closeDatabase,
   cleanExpiredMemories,
+  bulkLinkEntities,
   bulkDeleteMemories,
   archiveUnused,
   archiveStale,
@@ -1326,6 +2421,7 @@ export {
   MemoryInjector,
   MemoryExpiredError,
   InvalidScopeError,
+  EntityNotFoundError,
   DuplicateMemoryError,
   DEFAULT_CONFIG
 };