@hasna/mementos 0.3.7 → 0.4.1

package/dist/server/index.js

@@ -0,0 +1,2616 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/server/index.ts
+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}`);
+    this.name = "MemoryNotFoundError";
+  }
+}
+
+class DuplicateMemoryError extends Error {
+  constructor(key, scope) {
+    super(`Memory already exists with key "${key}" in scope "${scope}"`);
+    this.name = "DuplicateMemoryError";
+  }
+}
+class VersionConflictError extends Error {
+  expected;
+  actual;
+  constructor(id, expected, actual) {
+    super(`Version conflict for memory ${id}: expected ${expected}, got ${actual}`);
+    this.name = "VersionConflictError";
+    this.expected = expected;
+    this.actual = actual;
+  }
+}
+
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join, resolve } from "path";
+function isInMemoryDb(path) {
+  return path === ":memory:" || path.startsWith("file::memory:");
+}
+function findNearestMementosDb(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    const candidate = join(dir, ".mementos", "mementos.db");
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function findGitRoot(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    if (existsSync(join(dir, ".git")))
+      return dir;
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function getDbPath() {
+  if (process.env["MEMENTOS_DB_PATH"]) {
+    return process.env["MEMENTOS_DB_PATH"];
+  }
+  const cwd = process.cwd();
+  const nearest = findNearestMementosDb(cwd);
+  if (nearest)
+    return nearest;
+  if (process.env["MEMENTOS_DB_SCOPE"] === "project") {
+    const gitRoot = findGitRoot(cwd);
+    if (gitRoot) {
+      return join(gitRoot, ".mementos", "mementos.db");
+    }
+  }
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join(home, ".mementos", "mementos.db");
+}
+function ensureDir(filePath) {
+  if (isInMemoryDb(filePath))
+    return;
+  const dir = dirname(resolve(filePath));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+var MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    path TEXT UNIQUE NOT NULL,
+    description TEXT,
+    memory_prefix TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    role TEXT DEFAULT 'agent',
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS memories (
+    id TEXT PRIMARY KEY,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    category TEXT NOT NULL DEFAULT 'knowledge' CHECK(category IN ('preference', 'fact', 'knowledge', 'history')),
+    scope TEXT NOT NULL DEFAULT 'private' CHECK(scope IN ('global', 'shared', 'private')),
+    summary TEXT,
+    tags TEXT DEFAULT '[]',
+    importance INTEGER NOT NULL DEFAULT 5 CHECK(importance >= 1 AND importance <= 10),
+    source TEXT NOT NULL DEFAULT 'agent' CHECK(source IN ('user', 'agent', 'system', 'auto', 'imported')),
+    status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'archived', 'expired')),
+    pinned INTEGER NOT NULL DEFAULT 0,
+    agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    session_id TEXT,
+    metadata TEXT DEFAULT '{}',
+    access_count INTEGER NOT NULL DEFAULT 0,
+    version INTEGER NOT NULL DEFAULT 1,
+    expires_at TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    accessed_at TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS memory_tags (
+    memory_id TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+    tag TEXT NOT NULL,
+    PRIMARY KEY (memory_id, tag)
+  );
+
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    started_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_activity TEXT NOT NULL DEFAULT (datetime('now')),
+    metadata TEXT DEFAULT '{}'
+  );
+
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_unique_key
+    ON memories(key, scope, COALESCE(agent_id, ''), COALESCE(project_id, ''), COALESCE(session_id, ''));
+
+  CREATE INDEX IF NOT EXISTS idx_memories_key ON memories(key);
+  CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope);
+  CREATE INDEX IF NOT EXISTS idx_memories_category ON memories(category);
+  CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status);
+  CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
+  CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_id);
+  CREATE INDEX IF NOT EXISTS idx_memories_session ON memories(session_id);
+  CREATE INDEX IF NOT EXISTS idx_memories_pinned ON memories(pinned);
+  CREATE INDEX IF NOT EXISTS idx_memories_expires ON memories(expires_at);
+  CREATE INDEX IF NOT EXISTS idx_memories_created ON memories(created_at);
+  CREATE INDEX IF NOT EXISTS idx_memory_tags_tag ON memory_tags(tag);
+  CREATE INDEX IF NOT EXISTS idx_memory_tags_memory ON memory_tags(memory_id);
+  CREATE INDEX IF NOT EXISTS idx_agents_name ON agents(name);
+  CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+
+  CREATE TABLE IF NOT EXISTS _migrations (
+    id INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  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;
+function getDatabase(dbPath) {
+  if (_db)
+    return _db;
+  const path = dbPath || getDbPath();
+  ensureDir(path);
+  _db = new Database(path, { create: true });
+  _db.run("PRAGMA journal_mode = WAL");
+  _db.run("PRAGMA busy_timeout = 5000");
+  _db.run("PRAGMA foreign_keys = ON");
+  runMigrations(_db);
+  return _db;
+}
+function runMigrations(db) {
+  try {
+    const result = db.query("SELECT MAX(id) as max_id FROM _migrations").get();
+    const currentLevel = result?.max_id ?? 0;
+    for (let i = currentLevel;i < MIGRATIONS.length; i++) {
+      try {
+        db.exec(MIGRATIONS[i]);
+      } catch {}
+    }
+  } catch {
+    for (const migration of MIGRATIONS) {
+      try {
+        db.exec(migration);
+      } catch {}
+    }
+  }
+}
+function now() {
+  return new Date().toISOString();
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function shortUuid() {
+  return crypto.randomUUID().slice(0, 8);
+}
+
+// src/lib/redact.ts
+var REDACTED = "[REDACTED]";
+var SECRET_PATTERNS = [
+  { name: "openai_key", pattern: /sk-[a-zA-Z0-9_-]{20,}/g },
+  { name: "anthropic_key", pattern: /sk-ant-[a-zA-Z0-9_-]{20,}/g },
+  { name: "generic_key", pattern: /(?:pk|tok|key|token|api[_-]?key)[_-][a-zA-Z0-9_-]{16,}/gi },
+  { name: "aws_key", pattern: /AKIA[A-Z0-9]{16}/g },
+  { name: "aws_secret", pattern: /(?<=AWS_SECRET_ACCESS_KEY\s*=\s*)[A-Za-z0-9/+=]{40}/g },
+  { name: "github_token", pattern: /gh[ps]_[a-zA-Z0-9]{36,}/g },
+  { name: "github_oauth", pattern: /gho_[a-zA-Z0-9]{36,}/g },
+  { name: "npm_token", pattern: /npm_[a-zA-Z0-9]{36,}/g },
+  { name: "bearer", pattern: /Bearer\s+[a-zA-Z0-9_\-.]{20,}/g },
+  { name: "conn_string", pattern: /(?:postgres|postgresql|mysql|mongodb|redis|amqp|mqtt):\/\/[^\s"'`]+@[^\s"'`]+/gi },
+  { name: "env_secret", pattern: /(?:SECRET|TOKEN|PASSWORD|PASSPHRASE|API_KEY|PRIVATE_KEY|AUTH|CREDENTIAL)[_A-Z]*\s*=\s*["']?[^\s"'\n]{8,}["']?/gi },
+  { name: "stripe_key", pattern: /(?:sk|pk|rk)_(?:test|live)_[a-zA-Z0-9]{20,}/g },
+  { name: "slack_token", pattern: /xox[bpras]-[a-zA-Z0-9-]{20,}/g },
+  { name: "jwt", pattern: /eyJ[a-zA-Z0-9_-]{10,}\.eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/g },
+  { name: "hex_secret", pattern: /(?<=(?:key|token|secret|password|hash)\s*[:=]\s*["']?)[0-9a-f]{32,}(?=["']?)/gi }
+];
+function redactSecrets(text) {
+  let result = text;
+  for (const { pattern } of SECRET_PATTERNS) {
+    pattern.lastIndex = 0;
+    result = result.replace(pattern, REDACTED);
+  }
+  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"],
+    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 listMemories(filter, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter) {
+    if (filter.scope) {
+      if (Array.isArray(filter.scope)) {
+        conditions.push(`scope IN (${filter.scope.map(() => "?").join(",")})`);
+        params.push(...filter.scope);
+      } else {
+        conditions.push("scope = ?");
+        params.push(filter.scope);
+      }
+    }
+    if (filter.category) {
+      if (Array.isArray(filter.category)) {
+        conditions.push(`category IN (${filter.category.map(() => "?").join(",")})`);
+        params.push(...filter.category);
+      } else {
+        conditions.push("category = ?");
+        params.push(filter.category);
+      }
+    }
+    if (filter.source) {
+      if (Array.isArray(filter.source)) {
+        conditions.push(`source IN (${filter.source.map(() => "?").join(",")})`);
+        params.push(...filter.source);
+      } else {
+        conditions.push("source = ?");
+        params.push(filter.source);
+      }
+    }
+    if (filter.status) {
+      if (Array.isArray(filter.status)) {
+        conditions.push(`status IN (${filter.status.map(() => "?").join(",")})`);
+        params.push(...filter.status);
+      } else {
+        conditions.push("status = ?");
+        params.push(filter.status);
+      }
+    } else {
+      conditions.push("status = 'active'");
+    }
+    if (filter.project_id) {
+      conditions.push("project_id = ?");
+      params.push(filter.project_id);
+    }
+    if (filter.agent_id) {
+      conditions.push("agent_id = ?");
+      params.push(filter.agent_id);
+    }
+    if (filter.session_id) {
+      conditions.push("session_id = ?");
+      params.push(filter.session_id);
+    }
+    if (filter.min_importance) {
+      conditions.push("importance >= ?");
+      params.push(filter.min_importance);
+    }
+    if (filter.pinned !== undefined) {
+      conditions.push("pinned = ?");
+      params.push(filter.pinned ? 1 : 0);
+    }
+    if (filter.tags && filter.tags.length > 0) {
+      for (const tag of filter.tags) {
+        conditions.push("id IN (SELECT memory_id FROM memory_tags WHERE tag = ?)");
+        params.push(tag);
+      }
+    }
+    if (filter.search) {
+      conditions.push("(key LIKE ? OR value LIKE ? OR summary LIKE ?)");
+      const term = `%${filter.search}%`;
+      params.push(term, term, term);
+    }
+  } else {
+    conditions.push("status = 'active'");
+  }
+  let sql = "SELECT * FROM memories";
+  if (conditions.length > 0) {
+    sql += ` WHERE ${conditions.join(" AND ")}`;
+  }
+  sql += " ORDER BY importance DESC, created_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(parseMemoryRow);
+}
+function updateMemory(id, input, db) {
+  const d = db || getDatabase();
+  const existing = getMemory(id, d);
+  if (!existing)
+    throw new MemoryNotFoundError(id);
+  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) {
+    sets.push("value = ?");
+    params.push(redactSecrets(input.value));
+  }
+  if (input.category !== undefined) {
+    sets.push("category = ?");
+    params.push(input.category);
+  }
+  if (input.scope !== undefined) {
+    sets.push("scope = ?");
+    params.push(input.scope);
+  }
+  if (input.summary !== undefined) {
+    sets.push("summary = ?");
+    params.push(input.summary);
+  }
+  if (input.importance !== undefined) {
+    sets.push("importance = ?");
+    params.push(input.importance);
+  }
+  if (input.pinned !== undefined) {
+    sets.push("pinned = ?");
+    params.push(input.pinned ? 1 : 0);
+  }
+  if (input.status !== undefined) {
+    sets.push("status = ?");
+    params.push(input.status);
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  if (input.expires_at !== undefined) {
+    sets.push("expires_at = ?");
+    params.push(input.expires_at);
+  }
+  if (input.tags !== undefined) {
+    sets.push("tags = ?");
+    params.push(JSON.stringify(input.tags));
+    d.run("DELETE FROM memory_tags WHERE memory_id = ?", [id]);
+    const insertTag = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
+    for (const tag of input.tags) {
+      insertTag.run(id, tag);
+    }
+  }
+  params.push(id);
+  d.run(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`, params);
+  const updated = getMemory(id, d);
+  try {
+    if (input.value !== undefined) {
+      const oldLinks = getEntityMemoryLinks(undefined, updated.id, d);
+      for (const link of oldLinks) {
+        unlinkEntityFromMemory(link.entity_id, updated.id, d);
+      }
+      runEntityExtraction(updated, existing.project_id || undefined, d);
+    }
+  } catch {}
+  return updated;
+}
+function deleteMemory(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM memories WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+function 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 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) {
+  return {
+    id: row["id"],
+    key: row["key"],
+    value: row["value"],
+    category: row["category"],
+    scope: row["scope"],
+    summary: row["summary"] || null,
+    tags: JSON.parse(row["tags"] || "[]"),
+    importance: row["importance"],
+    source: row["source"],
+    status: row["status"],
+    pinned: !!row["pinned"],
+    agent_id: row["agent_id"] || null,
+    project_id: row["project_id"] || null,
+    session_id: row["session_id"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    access_count: row["access_count"],
+    version: row["version"],
+    expires_at: row["expires_at"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"],
+    accessed_at: row["accessed_at"] || null
+  };
+}
+function preprocessQuery(query) {
+  let q = query.trim();
+  q = q.replace(/\s+/g, " ");
+  q = q.normalize("NFC");
+  return q;
+}
+function escapeLikePattern(s) {
+  return s.replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+var STOP_WORDS = new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "dare",
+  "ought",
+  "used",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "then",
+  "once",
+  "here",
+  "there",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "not",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "just",
+  "because",
+  "but",
+  "and",
+  "or",
+  "if",
+  "while",
+  "that",
+  "this",
+  "it"
+]);
+function removeStopWords(tokens) {
+  if (tokens.length <= 1)
+    return tokens;
+  const filtered = tokens.filter((t) => !STOP_WORDS.has(t.toLowerCase()));
+  return filtered.length > 0 ? filtered : tokens;
+}
+function extractHighlights(memory, queryLower) {
+  const highlights = [];
+  const tokens = queryLower.split(/\s+/).filter(Boolean);
+  for (const field of ["key", "value", "summary"]) {
+    const text = field === "summary" ? memory.summary : memory[field];
+    if (!text)
+      continue;
+    const textLower = text.toLowerCase();
+    const searchTerms = [queryLower, ...tokens].filter(Boolean);
+    for (const term of searchTerms) {
+      const idx = textLower.indexOf(term);
+      if (idx !== -1) {
+        const start = Math.max(0, idx - 30);
+        const end = Math.min(text.length, idx + term.length + 30);
+        const prefix = start > 0 ? "..." : "";
+        const suffix = end < text.length ? "..." : "";
+        highlights.push({
+          field,
+          snippet: prefix + text.slice(start, end) + suffix
+        });
+        break;
+      }
+    }
+  }
+  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) {
+  const fieldScores = [];
+  const keyLower = memory.key.toLowerCase();
+  if (keyLower === queryLower) {
+    fieldScores.push(10);
+  } else if (keyLower.includes(queryLower)) {
+    fieldScores.push(7);
+  }
+  if (memory.tags.some((t) => t.toLowerCase() === queryLower)) {
+    fieldScores.push(6);
+  } else if (memory.tags.some((t) => t.toLowerCase().includes(queryLower))) {
+    fieldScores.push(3);
+  }
+  if (memory.summary && memory.summary.toLowerCase().includes(queryLower)) {
+    fieldScores.push(4);
+  }
+  if (memory.value.toLowerCase().includes(queryLower)) {
+    fieldScores.push(3);
+  }
+  const metadataStr = JSON.stringify(memory.metadata).toLowerCase();
+  if (metadataStr !== "{}" && metadataStr.includes(queryLower)) {
+    fieldScores.push(2);
+  }
+  fieldScores.sort((a, b) => b - a);
+  const diminishingMultipliers = [1, 0.5, 0.25, 0.15, 0.15];
+  let score = 0;
+  for (let i = 0;i < fieldScores.length; i++) {
+    score += fieldScores[i] * (diminishingMultipliers[i] ?? 0.15);
+  }
+  const { phrases } = extractQuotedPhrases(queryLower);
+  for (const phrase of phrases) {
+    if (keyLower.includes(phrase))
+      score += 8;
+    if (memory.value.toLowerCase().includes(phrase))
+      score += 5;
+    if (memory.summary && memory.summary.toLowerCase().includes(phrase))
+      score += 4;
+  }
+  const { remainder } = extractQuotedPhrases(queryLower);
+  const tokens = removeStopWords(remainder.split(/\s+/).filter(Boolean));
+  if (tokens.length > 1) {
+    let tokenScore = 0;
+    for (const token of tokens) {
+      if (keyLower === token) {
+        tokenScore += 10 / tokens.length;
+      } else if (keyLower.includes(token)) {
+        tokenScore += 7 / tokens.length;
+      }
+      if (memory.tags.some((t) => t.toLowerCase() === token)) {
+        tokenScore += 6 / tokens.length;
+      } else if (memory.tags.some((t) => t.toLowerCase().includes(token))) {
+        tokenScore += 3 / tokens.length;
+      }
+      if (memory.summary && memory.summary.toLowerCase().includes(token)) {
+        tokenScore += 4 / tokens.length;
+      }
+      if (memory.value.toLowerCase().includes(token)) {
+        tokenScore += 3 / tokens.length;
+      }
+      if (metadataStr !== "{}" && metadataStr.includes(token)) {
+        tokenScore += 2 / tokens.length;
+      }
+    }
+    if (score > 0) {
+      score += tokenScore * 0.3;
+    } else {
+      score += tokenScore;
+    }
+  }
+  return score;
+}
+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'))");
+  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.source) {
+    if (Array.isArray(filter.source)) {
+      conditions.push(`m.source IN (${filter.source.map(() => "?").join(",")})`);
+      params.push(...filter.source);
+    } else {
+      conditions.push("m.source = ?");
+      params.push(filter.source);
+    }
+  }
+  if (filter.status) {
+    conditions.shift();
+    if (Array.isArray(filter.status)) {
+      conditions.push(`m.status IN (${filter.status.map(() => "?").join(",")})`);
+      params.push(...filter.status);
+    } else {
+      conditions.push("m.status = ?");
+      params.push(filter.status);
+    }
+  }
+  if (filter.project_id) {
+    conditions.push("m.project_id = ?");
+    params.push(filter.project_id);
+  }
+  if (filter.agent_id) {
+    conditions.push("m.agent_id = ?");
+    params.push(filter.agent_id);
+  }
+  if (filter.session_id) {
+    conditions.push("m.session_id = ?");
+    params.push(filter.session_id);
+  }
+  if (filter.min_importance) {
+    conditions.push("m.importance >= ?");
+    params.push(filter.min_importance);
+  }
+  if (filter.pinned !== undefined) {
+    conditions.push("m.pinned = ?");
+    params.push(filter.pinned ? 1 : 0);
+  }
+  if (filter.tags && filter.tags.length > 0) {
+    for (const tag of filter.tags) {
+      conditions.push("m.id IN (SELECT memory_id FROM memory_tags WHERE tag = ?)");
+      params.push(tag);
+    }
+  }
+  return { conditions, params };
+}
+function searchWithFts5(d, query, queryLower, filter, graphBoostedIds) {
+  const ftsQuery = escapeFts5Query(query);
+  if (!ftsQuery)
+    return null;
+  try {
+    const { conditions, params } = buildFilterConditions(filter);
+    const queryParam = `%${query}%`;
+    const ftsCondition = `(m.rowid IN (SELECT f.rowid FROM memories_fts f WHERE memories_fts MATCH ?) ` + `OR m.id IN (SELECT memory_id FROM memory_tags WHERE tag LIKE ?) ` + `OR m.metadata LIKE ?)`;
+    const allConditions = [ftsCondition, ...conditions];
+    const allParams = [ftsQuery, queryParam, queryParam, ...params];
+    const candidateSql = `SELECT m.* FROM memories m WHERE ${allConditions.join(" AND ")}`;
+    const rows = d.query(candidateSql).all(...allParams);
+    return scoreResults(rows, queryLower, graphBoostedIds);
+  } catch {
+    return null;
+  }
+}
+function searchWithLike(d, query, queryLower, filter, graphBoostedIds) {
+  const { conditions, params } = buildFilterConditions(filter);
+  const rawTokens = query.trim().split(/\s+/).filter(Boolean);
+  const tokens = removeStopWords(rawTokens);
+  const escapedQuery = escapeLikePattern(query);
+  const likePatterns = [`%${escapedQuery}%`];
+  if (tokens.length > 1) {
+    for (const t of tokens)
+      likePatterns.push(`%${escapeLikePattern(t)}%`);
+  }
+  const fieldClauses = [];
+  for (const pattern of likePatterns) {
+    fieldClauses.push("m.key LIKE ? ESCAPE '\\'");
+    params.push(pattern);
+    fieldClauses.push("m.value LIKE ? ESCAPE '\\'");
+    params.push(pattern);
+    fieldClauses.push("m.summary LIKE ? ESCAPE '\\'");
+    params.push(pattern);
+    fieldClauses.push("m.metadata LIKE ? ESCAPE '\\'");
+    params.push(pattern);
+    fieldClauses.push("m.id IN (SELECT memory_id FROM memory_tags WHERE tag LIKE ? ESCAPE '\\')");
+    params.push(pattern);
+  }
+  conditions.push(`(${fieldClauses.join(" OR ")})`);
+  const sql = `SELECT DISTINCT m.* FROM memories m WHERE ${conditions.join(" AND ")}`;
+  const rows = d.query(sql).all(...params);
+  return scoreResults(rows, queryLower, graphBoostedIds);
+}
+function generateTrigrams(s) {
+  const lower = s.toLowerCase();
+  const trigrams = new Set;
+  for (let i = 0;i <= lower.length - 3; i++) {
+    trigrams.add(lower.slice(i, i + 3));
+  }
+  return trigrams;
+}
+function trigramSimilarity(a, b) {
+  const triA = generateTrigrams(a);
+  const triB = generateTrigrams(b);
+  if (triA.size === 0 || triB.size === 0)
+    return 0;
+  let intersection = 0;
+  for (const t of triA) {
+    if (triB.has(t))
+      intersection++;
+  }
+  const union = triA.size + triB.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+function searchWithFuzzy(d, query, filter, graphBoostedIds) {
+  const { conditions, params } = buildFilterConditions(filter);
+  const sql = `SELECT m.* FROM memories m WHERE ${conditions.join(" AND ")}`;
+  const rows = d.query(sql).all(...params);
+  const MIN_SIMILARITY = 0.3;
+  const results = [];
+  for (const row of rows) {
+    const memory = parseMemoryRow2(row);
+    let bestSimilarity = 0;
+    bestSimilarity = Math.max(bestSimilarity, trigramSimilarity(query, memory.key));
+    bestSimilarity = Math.max(bestSimilarity, trigramSimilarity(query, memory.value.slice(0, 200)));
+    if (memory.summary) {
+      bestSimilarity = Math.max(bestSimilarity, trigramSimilarity(query, memory.summary));
+    }
+    for (const tag of memory.tags) {
+      bestSimilarity = Math.max(bestSimilarity, trigramSimilarity(query, tag));
+    }
+    if (bestSimilarity >= MIN_SIMILARITY) {
+      const graphBoost = graphBoostedIds?.has(memory.id) ? 2 : 0;
+      const score = bestSimilarity * 5 * memory.importance / 10 + graphBoost;
+      results.push({ memory, score, match_type: "fuzzy" });
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results;
+}
+function getGraphBoostedMemoryIds(query, d) {
+  const boostedIds = new Set;
+  try {
+    const matchingEntities = listEntities({ search: query, limit: 10 }, d);
+    const exactMatch = getEntityByName(query, undefined, undefined, d);
+    if (exactMatch && !matchingEntities.find((e) => e.id === exactMatch.id)) {
+      matchingEntities.push(exactMatch);
+    }
+    for (const entity of matchingEntities) {
+      const memories = getMemoriesForEntity(entity.id, d);
+      for (const mem of memories) {
+        boostedIds.add(mem.id);
+      }
+    }
+  } catch {}
+  return boostedIds;
+}
+function computeRecencyBoost(memory) {
+  if (memory.pinned)
+    return 1;
+  const mostRecent = memory.accessed_at || memory.updated_at;
+  if (!mostRecent)
+    return 0;
+  const daysSinceAccess = (Date.now() - Date.parse(mostRecent)) / (1000 * 60 * 60 * 24);
+  return Math.max(0, 1 - daysSinceAccess / 30);
+}
+function scoreResults(rows, queryLower, graphBoostedIds) {
+  const scored = [];
+  for (const row of rows) {
+    const memory = parseMemoryRow2(row);
+    const rawScore = computeScore(memory, queryLower);
+    if (rawScore === 0)
+      continue;
+    const weightedScore = rawScore * memory.importance / 10;
+    const recencyBoost = computeRecencyBoost(memory);
+    const accessBoost = Math.min(memory.access_count / 20, 0.2);
+    const graphBoost = graphBoostedIds?.has(memory.id) ? 2 : 0;
+    const finalScore = (weightedScore + graphBoost) * (1 + recencyBoost * 0.3) * (1 + accessBoost);
+    const matchType = determineMatchType(memory, queryLower);
+    scored.push({
+      memory,
+      score: finalScore,
+      match_type: matchType,
+      highlights: extractHighlights(memory, queryLower)
+    });
+  }
+  scored.sort((a, b) => {
+    if (b.score !== a.score)
+      return b.score - a.score;
+    return b.memory.importance - a.memory.importance;
+  });
+  return scored;
+}
+function searchMemories(query, filter, db) {
+  const d = db || getDatabase();
+  query = preprocessQuery(query);
+  if (!query)
+    return [];
+  const queryLower = query.toLowerCase();
+  const graphBoostedIds = getGraphBoostedMemoryIds(query, d);
+  let scored;
+  if (hasFts5Table(d)) {
+    const ftsResult = searchWithFts5(d, query, queryLower, filter, graphBoostedIds);
+    if (ftsResult !== null) {
+      scored = ftsResult;
+    } else {
+      scored = searchWithLike(d, query, queryLower, filter, graphBoostedIds);
+    }
+  } 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;
+  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;
+function parsePort() {
+  const envPort = process.env["PORT"];
+  if (envPort) {
+    const p = parseInt(envPort, 10);
+    if (!Number.isNaN(p))
+      return p;
+  }
+  const portArg = process.argv.find((a) => a === "--port" || a.startsWith("--port="));
+  if (portArg) {
+    if (portArg.includes("=")) {
+      return parseInt(portArg.split("=")[1], 10) || DEFAULT_PORT;
+    }
+    const idx = process.argv.indexOf(portArg);
+    return parseInt(process.argv[idx + 1], 10) || DEFAULT_PORT;
+  }
+  return DEFAULT_PORT;
+}
+function resolveDashboardDir() {
+  const candidates = [];
+  try {
+    const scriptDir = dirname3(fileURLToPath(import.meta.url));
+    candidates.push(join3(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join3(scriptDir, "..", "..", "dashboard", "dist"));
+  } catch {}
+  if (process.argv[1]) {
+    const mainDir = dirname3(process.argv[1]);
+    candidates.push(join3(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join3(mainDir, "..", "..", "dashboard", "dist"));
+  }
+  candidates.push(join3(process.cwd(), "dashboard", "dist"));
+  for (const c of candidates) {
+    if (existsSync3(c))
+      return c;
+  }
+  return join3(process.cwd(), "dashboard", "dist");
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function serveStaticFile(filePath) {
+  if (!existsSync3(filePath))
+    return null;
+  const ct = MIME_TYPES[extname(filePath)] || "application/octet-stream";
+  return new Response(Bun.file(filePath), {
+    headers: { "Content-Type": ct }
+  });
+}
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization",
+  "Access-Control-Max-Age": "86400"
+};
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", ...CORS_HEADERS }
+  });
+}
+function errorResponse(message, status, details) {
+  const body = { error: message };
+  if (details !== undefined)
+    body["details"] = details;
+  return json(body, status);
+}
+async function readJson(req) {
+  try {
+    return await req.json();
+  } catch {
+    return null;
+  }
+}
+function getSearchParams(url) {
+  const params = {};
+  url.searchParams.forEach((v, k) => {
+    params[k] = v;
+  });
+  return params;
+}
+var routes = [];
+function addRoute(method, path, handler) {
+  const paramNames = [];
+  const patternStr = path.replace(/:(\w+)/g, (_match, name) => {
+    paramNames.push(name);
+    return "([^/]+)";
+  });
+  routes.push({
+    method,
+    pattern: new RegExp(`^${patternStr}$`),
+    paramNames,
+    handler
+  });
+}
+function matchRoute(method, pathname) {
+  for (const route of routes) {
+    if (route.method !== method)
+      continue;
+    const match = pathname.match(route.pattern);
+    if (match) {
+      const params = {};
+      route.paramNames.forEach((name, i) => {
+        params[name] = match[i + 1];
+      });
+      return { handler: route.handler, params };
+    }
+  }
+  return null;
+}
+addRoute("GET", "/api/memories", (_req, url) => {
+  const q = getSearchParams(url);
+  const filter = {};
+  if (q["scope"])
+    filter.scope = q["scope"];
+  if (q["category"])
+    filter.category = q["category"];
+  if (q["tags"])
+    filter.tags = q["tags"].split(",");
+  if (q["min_importance"])
+    filter.min_importance = parseInt(q["min_importance"], 10);
+  if (q["pinned"] !== undefined && q["pinned"] !== "")
+    filter.pinned = q["pinned"] === "true";
+  if (q["agent_id"])
+    filter.agent_id = q["agent_id"];
+  if (q["project_id"])
+    filter.project_id = q["project_id"];
+  if (q["limit"])
+    filter.limit = parseInt(q["limit"], 10);
+  if (q["offset"])
+    filter.offset = parseInt(q["offset"], 10);
+  const memories = listMemories(filter);
+  if (q["fields"]) {
+    const fields = q["fields"].split(",").map((f) => f.trim());
+    const filtered = memories.map((m) => Object.fromEntries(fields.map((f) => [f, m[f]]).filter(([, v]) => v !== undefined)));
+    return json({ memories: filtered, count: filtered.length });
+  }
+  return json({ memories, count: memories.length });
+});
+addRoute("GET", "/api/memories/stats", (_req) => {
+  const db = getDatabase();
+  const total = db.query("SELECT COUNT(*) as c FROM memories WHERE status = 'active'").get().c;
+  const byScope = db.query("SELECT scope, COUNT(*) as c FROM memories WHERE status = 'active' GROUP BY scope").all();
+  const byCategory = db.query("SELECT category, COUNT(*) as c FROM memories WHERE status = 'active' GROUP BY category").all();
+  const byStatus = db.query("SELECT status, COUNT(*) as c FROM memories GROUP BY status").all();
+  const pinnedCount = db.query("SELECT COUNT(*) as c FROM memories WHERE pinned = 1 AND status = 'active'").get().c;
+  const expiredCount = db.query("SELECT COUNT(*) as c FROM memories WHERE status = 'expired' OR (expires_at IS NOT NULL AND expires_at < datetime('now'))").get().c;
+  const stats = {
+    total,
+    by_scope: { global: 0, shared: 0, private: 0 },
+    by_category: { preference: 0, fact: 0, knowledge: 0, history: 0 },
+    by_status: { active: 0, archived: 0, expired: 0 },
+    by_agent: {},
+    pinned_count: pinnedCount,
+    expired_count: expiredCount
+  };
+  for (const row of byScope)
+    stats.by_scope[row.scope] = row.c;
+  for (const row of byCategory)
+    stats.by_category[row.category] = row.c;
+  for (const row of byStatus) {
+    if (row.status in stats.by_status) {
+      stats.by_status[row.status] = row.c;
+    }
+  }
+  const byAgent = db.query("SELECT agent_id, COUNT(*) as c FROM memories WHERE status = 'active' AND agent_id IS NOT NULL GROUP BY agent_id").all();
+  for (const row of byAgent)
+    stats.by_agent[row.agent_id] = row.c;
+  return json(stats);
+});
+addRoute("POST", "/api/memories/search", async (req) => {
+  const body = await readJson(req);
+  if (!body || typeof body["query"] !== "string") {
+    return errorResponse("Missing required field: query", 400);
+  }
+  const filter = {};
+  if (body["scope"])
+    filter.scope = body["scope"];
+  if (body["category"])
+    filter.category = body["category"];
+  if (body["tags"])
+    filter.tags = body["tags"];
+  if (body["limit"])
+    filter.limit = body["limit"];
+  const results = searchMemories(body["query"], filter);
+  return json({ results, count: results.length });
+});
+addRoute("POST", "/api/memories/export", async (req) => {
+  const body = await readJson(req) || {};
+  const filter = {};
+  if (body["scope"])
+    filter.scope = body["scope"];
+  if (body["category"])
+    filter.category = body["category"];
+  if (body["agent_id"])
+    filter.agent_id = body["agent_id"];
+  if (body["project_id"])
+    filter.project_id = body["project_id"];
+  if (body["tags"])
+    filter.tags = body["tags"];
+  filter.limit = body["limit"] || 1e4;
+  const memories = listMemories(filter);
+  return json({ memories, count: memories.length });
+});
+addRoute("POST", "/api/memories/import", async (req) => {
+  const body = await readJson(req);
+  if (!body || !Array.isArray(body["memories"])) {
+    return errorResponse("Missing required field: memories (array)", 400);
+  }
+  const overwrite = body["overwrite"] !== false;
+  const dedupeMode = overwrite ? "merge" : "create";
+  const memoriesArr = body["memories"];
+  let imported = 0;
+  const errors = [];
+  for (const mem of memoriesArr) {
+    try {
+      createMemory({
+        ...mem,
+        source: mem["source"] || "imported"
+      }, dedupeMode);
+      imported++;
+    } catch (e) {
+      errors.push(`Failed to import "${mem["key"]}": ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  return json({ imported, errors, total: memoriesArr.length }, 201);
+});
+addRoute("POST", "/api/memories/clean", () => {
+  const cleaned = cleanExpiredMemories();
+  return json({ cleaned });
+});
+addRoute("POST", "/api/memories", async (req) => {
+  const body = await readJson(req);
+  if (!body) {
+    return errorResponse("Invalid JSON body", 400);
+  }
+  if (!body["key"] || !body["value"]) {
+    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) {
+    if (e instanceof DuplicateMemoryError) {
+      return errorResponse(e.message, 409);
+    }
+    throw e;
+  }
+});
+addRoute("GET", "/api/memories/:id", (_req, _url, params) => {
+  const memory = getMemory(params["id"]);
+  if (!memory) {
+    return errorResponse("Memory not found", 404);
+  }
+  touchMemory(memory.id);
+  return json(memory);
+});
+addRoute("PATCH", "/api/memories/:id", async (req, _url, params) => {
+  const body = await readJson(req);
+  if (!body) {
+    return errorResponse("Invalid JSON body", 400);
+  }
+  if (body["version"] === undefined) {
+    return errorResponse("Missing required field: version", 400);
+  }
+  try {
+    const memory = updateMemory(params["id"], body);
+    return json(memory);
+  } catch (e) {
+    if (e instanceof MemoryNotFoundError) {
+      return errorResponse(e.message, 404);
+    }
+    if (e instanceof VersionConflictError) {
+      return errorResponse(e.message, 409, {
+        expected: e.expected,
+        actual: e.actual
+      });
+    }
+    throw e;
+  }
+});
+addRoute("DELETE", "/api/memories/:id", (_req, _url, params) => {
+  const deleted = deleteMemory(params["id"]);
+  if (!deleted) {
+    return errorResponse("Memory not found", 404);
+  }
+  return json({ deleted: true });
+});
+addRoute("GET", "/api/agents", () => {
+  const agents = listAgents();
+  return json({ agents, count: agents.length });
+});
+addRoute("POST", "/api/agents", async (req) => {
+  const body = await readJson(req);
+  if (!body || !body["name"]) {
+    return errorResponse("Missing required field: name", 400);
+  }
+  const agent = registerAgent(body["name"], body["description"], body["role"]);
+  return json(agent, 201);
+});
+addRoute("GET", "/api/agents/:id", (_req, _url, params) => {
+  const agent = getAgent(params["id"]);
+  if (!agent) {
+    return errorResponse("Agent not found", 404);
+  }
+  return json(agent);
+});
+addRoute("GET", "/api/projects", () => {
+  const projects = listProjects();
+  return json({ projects, count: projects.length });
+});
+addRoute("POST", "/api/projects", async (req) => {
+  const body = await readJson(req);
+  if (!body || !body["name"] || !body["path"]) {
+    return errorResponse("Missing required fields: name, path", 400);
+  }
+  const project = registerProject(body["name"], body["path"], body["description"], body["memory_prefix"]);
+  return json(project, 201);
+});
+addRoute("GET", "/api/inject", (_req, url) => {
+  const q = getSearchParams(url);
+  const maxTokens = q["max_tokens"] ? parseInt(q["max_tokens"], 10) : 500;
+  const minImportance = 3;
+  const categories = [
+    "preference",
+    "fact",
+    "knowledge"
+  ];
+  const allMemories = [];
+  const globalMems = listMemories({
+    scope: "global",
+    category: categories,
+    min_importance: minImportance,
+    status: "active",
+    project_id: q["project_id"],
+    limit: 50
+  });
+  allMemories.push(...globalMems);
+  if (q["project_id"]) {
+    const sharedMems = listMemories({
+      scope: "shared",
+      category: categories,
+      min_importance: minImportance,
+      status: "active",
+      project_id: q["project_id"],
+      limit: 50
+    });
+    allMemories.push(...sharedMems);
+  }
+  if (q["agent_id"]) {
+    const privateMems = listMemories({
+      scope: "private",
+      category: categories,
+      min_importance: minImportance,
+      status: "active",
+      agent_id: q["agent_id"],
+      limit: 50
+    });
+    allMemories.push(...privateMems);
+  }
+  const seen = new Set;
+  const unique = allMemories.filter((m) => {
+    if (seen.has(m.id))
+      return false;
+    seen.add(m.id);
+    return true;
+  });
+  unique.sort((a, b) => {
+    if (b.importance !== a.importance)
+      return b.importance - a.importance;
+    return new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime();
+  });
+  const charBudget = maxTokens * 4;
+  const lines = [];
+  let totalChars = 0;
+  for (const m of unique) {
+    const line = `- [${m.scope}/${m.category}] ${m.key}: ${m.value}`;
+    if (totalChars + line.length > charBudget)
+      break;
+    lines.push(line);
+    totalChars += line.length;
+    touchMemory(m.id);
+  }
+  if (lines.length === 0) {
+    return json({ context: "", memories_count: 0 });
+  }
+  const context = `<agent-memories>
+${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 {
+      const server = Bun.serve({ port, fetch: () => new Response("") });
+      server.stop(true);
+      return port;
+    } catch {}
+  }
+  return start;
+}
+function startServer(port) {
+  Bun.serve({
+    port,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const { pathname } = url;
+      if (req.method === "OPTIONS") {
+        return new Response(null, { status: 204, headers: CORS_HEADERS });
+      }
+      if (pathname === "/api/health" || pathname === "/health") {
+        return json({ status: "ok", version: "0.1.0" });
+      }
+      if (pathname === "/api/memories/stream" && req.method === "GET") {
+        const stream = new ReadableStream({
+          start(controller) {
+            const encoder = new TextEncoder;
+            let lastSeen = new Date().toISOString();
+            const send = (data) => {
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+            };
+            send({ type: "connected", timestamp: lastSeen });
+            const interval = setInterval(() => {
+              try {
+                const db = getDatabase();
+                const rows = db.query("SELECT * FROM memories WHERE updated_at > ? OR created_at > ? ORDER BY updated_at DESC LIMIT 50").all(lastSeen, lastSeen);
+                if (rows.length > 0) {
+                  lastSeen = new Date().toISOString();
+                  send({ type: "memories", data: rows, count: rows.length });
+                }
+              } catch {}
+            }, 1000);
+            req.signal.addEventListener("abort", () => {
+              clearInterval(interval);
+              controller.close();
+            });
+          }
+        });
+        return new Response(stream, {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            ...CORS_HEADERS
+          }
+        });
+      }
+      const matched = matchRoute(req.method, pathname);
+      if (!matched) {
+        if (pathname.startsWith("/api/")) {
+          return errorResponse("Not found", 404);
+        }
+        const dashDir = resolveDashboardDir();
+        if (existsSync3(dashDir) && (req.method === "GET" || req.method === "HEAD")) {
+          if (pathname !== "/") {
+            const staticRes = serveStaticFile(join3(dashDir, pathname));
+            if (staticRes)
+              return staticRes;
+          }
+          const indexRes = serveStaticFile(join3(dashDir, "index.html"));
+          if (indexRes)
+            return indexRes;
+        }
+        return errorResponse("Not found", 404);
+      }
+      try {
+        return await matched.handler(req, url, matched.params);
+      } catch (e) {
+        console.error(`[mementos-serve] ${req.method} ${pathname}:`, e);
+        const message = e instanceof Error ? e.message : "Internal server error";
+        return errorResponse(message, 500);
+      }
+    }
+  });
+  console.log(`Mementos server listening on http://localhost:${port}`);
+}
+async function main() {
+  const requestedPort = parsePort();
+  const port = await findFreePort(requestedPort);
+  if (port !== requestedPort) {
+    console.log(`Port ${requestedPort} in use, using ${port}`);
+  }
+  startServer(port);
+}
+main();
+export {
+  startServer
+};