@hasna/mementos 0.3.9 → 0.4.1

package/dist/server/index.js

@@ -2,11 +2,18 @@
 // @bun
 
 // src/server/index.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname2, extname, join as join2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname3, extname, join as join3 } from "path";
 import { fileURLToPath } from "url";
 
 // 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}`);
@@ -175,6 +182,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;
@@ -245,7 +359,656 @@ function redactSecrets(text) {
   return result;
 }
 
+// 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 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
+      ]);
+    }
+    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, normalizedName, 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 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);
+}
+
+// src/db/projects.ts
+function parseProjectRow(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    path: row["path"],
+    description: row["description"] || null,
+    memory_prefix: row["memory_prefix"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"]
+  };
+}
+function registerProject(name, path, description, memoryPrefix, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  const existing = d.query("SELECT * FROM projects WHERE path = ?").get(path);
+  if (existing) {
+    const existingId = existing["id"];
+    d.run("UPDATE projects SET updated_at = ? WHERE id = ?", [
+      timestamp,
+      existingId
+    ]);
+    return parseProjectRow(existing);
+  }
+  const id = uuid();
+  d.run("INSERT INTO projects (id, name, path, description, memory_prefix, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)", [id, name, path, description || null, memoryPrefix || null, timestamp, timestamp]);
+  return getProject(id, d);
+}
+function getProject(idOrPath, db) {
+  const d = db || getDatabase();
+  let row = d.query("SELECT * FROM projects WHERE id = ?").get(idOrPath);
+  if (row)
+    return parseProjectRow(row);
+  row = d.query("SELECT * FROM projects WHERE path = ?").get(idOrPath);
+  if (row)
+    return parseProjectRow(row);
+  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 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 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 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 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 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(parseEntityRow2);
+  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(parseEntityRow2(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"],
@@ -312,7 +1075,15 @@ function createMemory(input, dedupeMode = "merge", db) {
       for (const tag of tags) {
         insertTag2.run(existing.id, tag);
       }
-      return getMemory(existing.id, d);
+      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)
@@ -338,7 +1109,11 @@ function createMemory(input, dedupeMode = "merge", db) {
   for (const tag of tags) {
     insertTag.run(id, tag);
   }
-  return getMemory(id, d);
+  const memory = getMemory(id, d);
+  try {
+    runEntityExtraction(memory, input.project_id, d);
+  } catch {}
+  return memory;
 }
 function getMemory(id, db) {
   const d = db || getDatabase();
@@ -448,6 +1223,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) {
@@ -497,7 +1289,17 @@ function updateMemory(id, input, db) {
   }
   params.push(id);
   d.run(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`, params);
-  return getMemory(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;
 }
 function deleteMemory(id, db) {
   const d = db || getDatabase();
@@ -510,112 +1312,13 @@ function touchMemory(id, db) {
 }
 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);
-}
-
-// src/db/projects.ts
-function parseProjectRow(row) {
-  return {
-    id: row["id"],
-    name: row["name"],
-    path: row["path"],
-    description: row["description"] || null,
-    memory_prefix: row["memory_prefix"] || null,
-    created_at: row["created_at"],
-    updated_at: row["updated_at"]
-  };
-}
-function registerProject(name, path, description, memoryPrefix, db) {
-  const d = db || getDatabase();
-  const timestamp = now();
-  const existing = d.query("SELECT * FROM projects WHERE path = ?").get(path);
-  if (existing) {
-    const existingId = existing["id"];
-    d.run("UPDATE projects SET updated_at = ? WHERE id = ?", [
-      timestamp,
-      existingId
-    ]);
-    return parseProjectRow(existing);
-  }
-  const id = uuid();
-  d.run("INSERT INTO projects (id, name, path, description, memory_prefix, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)", [id, name, path, description || null, memoryPrefix || null, timestamp, timestamp]);
-  return getProject(id, d);
-}
-function getProject(idOrPath, db) {
-  const d = db || getDatabase();
-  let row = d.query("SELECT * FROM projects WHERE id = ?").get(idOrPath);
-  if (row)
-    return parseProjectRow(row);
-  row = d.query("SELECT * FROM projects WHERE path = ?").get(idOrPath);
-  if (row)
-    return parseProjectRow(row);
-  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);
+  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
@@ -644,109 +1347,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);
@@ -754,11 +1790,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) => {
@@ -766,10 +1807,97 @@ function searchMemories(query, filter, db) {
       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);
+    }
+  } 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;
+    });
+  }
   const offset = filter?.offset ?? 0;
   const limit = filter?.limit ?? scored.length;
-  return scored.slice(offset, offset + limit);
+  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/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);
+  }
+  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.`);
+  }
+  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];
+  }
+  if (total === 0) {
+    throw new Error(`Invalid duration: "${trimmed}" resolves to 0ms`);
+  }
+  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/server/index.ts
 var DEFAULT_PORT = 19428;
@@ -793,21 +1921,21 @@ function parsePort() {
 function resolveDashboardDir() {
   const candidates = [];
   try {
-    const scriptDir = dirname2(fileURLToPath(import.meta.url));
-    candidates.push(join2(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join2(scriptDir, "..", "..", "dashboard", "dist"));
+    const scriptDir = dirname3(fileURLToPath(import.meta.url));
+    candidates.push(join3(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join3(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
-    const mainDir = dirname2(process.argv[1]);
-    candidates.push(join2(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join2(mainDir, "..", "..", "dashboard", "dist"));
+    const mainDir = dirname3(process.argv[1]);
+    candidates.push(join3(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join3(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join2(process.cwd(), "dashboard", "dist"));
+  candidates.push(join3(process.cwd(), "dashboard", "dist"));
   for (const c of candidates) {
-    if (existsSync2(c))
+    if (existsSync3(c))
       return c;
   }
-  return join2(process.cwd(), "dashboard", "dist");
+  return join3(process.cwd(), "dashboard", "dist");
 }
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
@@ -821,7 +1949,7 @@ var MIME_TYPES = {
   ".woff2": "font/woff2"
 };
 function serveStaticFile(filePath) {
-  if (!existsSync2(filePath))
+  if (!existsSync3(filePath))
     return null;
   const ct = MIME_TYPES[extname(filePath)] || "application/octet-stream";
   return new Response(Bun.file(filePath), {
@@ -1019,6 +2147,9 @@ addRoute("POST", "/api/memories", async (req) => {
     return errorResponse("Missing required fields: key, value", 400);
   }
   try {
+    if (body["ttl_ms"] !== undefined && typeof body["ttl_ms"] === "string") {
+      body["ttl_ms"] = parseDuration(body["ttl_ms"]);
+    }
     const memory = createMemory(body);
     return json(memory, 201);
   } catch (e) {
@@ -1171,6 +2302,219 @@ ${lines.join(`
 </agent-memories>`;
   return json({ context, memories_count: lines.length });
 });
+addRoute("GET", "/api/entities", (_req, url) => {
+  const q = getSearchParams(url);
+  const filter = {};
+  if (q["type"])
+    filter.type = q["type"];
+  if (q["project_id"])
+    filter.project_id = q["project_id"];
+  if (q["search"])
+    filter.search = q["search"];
+  if (q["limit"])
+    filter.limit = parseInt(q["limit"], 10);
+  if (q["offset"])
+    filter.offset = parseInt(q["offset"], 10);
+  const entities = listEntities(filter);
+  return json({ entities, count: entities.length });
+});
+addRoute("POST", "/api/entities/merge", async (req) => {
+  const body = await readJson(req);
+  if (!body || !body["source_id"] || !body["target_id"]) {
+    return errorResponse("Missing required fields: source_id, target_id", 400);
+  }
+  try {
+    const merged = mergeEntities(body["source_id"], body["target_id"]);
+    return json(merged);
+  } catch (e) {
+    if (e instanceof EntityNotFoundError) {
+      return errorResponse(e.message, 404);
+    }
+    throw e;
+  }
+});
+addRoute("POST", "/api/entities", async (req) => {
+  const body = await readJson(req);
+  if (!body || !body["name"] || !body["type"]) {
+    return errorResponse("Missing required fields: name, type", 400);
+  }
+  try {
+    const entity = createEntity(body);
+    return json(entity, 201);
+  } catch (e) {
+    throw e;
+  }
+});
+addRoute("GET", "/api/entities/:id/memories", (_req, _url, params) => {
+  try {
+    getEntity(params["id"]);
+    const memories = getMemoriesForEntity(params["id"]);
+    return json({ memories, count: memories.length });
+  } catch (e) {
+    if (e instanceof EntityNotFoundError) {
+      return errorResponse(e.message, 404);
+    }
+    throw e;
+  }
+});
+addRoute("POST", "/api/entities/:id/memories", async (req, _url, params) => {
+  const body = await readJson(req);
+  if (!body || !body["memory_id"]) {
+    return errorResponse("Missing required field: memory_id", 400);
+  }
+  try {
+    const link = linkEntityToMemory(params["id"], body["memory_id"], body["role"] || undefined);
+    return json(link, 201);
+  } catch (e) {
+    if (e instanceof EntityNotFoundError) {
+      return errorResponse(e.message, 404);
+    }
+    throw e;
+  }
+});
+addRoute("GET", "/api/entities/:id/relations", (_req, url, params) => {
+  const q = getSearchParams(url);
+  try {
+    getEntity(params["id"]);
+    const relations = listRelations({
+      entity_id: params["id"],
+      relation_type: q["type"],
+      direction: q["direction"]
+    });
+    return json({ relations, count: relations.length });
+  } catch (e) {
+    if (e instanceof EntityNotFoundError) {
+      return errorResponse(e.message, 404);
+    }
+    throw e;
+  }
+});
+addRoute("DELETE", "/api/entities/:entityId/memories/:memoryId", (_req, _url, params) => {
+  unlinkEntityFromMemory(params["entityId"], params["memoryId"]);
+  return json({ deleted: true });
+});
+addRoute("GET", "/api/entities/:id", (_req, _url, params) => {
+  try {
+    const entity = getEntity(params["id"]);
+    const relations = listRelations({ entity_id: params["id"] });
+    const memories = getMemoriesForEntity(params["id"]);
+    return json({ ...entity, relations, memories });
+  } catch (e) {
+    if (e instanceof EntityNotFoundError) {
+      return errorResponse(e.message, 404);
+    }
+    throw e;
+  }
+});
+addRoute("PATCH", "/api/entities/:id", async (req, _url, params) => {
+  const body = await readJson(req);
+  if (!body) {
+    return errorResponse("Invalid JSON body", 400);
+  }
+  try {
+    const entity = updateEntity(params["id"], body);
+    return json(entity);
+  } catch (e) {
+    if (e instanceof EntityNotFoundError) {
+      return errorResponse(e.message, 404);
+    }
+    throw e;
+  }
+});
+addRoute("DELETE", "/api/entities/:id", (_req, _url, params) => {
+  try {
+    deleteEntity(params["id"]);
+    return json({ deleted: true });
+  } catch (e) {
+    if (e instanceof EntityNotFoundError) {
+      return errorResponse(e.message, 404);
+    }
+    throw e;
+  }
+});
+addRoute("POST", "/api/relations", async (req) => {
+  const body = await readJson(req);
+  if (!body || !body["source_entity_id"] || !body["target_entity_id"] || !body["relation_type"]) {
+    return errorResponse("Missing required fields: source_entity_id, target_entity_id, relation_type", 400);
+  }
+  try {
+    const relation = createRelation(body);
+    return json(relation, 201);
+  } catch (e) {
+    throw e;
+  }
+});
+addRoute("GET", "/api/relations/:id", (_req, _url, params) => {
+  try {
+    const relation = getRelation(params["id"]);
+    return json(relation);
+  } catch (e) {
+    if (e instanceof Error && e.message.startsWith("Relation not found")) {
+      return errorResponse(e.message, 404);
+    }
+    throw e;
+  }
+});
+addRoute("DELETE", "/api/relations/:id", (_req, _url, params) => {
+  try {
+    deleteRelation(params["id"]);
+    return json({ deleted: true });
+  } catch (e) {
+    if (e instanceof Error && e.message.startsWith("Relation not found")) {
+      return errorResponse(e.message, 404);
+    }
+    throw e;
+  }
+});
+addRoute("GET", "/api/graph/path", (_req, url) => {
+  const q = getSearchParams(url);
+  if (!q["from"] || !q["to"]) {
+    return errorResponse("Missing required query params: from, to", 400);
+  }
+  const maxDepth = q["max_depth"] ? parseInt(q["max_depth"], 10) : 5;
+  try {
+    const path = findPath(q["from"], q["to"], maxDepth);
+    if (!path) {
+      return json({ path: null, found: false });
+    }
+    return json({ path, found: true, length: path.length });
+  } catch (e) {
+    if (e instanceof EntityNotFoundError) {
+      return errorResponse(e.message, 404);
+    }
+    throw e;
+  }
+});
+addRoute("GET", "/api/graph/stats", () => {
+  const db = getDatabase();
+  const entityCount = db.query("SELECT COUNT(*) as c FROM entities").get().c;
+  const relationCount = db.query("SELECT COUNT(*) as c FROM relations").get().c;
+  const entitiesByType = db.query("SELECT type, COUNT(*) as c FROM entities GROUP BY type").all();
+  const relationsByType = db.query("SELECT relation_type, COUNT(*) as c FROM relations GROUP BY relation_type").all();
+  return json({
+    entities: {
+      total: entityCount,
+      by_type: Object.fromEntries(entitiesByType.map((r) => [r.type, r.c]))
+    },
+    relations: {
+      total: relationCount,
+      by_type: Object.fromEntries(relationsByType.map((r) => [r.relation_type, r.c]))
+    }
+  });
+});
+addRoute("GET", "/api/graph/:entityId", (_req, url, params) => {
+  const q = getSearchParams(url);
+  const depth = q["depth"] ? parseInt(q["depth"], 10) : 2;
+  try {
+    const graph = getEntityGraph(params["entityId"], depth);
+    return json(graph);
+  } catch (e) {
+    if (e instanceof EntityNotFoundError) {
+      return errorResponse(e.message, 404);
+    }
+    throw e;
+  }
+});
 async function findFreePort(start) {
   for (let port = start;port < start + 100; port++) {
     try {
@@ -1235,13 +2579,13 @@ function startServer(port) {
           return errorResponse("Not found", 404);
         }
         const dashDir = resolveDashboardDir();
-        if (existsSync2(dashDir) && (req.method === "GET" || req.method === "HEAD")) {
+        if (existsSync3(dashDir) && (req.method === "GET" || req.method === "HEAD")) {
           if (pathname !== "/") {
-            const staticRes = serveStaticFile(join2(dashDir, pathname));
+            const staticRes = serveStaticFile(join3(dashDir, pathname));
             if (staticRes)
               return staticRes;
           }
-          const indexRes = serveStaticFile(join2(dashDir, "index.html"));
+          const indexRes = serveStaticFile(join3(dashDir, "index.html"));
           if (indexRes)
             return indexRes;
         }