engrams 0.1.0

package/dist/index.js

@@ -0,0 +1,2113 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../core/dist/schema.js
+var schema_exports = {};
+__export(schema_exports, {
+  agentPermissions: () => agentPermissions,
+  memories: () => memories,
+  memoryConnections: () => memoryConnections,
+  memoryEvents: () => memoryEvents
+});
+import { sqliteTable, text, real, integer } from "drizzle-orm/sqlite-core";
+var memories, memoryConnections, memoryEvents, agentPermissions;
+var init_schema = __esm({
+  "../core/dist/schema.js"() {
+    "use strict";
+    memories = sqliteTable("memories", {
+      id: text("id").primaryKey(),
+      content: text("content").notNull(),
+      detail: text("detail"),
+      domain: text("domain").notNull().default("general"),
+      sourceAgentId: text("source_agent_id").notNull(),
+      sourceAgentName: text("source_agent_name").notNull(),
+      crossAgentId: text("cross_agent_id"),
+      crossAgentName: text("cross_agent_name"),
+      sourceType: text("source_type").notNull(),
+      sourceDescription: text("source_description"),
+      confidence: real("confidence").notNull().default(0.7),
+      confirmedCount: integer("confirmed_count").notNull().default(0),
+      correctedCount: integer("corrected_count").notNull().default(0),
+      mistakeCount: integer("mistake_count").notNull().default(0),
+      usedCount: integer("used_count").notNull().default(0),
+      learnedAt: text("learned_at"),
+      confirmedAt: text("confirmed_at"),
+      lastUsedAt: text("last_used_at"),
+      deletedAt: text("deleted_at"),
+      hasPiiFlag: integer("has_pii_flag").notNull().default(0),
+      entityType: text("entity_type"),
+      entityName: text("entity_name"),
+      structuredData: text("structured_data")
+    });
+    memoryConnections = sqliteTable("memory_connections", {
+      sourceMemoryId: text("source_memory_id").notNull().references(() => memories.id),
+      targetMemoryId: text("target_memory_id").notNull().references(() => memories.id),
+      relationship: text("relationship").notNull()
+    });
+    memoryEvents = sqliteTable("memory_events", {
+      id: text("id").primaryKey(),
+      memoryId: text("memory_id").notNull().references(() => memories.id),
+      eventType: text("event_type").notNull(),
+      agentId: text("agent_id"),
+      agentName: text("agent_name"),
+      oldValue: text("old_value"),
+      newValue: text("new_value"),
+      timestamp: text("timestamp").notNull()
+    });
+    agentPermissions = sqliteTable("agent_permissions", {
+      agentId: text("agent_id").notNull(),
+      domain: text("domain").notNull(),
+      canRead: integer("can_read").notNull().default(1),
+      canWrite: integer("can_write").notNull().default(1)
+    });
+  }
+});
+
+// ../core/dist/types.js
+var init_types = __esm({
+  "../core/dist/types.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/confidence.js
+function applyConfidenceDecay(sqlite) {
+  const now3 = /* @__PURE__ */ new Date();
+  const candidates = sqlite.prepare(`
+    SELECT id, confidence, last_used_at, confirmed_at, learned_at
+    FROM memories
+    WHERE deleted_at IS NULL AND confidence > ?
+  `).all(MIN_CONFIDENCE);
+  let decayed = 0;
+  for (const mem of candidates) {
+    const lastActivity = mem.last_used_at || mem.confirmed_at || mem.learned_at;
+    if (!lastActivity)
+      continue;
+    const elapsed = now3.getTime() - new Date(lastActivity).getTime();
+    const periods = Math.floor(elapsed / DECAY_INTERVAL_MS);
+    if (periods <= 0)
+      continue;
+    const newConfidence = Math.max(mem.confidence - DECAY_RATE * periods, MIN_CONFIDENCE);
+    if (newConfidence < mem.confidence) {
+      sqlite.prepare(`UPDATE memories SET confidence = ? WHERE id = ?`).run(newConfidence, mem.id);
+      decayed++;
+    }
+  }
+  return decayed;
+}
+function getInitialConfidence(sourceType) {
+  return INITIAL_CONFIDENCE[sourceType] ?? 0.7;
+}
+function applyConfirm(_current) {
+  return 0.99;
+}
+function applyCorrect() {
+  return 0.5;
+}
+function applyMistake(current) {
+  return Math.max(current - 0.15, 0.1);
+}
+var DECAY_RATE, MIN_CONFIDENCE, DECAY_INTERVAL_MS, INITIAL_CONFIDENCE;
+var init_confidence = __esm({
+  "../core/dist/confidence.js"() {
+    "use strict";
+    DECAY_RATE = 0.01;
+    MIN_CONFIDENCE = 0.1;
+    DECAY_INTERVAL_MS = 30 * 24 * 60 * 60 * 1e3;
+    INITIAL_CONFIDENCE = {
+      stated: 0.9,
+      observed: 0.75,
+      inferred: 0.65,
+      "cross-agent": 0.7
+    };
+  }
+});
+
+// ../core/dist/fts.js
+function setupFTS(sqlite) {
+  sqlite.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+      content,
+      detail,
+      source_agent_name,
+      entity_name,
+      content='memories',
+      content_rowid='rowid'
+    );
+  `);
+  sqlite.exec(`
+    CREATE TRIGGER IF NOT EXISTS memory_fts_insert AFTER INSERT ON memories BEGIN
+      INSERT INTO memory_fts(rowid, content, detail, source_agent_name, entity_name)
+      VALUES (new.rowid, new.content, new.detail, new.source_agent_name, new.entity_name);
+    END;
+  `);
+  sqlite.exec(`
+    CREATE TRIGGER IF NOT EXISTS memory_fts_delete AFTER DELETE ON memories BEGIN
+      INSERT INTO memory_fts(memory_fts, rowid, content, detail, source_agent_name, entity_name)
+      VALUES ('delete', old.rowid, old.content, old.detail, old.source_agent_name, old.entity_name);
+    END;
+  `);
+  sqlite.exec(`
+    CREATE TRIGGER IF NOT EXISTS memory_fts_update AFTER UPDATE ON memories BEGIN
+      INSERT INTO memory_fts(memory_fts, rowid, content, detail, source_agent_name, entity_name)
+      VALUES ('delete', old.rowid, old.content, old.detail, old.source_agent_name, old.entity_name);
+      INSERT INTO memory_fts(rowid, content, detail, source_agent_name, entity_name)
+      VALUES (new.rowid, new.content, new.detail, new.source_agent_name, new.entity_name);
+    END;
+  `);
+}
+function searchFTS(sqlite, query, limit = 20) {
+  const rows = sqlite.prepare(`SELECT rowid FROM memory_fts WHERE memory_fts MATCH ? ORDER BY rank LIMIT ?`).all(query, limit);
+  return rows;
+}
+var init_fts = __esm({
+  "../core/dist/fts.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/vec.js
+import { createRequire } from "module";
+function setupVec(sqlite) {
+  try {
+    const sqliteVec = require2("sqlite-vec");
+    sqliteVec.load(sqlite);
+    sqlite.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS memory_embeddings USING vec0(
+        memory_id TEXT PRIMARY KEY,
+        embedding float[${EMBEDDING_DIM}]
+      );
+    `);
+    return true;
+  } catch (err) {
+    process.stderr.write(`[engrams] sqlite-vec not available \u2014 vector search disabled, falling back to FTS5 only: ${err}
+`);
+    return false;
+  }
+}
+function toBuffer(embedding) {
+  return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+}
+function insertEmbedding(sqlite, memoryId, embedding) {
+  sqlite.prepare(`INSERT OR REPLACE INTO memory_embeddings (memory_id, embedding) VALUES (?, ?)`).run(memoryId, toBuffer(embedding));
+}
+function searchVec(sqlite, queryEmbedding, limit = 20) {
+  return sqlite.prepare(`SELECT memory_id, distance FROM memory_embeddings WHERE embedding MATCH ? ORDER BY distance LIMIT ?`).all(toBuffer(queryEmbedding), limit);
+}
+var require2, EMBEDDING_DIM;
+var init_vec = __esm({
+  "../core/dist/vec.js"() {
+    "use strict";
+    require2 = createRequire(import.meta.url);
+    EMBEDDING_DIM = 384;
+  }
+});
+
+// ../core/dist/db.js
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { resolve } from "path";
+import { homedir } from "os";
+import { mkdirSync, chmodSync } from "fs";
+function runMigration(sqlite, name, fn) {
+  const exists = sqlite.prepare(`SELECT 1 FROM _migrations WHERE name = ?`).get(name);
+  if (!exists) {
+    try {
+      fn();
+    } catch {
+    }
+    sqlite.prepare(`INSERT OR IGNORE INTO _migrations (name) VALUES (?)`).run(name);
+  }
+}
+function runMigrations(sqlite) {
+  sqlite.exec(`CREATE TABLE IF NOT EXISTS _migrations (name TEXT PRIMARY KEY)`);
+  runMigration(sqlite, "add_has_pii_flag", () => {
+    sqlite.exec(`ALTER TABLE memories ADD COLUMN has_pii_flag INTEGER NOT NULL DEFAULT 0`);
+  });
+  runMigration(sqlite, "add_entity_columns", () => {
+    sqlite.exec(`ALTER TABLE memories ADD COLUMN entity_type TEXT`);
+    sqlite.exec(`ALTER TABLE memories ADD COLUMN entity_name TEXT`);
+    sqlite.exec(`ALTER TABLE memories ADD COLUMN structured_data TEXT`);
+    sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_memories_entity_type ON memories(entity_type) WHERE deleted_at IS NULL`);
+    sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_memories_entity_name ON memories(entity_name) WHERE deleted_at IS NULL`);
+  });
+  runMigration(sqlite, "fts_add_entity_name", () => {
+    sqlite.exec(`DROP TRIGGER IF EXISTS memory_fts_insert`);
+    sqlite.exec(`DROP TRIGGER IF EXISTS memory_fts_delete`);
+    sqlite.exec(`DROP TRIGGER IF EXISTS memory_fts_update`);
+    sqlite.exec(`DROP TABLE IF EXISTS memory_fts`);
+  });
+}
+function createDatabase(dbPath) {
+  const dir = resolve(homedir(), ".engrams");
+  mkdirSync(dir, { recursive: true });
+  const path = dbPath ?? resolve(dir, "engrams.db");
+  const sqlite = new Database(path);
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("foreign_keys = ON");
+  sqlite.exec(CREATE_TABLES_SQL);
+  runMigrations(sqlite);
+  setupFTS(sqlite);
+  try {
+    sqlite.exec(`INSERT INTO memory_fts(memory_fts) VALUES('rebuild')`);
+  } catch {
+  }
+  let vecAvailable = false;
+  try {
+    vecAvailable = setupVec(sqlite);
+  } catch {
+  }
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+  const db = drizzle(sqlite, { schema: schema_exports });
+  return { db, sqlite, vecAvailable };
+}
+function bumpLastModified(sqlite) {
+  sqlite.prepare(`INSERT OR REPLACE INTO engrams_meta (key, value) VALUES ('last_modified', ?)`).run((/* @__PURE__ */ new Date()).toISOString());
+}
+var CREATE_TABLES_SQL;
+var init_db = __esm({
+  "../core/dist/db.js"() {
+    "use strict";
+    init_schema();
+    init_fts();
+    init_vec();
+    CREATE_TABLES_SQL = `
+  CREATE TABLE IF NOT EXISTS memories (
+    id TEXT PRIMARY KEY,
+    content TEXT NOT NULL,
+    detail TEXT,
+    domain TEXT NOT NULL DEFAULT 'general',
+    source_agent_id TEXT NOT NULL,
+    source_agent_name TEXT NOT NULL,
+    cross_agent_id TEXT,
+    cross_agent_name TEXT,
+    source_type TEXT NOT NULL,
+    source_description TEXT,
+    confidence REAL NOT NULL DEFAULT 0.7,
+    confirmed_count INTEGER NOT NULL DEFAULT 0,
+    corrected_count INTEGER NOT NULL DEFAULT 0,
+    mistake_count INTEGER NOT NULL DEFAULT 0,
+    used_count INTEGER NOT NULL DEFAULT 0,
+    learned_at TEXT,
+    confirmed_at TEXT,
+    last_used_at TEXT,
+    deleted_at TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS memory_connections (
+    source_memory_id TEXT NOT NULL REFERENCES memories(id),
+    target_memory_id TEXT NOT NULL REFERENCES memories(id),
+    relationship TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS memory_events (
+    id TEXT PRIMARY KEY,
+    memory_id TEXT NOT NULL REFERENCES memories(id),
+    event_type TEXT NOT NULL,
+    agent_id TEXT,
+    agent_name TEXT,
+    old_value TEXT,
+    new_value TEXT,
+    timestamp TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS agent_permissions (
+    agent_id TEXT NOT NULL,
+    domain TEXT NOT NULL,
+    can_read INTEGER NOT NULL DEFAULT 1,
+    can_write INTEGER NOT NULL DEFAULT 1
+  );
+
+  CREATE TABLE IF NOT EXISTS engrams_meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+  INSERT OR IGNORE INTO engrams_meta (key, value) VALUES ('last_modified', datetime('now'));
+`;
+  }
+});
+
+// ../core/dist/embeddings.js
+import { resolve as resolve2 } from "path";
+import { homedir as homedir2 } from "os";
+async function getEmbedder() {
+  if (!embedder) {
+    const { pipeline } = await import("@huggingface/transformers");
+    const cacheDir = resolve2(homedir2(), ".engrams", "models");
+    const model = await pipeline("feature-extraction", MODEL_ID, {
+      cache_dir: cacheDir,
+      dtype: "q8"
+    });
+    embedder = model;
+  }
+  return embedder;
+}
+async function generateEmbedding(text2) {
+  const cached = embeddingCache.get(text2);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+    return cached.embedding;
+  }
+  const model = await getEmbedder();
+  const output = await model(text2, { pooling: "mean", normalize: true });
+  const embedding = new Float32Array(output.data);
+  if (embeddingCache.size >= CACHE_MAX) {
+    const oldestKey = embeddingCache.keys().next().value;
+    if (oldestKey)
+      embeddingCache.delete(oldestKey);
+  }
+  embeddingCache.set(text2, { embedding, timestamp: Date.now() });
+  return embedding;
+}
+async function backfillEmbeddings(sqlite) {
+  const missing = sqlite.prepare(`
+      SELECT m.id, m.content, m.detail FROM memories m
+      LEFT JOIN memory_embeddings e ON m.id = e.memory_id
+      WHERE m.deleted_at IS NULL AND e.memory_id IS NULL
+    `).all();
+  let count = 0;
+  for (const mem of missing) {
+    try {
+      const text2 = mem.content + (mem.detail ? " " + mem.detail : "");
+      const embedding = await generateEmbedding(text2);
+      insertEmbedding(sqlite, mem.id, embedding);
+      count++;
+    } catch {
+    }
+  }
+  return count;
+}
+var MODEL_ID, embedder, CACHE_MAX, CACHE_TTL_MS, embeddingCache;
+var init_embeddings = __esm({
+  "../core/dist/embeddings.js"() {
+    "use strict";
+    init_vec();
+    MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+    embedder = null;
+    CACHE_MAX = 100;
+    CACHE_TTL_MS = 5 * 60 * 1e3;
+    embeddingCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../core/dist/search.js
+function getStoredEmbedding(sqlite, memoryId) {
+  const row = sqlite.prepare(`SELECT embedding FROM memory_embeddings WHERE memory_id = ?`).get(memoryId);
+  if (!row)
+    return null;
+  return new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4);
+}
+function cosineSimilarity(a, b) {
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function recencyBoost(learnedAt) {
+  if (!learnedAt)
+    return 1;
+  const ageMs = Date.now() - new Date(learnedAt).getTime();
+  const ageDays = ageMs / (1e3 * 60 * 60 * 24);
+  return 1 + Math.max(0, 0.1 * (1 - ageDays / 30));
+}
+function expandConnections(sqlite, results, queryEmbedding, maxDepth, similarityThreshold) {
+  if (!queryEmbedding) {
+    return results.map((r) => ({ ...r, connected: [] }));
+  }
+  const seen = new Set(results.map((r) => r.id));
+  return results.map((result) => {
+    const connected = [];
+    const queue = [{ memoryId: result.id, depth: 0 }];
+    while (queue.length > 0) {
+      const { memoryId, depth } = queue.shift();
+      if (depth >= maxDepth)
+        continue;
+      const outgoing = sqlite.prepare(`SELECT mc.target_memory_id as id, mc.relationship, m.*
+           FROM memory_connections mc
+           JOIN memories m ON m.id = mc.target_memory_id
+           WHERE mc.source_memory_id = ? AND m.deleted_at IS NULL`).all(memoryId);
+      const incoming = sqlite.prepare(`SELECT mc.source_memory_id as id, mc.relationship, m.*
+           FROM memory_connections mc
+           JOIN memories m ON m.id = mc.source_memory_id
+           WHERE mc.target_memory_id = ? AND m.deleted_at IS NULL`).all(memoryId);
+      for (const conn of [...outgoing, ...incoming]) {
+        if (seen.has(conn.id))
+          continue;
+        seen.add(conn.id);
+        const embedding = getStoredEmbedding(sqlite, conn.id);
+        if (!embedding)
+          continue;
+        const similarity = cosineSimilarity(queryEmbedding, embedding);
+        if (similarity < similarityThreshold)
+          continue;
+        connected.push({
+          memory: conn,
+          relationship: conn.relationship,
+          depth: depth + 1,
+          similarity
+        });
+        queue.push({ memoryId: conn.id, depth: depth + 1 });
+      }
+    }
+    connected.sort((a, b) => {
+      const simDiff = b.similarity - a.similarity;
+      if (Math.abs(simDiff) > 1e-10)
+        return simDiff;
+      return a.memory.id.localeCompare(b.memory.id);
+    });
+    return { ...result, connected };
+  });
+}
+async function hybridSearch(sqlite, query, options = {}) {
+  const limit = options.limit ?? 20;
+  const expand = options.expand ?? true;
+  const maxDepth = options.maxDepth ?? 3;
+  const similarityThreshold = options.similarityThreshold ?? 0.5;
+  const fetchLimit = limit * 3;
+  const cacheKey = JSON.stringify({ query, ...options });
+  const currentLastModified = sqlite.prepare(`SELECT value FROM engrams_meta WHERE key = 'last_modified'`).get();
+  const cachedEntry = resultCache.get(cacheKey);
+  if (cachedEntry && cachedEntry.lastModified === currentLastModified?.value) {
+    return { results: cachedEntry.results, cached: true };
+  }
+  const ftsIds = [];
+  try {
+    const ftsResults = searchFTS(sqlite, query, fetchLimit);
+    if (ftsResults.length > 0) {
+      const rowids = ftsResults.map((r) => r.rowid);
+      const placeholders2 = rowids.map(() => "?").join(",");
+      const rows2 = sqlite.prepare(`SELECT id FROM memories WHERE rowid IN (${placeholders2}) AND deleted_at IS NULL`).all(...rowids);
+      ftsIds.push(...rows2.map((r) => r.id));
+    }
+  } catch {
+  }
+  const vecIds = [];
+  let queryEmbedding = null;
+  try {
+    queryEmbedding = await generateEmbedding(query);
+    const vecResults = searchVec(sqlite, queryEmbedding, fetchLimit);
+    vecIds.push(...vecResults.map((r) => r.memory_id));
+  } catch {
+  }
+  const scores = /* @__PURE__ */ new Map();
+  ftsIds.forEach((id, rank) => {
+    scores.set(id, (scores.get(id) ?? 0) + 1 / (RRF_K + rank + 1));
+  });
+  vecIds.forEach((id, rank) => {
+    scores.set(id, (scores.get(id) ?? 0) + 1 / (RRF_K + rank + 1));
+  });
+  for (const [id, rawScore] of scores.entries()) {
+    const mem = sqlite.prepare(`SELECT confidence, learned_at FROM memories WHERE id = ? AND deleted_at IS NULL`).get(id);
+    if (mem) {
+      const confidenceBoost = 0.5 + mem.confidence * 0.5;
+      const recency = recencyBoost(mem.learned_at);
+      scores.set(id, rawScore * confidenceBoost * recency);
+    }
+  }
+  const rankedIds = [...scores.keys()];
+  rankedIds.sort((a, b) => {
+    const scoreDiff = scores.get(b) - scores.get(a);
+    if (Math.abs(scoreDiff) > 1e-10)
+      return scoreDiff;
+    return a.localeCompare(b);
+  });
+  const topIds = rankedIds.slice(0, limit);
+  if (topIds.length === 0) {
+    return { results: [], cached: false };
+  }
+  const placeholders = topIds.map(() => "?").join(",");
+  let sql2 = `SELECT * FROM memories WHERE id IN (${placeholders}) AND deleted_at IS NULL`;
+  const params = [...topIds];
+  if (options.domain) {
+    sql2 += ` AND domain = ?`;
+    params.push(options.domain);
+  }
+  if (options.entityType) {
+    sql2 += ` AND entity_type = ?`;
+    params.push(options.entityType);
+  }
+  if (options.entityName) {
+    sql2 += ` AND entity_name = ? COLLATE NOCASE`;
+    params.push(options.entityName);
+  }
+  if (options.minConfidence !== void 0) {
+    sql2 += ` AND confidence >= ?`;
+    params.push(options.minConfidence);
+  }
+  const rows = sqlite.prepare(sql2).all(...params);
+  const rowMap = new Map(rows.map((r) => [r.id, r]));
+  const searchResults = topIds.filter((id) => rowMap.has(id)).map((id) => ({
+    id,
+    score: scores.get(id),
+    memory: rowMap.get(id)
+  }));
+  let expandedResults;
+  if (expand) {
+    expandedResults = expandConnections(sqlite, searchResults, queryEmbedding, maxDepth, similarityThreshold);
+  } else {
+    expandedResults = searchResults.map((r) => ({ ...r, connected: [] }));
+  }
+  if (currentLastModified) {
+    resultCache.set(cacheKey, { results: expandedResults, lastModified: currentLastModified.value });
+  }
+  return { results: expandedResults, cached: false };
+}
+var RRF_K, resultCache;
+var init_search = __esm({
+  "../core/dist/search.js"() {
+    "use strict";
+    init_fts();
+    init_vec();
+    init_embeddings();
+    RRF_K = 60;
+    resultCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../core/dist/pii.js
+function isValidCreditCard(match) {
+  const digits = match.replace(/[^0-9]/g, "");
+  return digits.length >= 13 && digits.length <= 19;
+}
+function detectSensitiveData(text2) {
+  const results = [];
+  const coveredRanges = [];
+  for (const { type, pattern } of PII_PATTERNS) {
+    pattern.lastIndex = 0;
+    let m;
+    while ((m = pattern.exec(text2)) !== null) {
+      const start = m.index;
+      const end = m.index + m[0].length;
+      const overlaps = coveredRanges.some((r) => start < r.end && end > r.start);
+      if (overlaps)
+        continue;
+      if (type === "credit_card" && !isValidCreditCard(m[0]))
+        continue;
+      if (type === "phone") {
+        const digits = m[0].replace(/[^0-9]/g, "");
+        if (digits.length < 10)
+          continue;
+      }
+      results.push({ type, match: m[0], start, end });
+      coveredRanges.push({ start, end });
+    }
+  }
+  results.sort((a, b) => a.start - b.start);
+  return results;
+}
+function redactSensitiveData(text2) {
+  const matches = detectSensitiveData(text2);
+  if (matches.length === 0)
+    return { redacted: text2, matches };
+  const tokenMap = new Map(PII_PATTERNS.map((p) => [p.type, p.redactToken]));
+  let redacted = text2;
+  for (let i = matches.length - 1; i >= 0; i--) {
+    const m = matches[i];
+    const token = tokenMap.get(m.type) ?? `[${m.type.toUpperCase()}]`;
+    redacted = redacted.slice(0, m.start) + token + redacted.slice(m.end);
+  }
+  return { redacted, matches };
+}
+var PII_PATTERNS;
+var init_pii = __esm({
+  "../core/dist/pii.js"() {
+    "use strict";
+    PII_PATTERNS = [
+      {
+        type: "ssn",
+        pattern: /\b\d{3}-\d{2}-\d{4}\b/g,
+        redactToken: "[SSN]"
+      },
+      {
+        type: "credit_card",
+        pattern: /\b(?:\d[ -]*?){13,19}\b/g,
+        redactToken: "[CREDIT_CARD]"
+      },
+      {
+        type: "api_key",
+        pattern: /\b(?:sk-[a-zA-Z0-9]{20,}|ghp_[a-zA-Z0-9]{36,}|xoxb-[a-zA-Z0-9-]+|xoxp-[a-zA-Z0-9-]+|AKIA[A-Z0-9]{16}|rk_live_[a-zA-Z0-9]+|rk_test_[a-zA-Z0-9]+|pk_live_[a-zA-Z0-9]+|pk_test_[a-zA-Z0-9]+)\b/g,
+        redactToken: "[API_KEY]"
+      },
+      {
+        type: "email",
+        pattern: /\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b/g,
+        redactToken: "[EMAIL]"
+      },
+      {
+        type: "phone",
+        pattern: /(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g,
+        redactToken: "[PHONE]"
+      },
+      {
+        type: "ip_address",
+        pattern: /\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b/g,
+        redactToken: "[IP_ADDRESS]"
+      }
+    ];
+  }
+});
+
+// ../core/dist/entity-extraction.js
+async function extractEntity(content, detail, existingEntityNames) {
+  const { default: Anthropic2 } = await import("@anthropic-ai/sdk");
+  const client = new Anthropic2();
+  const existingNamesHint = existingEntityNames && existingEntityNames.length > 0 ? `
+
+Existing entity names in the system (prefer matching these over creating new ones):
+${existingEntityNames.slice(0, 50).map((n) => `- ${n}`).join("\n")}` : "";
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-5-20250514",
+    max_tokens: 500,
+    messages: [
+      {
+        role: "user",
+        content: `Classify this memory and extract structured data.
+
+Memory: ${content}${detail ? `
+Detail: ${detail}` : ""}${existingNamesHint}
+
+Respond with JSON only:
+{
+  "entity_type": "person|organization|place|project|preference|event|goal|fact",
+  "entity_name": "canonical name or null if not applicable",
+  "structured_data": { type-specific fields },
+  "suggested_connections": [
+    { "target_entity_name": "...", "target_entity_type": "...", "relationship": "works_at|involves|located_at|part_of|about|related" }
+  ]
+}
+
+Entity type definitions:
+- person: about a specific individual
+- organization: about a company, team, or group
+- place: about a location
+- project: about a work project or initiative
+- preference: about what the user likes/dislikes/prefers
+- event: about something that happened or will happen
+- goal: about something the user wants to achieve
+- fact: general knowledge that doesn't fit other types
+
+For entity_name, use the canonical form (e.g. "Sarah Chen" not "my manager Sarah"). If an existing entity name matches, use that exact spelling.
+
+For structured_data, include relevant fields:
+- person: name, role, organization, relationship_to_user
+- organization: name, type, user_relationship
+- place: name, context
+- project: name, status, user_role
+- preference: category, strength (strong/mild/contextual)
+- event: what, when, who
+- goal: what, timeline, status (active/achieved/abandoned)
+- fact: category`
+      }
+    ]
+  });
+  const text2 = response.content[0].type === "text" ? response.content[0].text : "";
+  const cleaned = text2.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
+  return JSON.parse(cleaned);
+}
+var init_entity_extraction = __esm({
+  "../core/dist/entity-extraction.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/index.js
+var init_dist = __esm({
+  "../core/dist/index.js"() {
+    "use strict";
+    init_schema();
+    init_types();
+    init_confidence();
+    init_db();
+    init_fts();
+    init_embeddings();
+    init_vec();
+    init_search();
+    init_db();
+    init_pii();
+    init_entity_extraction();
+  }
+});
+
+// src/http.ts
+var http_exports = {};
+__export(http_exports, {
+  startHttpApi: () => startHttpApi
+});
+import { createServer } from "http";
+import { randomBytes } from "crypto";
+import { eq, and, isNull } from "drizzle-orm";
+function generateId() {
+  return randomBytes(16).toString("hex");
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function json(res, data, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function parseBody(req) {
+  return new Promise((resolve3, reject) => {
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", () => {
+      try {
+        resolve3(body ? JSON.parse(body) : {});
+      } catch {
+        reject(new Error("Invalid JSON"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function startHttpApi(db, sqlite, port = 3838) {
+  const server = createServer(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+    const url = req.url ?? "";
+    try {
+      const confirmMatch = url.match(/^\/api\/memory\/([^/]+)\/confirm$/);
+      if (confirmMatch && req.method === "POST") {
+        const id = confirmMatch[1];
+        const existing = db.select().from(memories).where(and(eq(memories.id, id), isNull(memories.deletedAt))).get();
+        if (!existing) return json(res, { error: "Not found" }, 404);
+        const newConfidence = applyConfirm(existing.confidence);
+        const timestamp = now();
+        db.update(memories).set({
+          confidence: newConfidence,
+          confirmedCount: existing.confirmedCount + 1,
+          confirmedAt: timestamp
+        }).where(eq(memories.id, id)).run();
+        db.insert(memoryEvents).values({
+          id: generateId(),
+          memoryId: id,
+          eventType: "confirmed",
+          agentName: "dashboard",
+          oldValue: JSON.stringify({ confidence: existing.confidence }),
+          newValue: JSON.stringify({ confidence: newConfidence }),
+          timestamp
+        }).run();
+        return json(res, { id, newConfidence });
+      }
+      const correctMatch = url.match(/^\/api\/memory\/([^/]+)\/correct$/);
+      if (correctMatch && req.method === "POST") {
+        const id = correctMatch[1];
+        const body = await parseBody(req);
+        const content = body.content;
+        if (!content) return json(res, { error: "content required" }, 400);
+        const existing = db.select().from(memories).where(and(eq(memories.id, id), isNull(memories.deletedAt))).get();
+        if (!existing) return json(res, { error: "Not found" }, 404);
+        const newConfidence = applyCorrect();
+        const timestamp = now();
+        db.update(memories).set({
+          content,
+          confidence: newConfidence,
+          correctedCount: existing.correctedCount + 1
+        }).where(eq(memories.id, id)).run();
+        db.insert(memoryEvents).values({
+          id: generateId(),
+          memoryId: id,
+          eventType: "corrected",
+          agentName: "dashboard",
+          oldValue: JSON.stringify({ content: existing.content }),
+          newValue: JSON.stringify({ content, confidence: newConfidence }),
+          timestamp
+        }).run();
+        return json(res, { id, newConfidence });
+      }
+      const flagMatch = url.match(/^\/api\/memory\/([^/]+)\/flag$/);
+      if (flagMatch && req.method === "POST") {
+        const id = flagMatch[1];
+        const existing = db.select().from(memories).where(and(eq(memories.id, id), isNull(memories.deletedAt))).get();
+        if (!existing) return json(res, { error: "Not found" }, 404);
+        const newConfidence = applyMistake(existing.confidence);
+        const timestamp = now();
+        db.update(memories).set({
+          confidence: newConfidence,
+          mistakeCount: existing.mistakeCount + 1
+        }).where(eq(memories.id, id)).run();
+        db.insert(memoryEvents).values({
+          id: generateId(),
+          memoryId: id,
+          eventType: "confidence_changed",
+          agentName: "dashboard",
+          oldValue: JSON.stringify({ confidence: existing.confidence }),
+          newValue: JSON.stringify({ confidence: newConfidence, flaggedAsMistake: true }),
+          timestamp
+        }).run();
+        return json(res, { id, newConfidence });
+      }
+      const deleteMatch = url.match(/^\/api\/memory\/([^/]+)\/delete$/);
+      if (deleteMatch && req.method === "POST") {
+        const id = deleteMatch[1];
+        const timestamp = now();
+        db.update(memories).set({ deletedAt: timestamp }).where(eq(memories.id, id)).run();
+        db.insert(memoryEvents).values({
+          id: generateId(),
+          memoryId: id,
+          eventType: "removed",
+          agentName: "dashboard",
+          newValue: JSON.stringify({ reason: "deleted via dashboard" }),
+          timestamp
+        }).run();
+        return json(res, { id, deleted: true });
+      }
+      const updateMatch = url.match(/^\/api\/memory\/([^/]+)\/update$/);
+      if (updateMatch && req.method === "POST") {
+        const id = updateMatch[1];
+        const body = await parseBody(req);
+        const updates = {};
+        if (body.content) updates.content = body.content;
+        if (body.detail) updates.detail = body.detail;
+        if (body.domain) updates.domain = body.domain;
+        if (Object.keys(updates).length === 0)
+          return json(res, { error: "No fields" }, 400);
+        db.update(memories).set(updates).where(eq(memories.id, id)).run();
+        return json(res, { id, updated: true });
+      }
+      if (url === "/api/permissions" && req.method === "POST") {
+        const body = await parseBody(req);
+        const agentId = body.agentId;
+        const domain = body.domain;
+        const canRead = body.canRead !== false ? 1 : 0;
+        const canWrite = body.canWrite !== false ? 1 : 0;
+        const existing = db.select().from(agentPermissions).where(
+          and(
+            eq(agentPermissions.agentId, agentId),
+            eq(agentPermissions.domain, domain)
+          )
+        ).get();
+        if (existing) {
+          db.update(agentPermissions).set({ canRead, canWrite }).where(
+            and(
+              eq(agentPermissions.agentId, agentId),
+              eq(agentPermissions.domain, domain)
+            )
+          ).run();
+        } else {
+          db.insert(agentPermissions).values({ agentId, domain, canRead, canWrite }).run();
+        }
+        return json(res, { agentId, domain, canRead: !!canRead, canWrite: !!canWrite });
+      }
+      if (url === "/api/clear-all" && req.method === "POST") {
+        const timestamp = now();
+        sqlite.prepare(`UPDATE memories SET deleted_at = ? WHERE deleted_at IS NULL`).run(timestamp);
+        return json(res, { cleared: true });
+      }
+      json(res, { error: "Not found" }, 404);
+    } catch (e) {
+      const message = e instanceof Error ? e.message : "Unknown error";
+      json(res, { error: message }, 500);
+    }
+  });
+  server.listen(port, () => {
+  });
+  return server;
+}
+var init_http = __esm({
+  "src/http.ts"() {
+    "use strict";
+    init_dist();
+  }
+});
+
+// src/server.ts
+init_dist();
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { eq as eq2, and as and2, isNull as isNull2 } from "drizzle-orm";
+import { randomBytes as randomBytes2 } from "crypto";
+import Anthropic from "@anthropic-ai/sdk";
+function generateId2() {
+  return randomBytes2(16).toString("hex");
+}
+function now2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function textResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+async function startServer() {
+  const server = new McpServer({
+    name: "engrams",
+    version: "0.1.0"
+  });
+  const { db, sqlite, vecAvailable } = createDatabase();
+  let lastDecayRun = 0;
+  const DECAY_THROTTLE_MS = 60 * 60 * 1e3;
+  function maybeRunDecay() {
+    const now3 = Date.now();
+    if (now3 - lastDecayRun > DECAY_THROTTLE_MS) {
+      applyConfidenceDecay(sqlite);
+      lastDecayRun = now3;
+    }
+  }
+  if (vecAvailable) {
+    backfillEmbeddings(sqlite).then((count) => {
+      if (count > 0) process.stderr.write(`[engrams] Backfilled embeddings for ${count} memories
+`);
+    }).catch(() => {
+    });
+  }
+  server.resource("memory-instructions", "memory://instructions", async (uri) => {
+    return {
+      contents: [
+        {
+          uri: uri.href,
+          mimeType: "text/plain",
+          text: `# Engrams \u2014 Memory Guidelines
+
+You have access to Engrams, a persistent memory system shared across all AI tools this user connects. Memories you save here are available in future conversations and across other tools (Claude Code, Cursor, Claude Desktop, etc.).
+
+## When to save a memory
+- User states a preference ("I prefer morning meetings", "I use vim keybindings")
+- User corrects you or provides factual context about themselves ("I'm a PM, not an engineer", "My team uses pnpm, not npm")
+- User shares information useful across future conversations (goals, relationships, routines, project context)
+- You observe a consistent pattern in the user's behavior (inferred, lower confidence)
+- Another agent shared knowledge relevant to this conversation (cross-agent)
+
+## When NOT to save a memory
+- Ephemeral task details ("fix the bug on line 42") \u2014 these don't persist across conversations
+- Information already in the codebase or git history \u2014 read the source of truth instead
+- Debugging steps or temporary workarounds
+- Anything the user asks you not to remember
+
+## How to use memories
+- Search Engrams at the start of conversations when context about the user would help
+- Before asking the user a question, check if the answer is already in memory
+- When a memory helps you give a better response, use it but don't narrate that you searched
+- If you act on a memory and the user confirms it was helpful, call memory_confirm
+- If you act on a memory and it was wrong, call memory_flag_mistake
+- If the user corrects a memory, call memory_correct with the updated content
+
+## Source types
+- "stated": User explicitly told you (highest initial confidence: 0.90)
+- "observed": You noticed from the user's actions (0.75)
+- "inferred": You deduced from context (0.65)
+- "cross-agent": Another agent shared this (0.70)
+
+## Domains
+Organize memories by life domain: general, work, health, finance, relationships, daily-life, learning, creative, or any domain that fits. Use consistent domain names.`
+        }
+      ]
+    };
+  });
+  const WRITE_SIMILARITY_THRESHOLD = 0.7;
+  server.tool(
+    "memory_write",
+    "Store a new memory. If a similar memory already exists, returns the existing memory and resolution options instead of writing immediately. Call again with 'resolution' and 'existing_memory_id' to resolve. Pass resolution: 'keep_both' to skip dedup check and force a new memory.",
+    {
+      content: z.string().describe("The memory content"),
+      domain: z.string().optional().describe("Life domain (default: general)"),
+      detail: z.string().optional().describe("Extended context"),
+      sourceAgentId: z.string().describe("Your agent ID"),
+      sourceAgentName: z.string().describe("Your agent name"),
+      sourceType: z.enum(["stated", "inferred", "observed", "cross-agent"]).describe("How this memory was acquired"),
+      sourceDescription: z.string().optional().describe("Description of source"),
+      entityType: z.enum(["person", "organization", "place", "project", "preference", "event", "goal", "fact"]).optional().describe("Entity classification. If omitted, auto-classification runs in background."),
+      entityName: z.string().optional().describe("Canonical entity name (e.g. 'Sarah Chen', not 'my manager Sarah'). Helps with dedup."),
+      structuredData: z.record(z.unknown()).optional().describe("Type-specific structured fields (schema depends on entityType)"),
+      force: z.boolean().optional().describe("Deprecated \u2014 use resolution: 'keep_both' instead"),
+      resolution: z.enum(["update", "correct", "add_detail", "keep_both", "skip"]).optional().describe("How to resolve a similarity match"),
+      existingMemoryId: z.string().optional().describe("ID of existing memory to act on (required for update/correct/add_detail)")
+    },
+    async (params) => {
+      if (params.resolution && params.resolution !== "keep_both") {
+        if (params.resolution === "skip") {
+          return textResult({ status: "skipped", message: "No changes made" });
+        }
+        if (!params.existingMemoryId) {
+          return textResult({ error: "existing_memory_id is required for resolution: " + params.resolution });
+        }
+        const existing = db.select().from(memories).where(and2(eq2(memories.id, params.existingMemoryId), isNull2(memories.deletedAt))).get();
+        if (!existing) {
+          return textResult({ error: "Existing memory not found or deleted" });
+        }
+        const timestamp2 = now2();
+        if (params.resolution === "update") {
+          const newConfidence = Math.min(existing.confidence + 0.02, 0.99);
+          db.update(memories).set({
+            content: params.content,
+            detail: params.detail ?? existing.detail,
+            confidence: newConfidence
+          }).where(eq2(memories.id, params.existingMemoryId)).run();
+          if (vecAvailable) {
+            try {
+              const detail = params.detail ?? existing.detail;
+              const embeddingText = params.content + (detail ? " " + detail : "");
+              const embedding2 = await generateEmbedding(embeddingText);
+              insertEmbedding(sqlite, params.existingMemoryId, embedding2);
+            } catch {
+            }
+          }
+          db.insert(memoryEvents).values({
+            id: generateId2(),
+            memoryId: params.existingMemoryId,
+            eventType: "updated",
+            agentId: params.sourceAgentId,
+            agentName: params.sourceAgentName,
+            oldValue: JSON.stringify({ content: existing.content, detail: existing.detail }),
+            newValue: JSON.stringify({ content: params.content, detail: params.detail ?? existing.detail }),
+            timestamp: timestamp2
+          }).run();
+          bumpLastModified(sqlite);
+          return textResult({
+            status: "updated",
+            id: params.existingMemoryId,
+            previousConfidence: existing.confidence,
+            newConfidence
+          });
+        }
+        if (params.resolution === "correct") {
+          const newConfidence = Math.min(Math.max(existing.confidence, 0.85), 0.99);
+          db.update(memories).set({
+            content: params.content,
+            detail: params.detail ?? existing.detail,
+            confidence: newConfidence,
+            correctedCount: existing.correctedCount + 1
+          }).where(eq2(memories.id, params.existingMemoryId)).run();
+          if (vecAvailable) {
+            try {
+              const detail = params.detail ?? existing.detail;
+              const embeddingText = params.content + (detail ? " " + detail : "");
+              const embedding2 = await generateEmbedding(embeddingText);
+              insertEmbedding(sqlite, params.existingMemoryId, embedding2);
+            } catch {
+            }
+          }
+          db.insert(memoryEvents).values({
+            id: generateId2(),
+            memoryId: params.existingMemoryId,
+            eventType: "corrected",
+            agentId: params.sourceAgentId,
+            agentName: params.sourceAgentName,
+            oldValue: JSON.stringify({ content: existing.content, confidence: existing.confidence }),
+            newValue: JSON.stringify({ content: params.content, confidence: newConfidence }),
+            timestamp: timestamp2
+          }).run();
+          bumpLastModified(sqlite);
+          return textResult({
+            status: "corrected",
+            id: params.existingMemoryId,
+            previousConfidence: existing.confidence,
+            newConfidence,
+            correctedCount: existing.correctedCount + 1
+          });
+        }
+        if (params.resolution === "add_detail") {
+          const separator = existing.detail ? "\n" : "";
+          const newDetail = (existing.detail ?? "") + separator + params.content;
+          db.update(memories).set({ detail: newDetail }).where(eq2(memories.id, params.existingMemoryId)).run();
+          if (vecAvailable) {
+            try {
+              const embeddingText = existing.content + " " + newDetail;
+              const embedding2 = await generateEmbedding(embeddingText);
+              insertEmbedding(sqlite, params.existingMemoryId, embedding2);
+            } catch {
+            }
+          }
+          db.insert(memoryEvents).values({
+            id: generateId2(),
+            memoryId: params.existingMemoryId,
+            eventType: "updated",
+            agentId: params.sourceAgentId,
+            agentName: params.sourceAgentName,
+            oldValue: JSON.stringify({ detail: existing.detail }),
+            newValue: JSON.stringify({ detail: newDetail }),
+            timestamp: timestamp2
+          }).run();
+          bumpLastModified(sqlite);
+          return textResult({
+            status: "detail_appended",
+            id: params.existingMemoryId,
+            newDetail
+          });
+        }
+      }
+      const skipDedup = params.resolution === "keep_both" || params.force;
+      let embedding = null;
+      if (!skipDedup) {
+        const embeddingText = params.content + (params.detail ? " " + params.detail : "");
+        if (vecAvailable) {
+          try {
+            embedding = await generateEmbedding(embeddingText);
+            const similar = searchVec(sqlite, embedding, 3);
+            const closeMatches = similar.filter((s) => 1 - s.distance >= WRITE_SIMILARITY_THRESHOLD);
+            if (closeMatches.length > 0) {
+              const matchedMemories = closeMatches.map((m) => {
+                const row = sqlite.prepare(`SELECT * FROM memories WHERE id = ? AND deleted_at IS NULL`).get(m.memory_id);
+                if (!row) return null;
+                return {
+                  id: row.id,
+                  content: row.content,
+                  detail: row.detail,
+                  confidence: row.confidence,
+                  similarity: Math.round((1 - m.distance) * 100) / 100
+                };
+              }).filter(Boolean);
+              if (matchedMemories.length > 0) {
+                return textResult({
+                  status: "similar_found",
+                  proposed: {
+                    content: params.content,
+                    detail: params.detail ?? null,
+                    domain: params.domain ?? "general"
+                  },
+                  similar: matchedMemories,
+                  options: [
+                    "update \u2014 replace the existing memory's content with the new content",
+                    "correct \u2014 existing was wrong; update it and boost confidence to min(max(existing, 0.85), 0.99)",
+                    "add_detail \u2014 append new content to the existing memory's detail field",
+                    "keep_both \u2014 store as a new memory (not a duplicate)",
+                    "skip \u2014 existing memory is already accurate, don't write anything"
+                  ],
+                  message: "Similar memory found. Respond with memory_write again including resolution and existingMemoryId to proceed."
+                });
+              }
+            }
+          } catch {
+          }
+        } else {
+          const dedupResults = searchFTS(sqlite, params.content, 3);
+          if (dedupResults.length > 0) {
+            const rowids = dedupResults.map((r) => r.rowid);
+            const placeholders = rowids.map(() => "?").join(",");
+            const existing = sqlite.prepare(
+              `SELECT * FROM memories WHERE rowid IN (${placeholders}) AND deleted_at IS NULL`
+            ).all(...rowids);
+            if (existing.length > 0) {
+              return textResult({
+                status: "similar_found",
+                proposed: {
+                  content: params.content,
+                  detail: params.detail ?? null,
+                  domain: params.domain ?? "general"
+                },
+                similar: existing.map((e) => ({
+                  id: e.id,
+                  content: e.content,
+                  detail: e.detail,
+                  confidence: e.confidence,
+                  similarity: null
+                  // FTS5 doesn't provide cosine similarity
+                })),
+                options: [
+                  "update \u2014 replace the existing memory's content with the new content",
+                  "correct \u2014 existing was wrong; update it and boost confidence to min(max(existing, 0.85), 0.99)",
+                  "add_detail \u2014 append new content to the existing memory's detail field",
+                  "keep_both \u2014 store as a new memory (not a duplicate)",
+                  "skip \u2014 existing memory is already accurate, don't write anything"
+                ],
+                message: "Similar memory found. Respond with memory_write again including resolution and existingMemoryId to proceed."
+              });
+            }
+          }
+        }
+        if (params.entityName && params.entityType) {
+          const entityMatches = sqlite.prepare(
+            `SELECT * FROM memories
+               WHERE entity_type = ? AND entity_name = ? COLLATE NOCASE
+               AND deleted_at IS NULL`
+          ).all(params.entityType, params.entityName);
+          if (entityMatches.length > 0) {
+            return textResult({
+              status: "similar_found",
+              proposed: {
+                content: params.content,
+                detail: params.detail ?? null,
+                domain: params.domain ?? "general"
+              },
+              similar: entityMatches.map((e) => ({
+                id: e.id,
+                content: e.content,
+                detail: e.detail,
+                confidence: e.confidence,
+                similarity: null,
+                entity_match: true
+              })),
+              options: [
+                "update \u2014 replace the existing memory's content with the new content",
+                "correct \u2014 existing was wrong; update it and boost confidence to min(max(existing, 0.85), 0.99)",
+                "add_detail \u2014 append new content to the existing memory's detail field",
+                "keep_both \u2014 store as a new memory (not a duplicate)",
+                "skip \u2014 existing memory is already accurate, don't write anything"
+              ],
+              message: `Existing memory found for ${params.entityType} "${params.entityName}". Respond with memory_write again including resolution and existingMemoryId to proceed.`
+            });
+          }
+        }
+      }
+      const VALID_ENTITY_TYPES = ["person", "organization", "place", "project", "preference", "event", "goal", "fact"];
+      if (params.entityType && !VALID_ENTITY_TYPES.includes(params.entityType)) {
+        return textResult({ error: `Invalid entity_type: "${params.entityType}". Must be one of: ${VALID_ENTITY_TYPES.join(", ")}` });
+      }
+      const id = generateId2();
+      const confidence = getInitialConfidence(params.sourceType);
+      const timestamp = now2();
+      const piiText = params.content + (params.detail ? " " + params.detail : "");
+      const piiMatches = detectSensitiveData(piiText);
+      const hasPii = piiMatches.length > 0;
+      db.insert(memories).values({
+        id,
+        content: params.content,
+        detail: params.detail ?? null,
+        domain: params.domain ?? "general",
+        sourceAgentId: params.sourceAgentId,
+        sourceAgentName: params.sourceAgentName,
+        sourceType: params.sourceType,
+        sourceDescription: params.sourceDescription ?? null,
+        confidence,
+        learnedAt: timestamp,
+        hasPiiFlag: hasPii ? 1 : 0,
+        entityType: params.entityType ?? null,
+        entityName: params.entityName ?? null,
+        structuredData: params.structuredData ? JSON.stringify(params.structuredData) : null
+      }).run();
+      if (vecAvailable) {
+        try {
+          if (!embedding) {
+            const embeddingText = params.content + (params.detail ? " " + params.detail : "");
+            embedding = await generateEmbedding(embeddingText);
+          }
+          insertEmbedding(sqlite, id, embedding);
+        } catch {
+        }
+      }
+      db.insert(memoryEvents).values({
+        id: generateId2(),
+        memoryId: id,
+        eventType: "created",
+        agentId: params.sourceAgentId,
+        agentName: params.sourceAgentName,
+        newValue: JSON.stringify({ content: params.content, domain: params.domain ?? "general" }),
+        timestamp
+      }).run();
+      if (!params.entityType && process.env.ANTHROPIC_API_KEY) {
+        (async () => {
+          try {
+            const existingNames = sqlite.prepare(`SELECT DISTINCT entity_name FROM memories WHERE entity_name IS NOT NULL AND deleted_at IS NULL`).all();
+            const extraction = await extractEntity(
+              params.content,
+              params.detail ?? null,
+              existingNames.map((r) => r.entity_name)
+            );
+            const current = sqlite.prepare(`SELECT entity_type FROM memories WHERE id = ? AND deleted_at IS NULL`).get(id);
+            if (!current || current.entity_type) return;
+            sqlite.transaction(() => {
+              sqlite.prepare(
+                `UPDATE memories SET entity_type = ?, entity_name = ?, structured_data = ? WHERE id = ? AND entity_type IS NULL AND deleted_at IS NULL`
+              ).run(
+                extraction.entity_type,
+                extraction.entity_name,
+                JSON.stringify(extraction.structured_data),
+                id
+              );
+              for (const conn of extraction.suggested_connections) {
+                const target = sqlite.prepare(`SELECT id FROM memories WHERE entity_name = ? COLLATE NOCASE AND deleted_at IS NULL LIMIT 1`).get(conn.target_entity_name);
+                if (target && target.id !== id) {
+                  sqlite.prepare(
+                    `INSERT INTO memory_connections (source_memory_id, target_memory_id, relationship) VALUES (?, ?, ?)`
+                  ).run(id, target.id, conn.relationship);
+                }
+              }
+            })();
+            bumpLastModified(sqlite);
+          } catch {
+          }
+        })();
+      }
+      const fullText = params.content + (params.detail ? " " + params.detail : "");
+      const sentences = fullText.split(/(?<=[.!?])\s+/).filter((s) => s.length > 10);
+      let splitSuggestion = null;
+      if (sentences.length >= 3 && process.env.ANTHROPIC_API_KEY) {
+        try {
+          const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+          const resp = await client.messages.create({
+            model: "claude-haiku-4-5-20251001",
+            max_tokens: 512,
+            messages: [
+              {
+                role: "user",
+                content: `Analyze this memory and determine if it contains multiple distinct topics that should be stored separately. Only suggest splitting if the topics are genuinely independent (would be searched for separately).
+
+Memory content: ${JSON.stringify(params.content)}
+Memory detail: ${JSON.stringify(params.detail ?? null)}
+
+Respond with ONLY valid JSON:
+- If it should NOT be split: {"should_split": false}
+- If it SHOULD be split: {"should_split": true, "parts": [{"content": "...", "detail": "..."}, ...]}
+
+Each part should have a concise "content" (one sentence) and optional "detail". Do not split if the content is a single coherent topic.`
+              }
+            ]
+          });
+          const text2 = resp.content[0].type === "text" ? resp.content[0].text : "";
+          splitSuggestion = JSON.parse(text2);
+        } catch {
+        }
+      }
+      bumpLastModified(sqlite);
+      const result = {
+        id,
+        confidence,
+        domain: params.domain ?? "general",
+        created: true,
+        entityType: params.entityType ?? null,
+        entityName: params.entityName ?? null
+      };
+      if (!params.entityType && process.env.ANTHROPIC_API_KEY) {
+        result._background_classification = "running";
+      }
+      if (hasPii) {
+        result._pii_detected = [...new Set(piiMatches.map((m) => m.type))];
+      }
+      if (splitSuggestion?.should_split && splitSuggestion.parts) {
+        result.split_suggested = true;
+        result.suggested_parts = splitSuggestion.parts;
+        result.message = "This memory appears to contain multiple distinct topics. Consider calling memory_split to separate them.";
+      }
+      return textResult(result);
+    }
+  );
+  server.tool(
+    "memory_search",
+    "Search the user's persistent memory for relevant context. Call this at the start of conversations or before answering questions where prior knowledge about the user would help. Also call before asking the user something \u2014 the answer may already be in memory.",
+    {
+      query: z.string().describe("Search query"),
+      domain: z.string().optional().describe("Filter by domain"),
+      entityType: z.enum(["person", "organization", "place", "project", "preference", "event", "goal", "fact"]).optional().describe("Filter by entity type"),
+      entityName: z.string().optional().describe("Filter by entity name (case-insensitive)"),
+      minConfidence: z.number().optional().describe("Minimum confidence threshold"),
+      limit: z.number().optional().describe("Max results (default 20)"),
+      expand: z.boolean().optional().describe("Include connected memories (default true)"),
+      maxDepth: z.number().optional().describe("Max graph expansion depth (default 3)"),
+      similarityThreshold: z.number().optional().describe("Min similarity for connected memories (default 0.5)")
+    },
+    async (params) => {
+      maybeRunDecay();
+      const limit = params.limit ?? 20;
+      const { results: searchResults, cached: wasCached } = await hybridSearch(sqlite, params.query, {
+        domain: params.domain,
+        entityType: params.entityType,
+        entityName: params.entityName,
+        minConfidence: params.minConfidence,
+        limit,
+        expand: params.expand,
+        maxDepth: params.maxDepth,
+        similarityThreshold: params.similarityThreshold
+      });
+      if (searchResults.length === 0) {
+        return textResult({ memories: [], count: 0, totalConnected: 0, cached: wasCached });
+      }
+      const timestamp = now2();
+      const updateStmt = sqlite.prepare(
+        `UPDATE memories SET used_count = used_count + 1, last_used_at = ? WHERE id = ?`
+      );
+      const insertEventStmt = sqlite.prepare(
+        `INSERT INTO memory_events (id, memory_id, event_type, timestamp) VALUES (?, ?, 'used', ?)`
+      );
+      const batchUpdate = sqlite.transaction(() => {
+        for (const r of searchResults) {
+          updateStmt.run(timestamp, r.memory.id);
+          insertEventStmt.run(generateId2(), r.memory.id, timestamp);
+        }
+      });
+      batchUpdate();
+      return textResult({
+        memories: searchResults.map((r) => ({
+          ...r.memory,
+          _searchScore: r.score,
+          _connected: r.connected.map((c) => ({
+            ...c.memory,
+            _relationship: c.relationship,
+            _depth: c.depth,
+            _similarity: c.similarity
+          }))
+        })),
+        count: searchResults.length,
+        totalConnected: searchResults.reduce((sum, r) => sum + r.connected.length, 0),
+        cached: wasCached
+      });
+    }
+  );
+  server.tool(
+    "memory_update",
+    "Update an existing memory's content, detail, or domain",
+    {
+      id: z.string().describe("Memory ID to update"),
+      content: z.string().optional().describe("New content"),
+      detail: z.string().optional().describe("New detail"),
+      domain: z.string().optional().describe("New domain"),
+      agentId: z.string().optional().describe("Your agent ID"),
+      agentName: z.string().optional().describe("Your agent name")
+    },
+    async (params) => {
+      const existing = db.select().from(memories).where(and2(eq2(memories.id, params.id), isNull2(memories.deletedAt))).get();
+      if (!existing) {
+        return textResult({ error: "Memory not found or deleted" });
+      }
+      const updates = {};
+      if (params.content !== void 0) updates.content = params.content;
+      if (params.detail !== void 0) updates.detail = params.detail;
+      if (params.domain !== void 0) updates.domain = params.domain;
+      if (Object.keys(updates).length === 0) {
+        return textResult({ error: "No fields to update" });
+      }
+      db.update(memories).set(updates).where(eq2(memories.id, params.id)).run();
+      if (params.content !== void 0 && vecAvailable) {
+        try {
+          const detail = params.detail ?? existing.detail;
+          const embeddingText = params.content + (detail ? " " + detail : "");
+          const embedding = await generateEmbedding(embeddingText);
+          insertEmbedding(sqlite, params.id, embedding);
+        } catch {
+        }
+      }
+      db.insert(memoryEvents).values({
+        id: generateId2(),
+        memoryId: params.id,
+        eventType: "confidence_changed",
+        agentId: params.agentId ?? null,
+        agentName: params.agentName ?? null,
+        oldValue: JSON.stringify({
+          content: existing.content,
+          detail: existing.detail,
+          domain: existing.domain
+        }),
+        newValue: JSON.stringify(updates),
+        timestamp: now2()
+      }).run();
+      bumpLastModified(sqlite);
+      return textResult({ id: params.id, updated: true, changes: updates });
+    }
+  );
+  server.tool(
+    "memory_remove",
+    "Delete a memory the user no longer wants stored. Call when the user explicitly asks to forget something.",
+    {
+      id: z.string().describe("Memory ID to remove"),
+      reason: z.string().optional().describe("Reason for removal"),
+      agentId: z.string().optional().describe("Your agent ID"),
+      agentName: z.string().optional().describe("Your agent name")
+    },
+    async (params) => {
+      const existing = db.select().from(memories).where(and2(eq2(memories.id, params.id), isNull2(memories.deletedAt))).get();
+      if (!existing) {
+        return textResult({ error: "Memory not found or already deleted" });
+      }
+      const timestamp = now2();
+      db.update(memories).set({ deletedAt: timestamp }).where(eq2(memories.id, params.id)).run();
+      db.insert(memoryEvents).values({
+        id: generateId2(),
+        memoryId: params.id,
+        eventType: "removed",
+        agentId: params.agentId ?? null,
+        agentName: params.agentName ?? null,
+        newValue: JSON.stringify({ reason: params.reason }),
+        timestamp
+      }).run();
+      bumpLastModified(sqlite);
+      return textResult({ id: params.id, removed: true });
+    }
+  );
+  server.tool(
+    "memory_confirm",
+    "Confirm a memory is still accurate. Call this when you act on a memory and the user validates it was correct, or when the user reaffirms something you already know.",
+    {
+      id: z.string().describe("Memory ID to confirm"),
+      agentId: z.string().optional().describe("Your agent ID"),
+      agentName: z.string().optional().describe("Your agent name")
+    },
+    async (params) => {
+      const existing = db.select().from(memories).where(and2(eq2(memories.id, params.id), isNull2(memories.deletedAt))).get();
+      if (!existing) {
+        return textResult({ error: "Memory not found or deleted" });
+      }
+      const newConfidence = applyConfirm(existing.confidence);
+      const timestamp = now2();
+      db.update(memories).set({
+        confidence: newConfidence,
+        confirmedCount: existing.confirmedCount + 1,
+        confirmedAt: timestamp
+      }).where(eq2(memories.id, params.id)).run();
+      db.insert(memoryEvents).values({
+        id: generateId2(),
+        memoryId: params.id,
+        eventType: "confirmed",
+        agentId: params.agentId ?? null,
+        agentName: params.agentName ?? null,
+        oldValue: JSON.stringify({ confidence: existing.confidence }),
+        newValue: JSON.stringify({ confidence: newConfidence }),
+        timestamp
+      }).run();
+      bumpLastModified(sqlite);
+      return textResult({
+        id: params.id,
+        confirmed: true,
+        previousConfidence: existing.confidence,
+        newConfidence,
+        confirmedCount: existing.confirmedCount + 1
+      });
+    }
+  );
+  server.tool(
+    "memory_correct",
+    "Replace a memory's content with corrected information. Call this when the user says a memory is wrong and provides the right answer. Resets confidence to 0.50.",
+    {
+      id: z.string().describe("Memory ID to correct"),
+      content: z.string().describe("The corrected content"),
+      agentId: z.string().optional().describe("Your agent ID"),
+      agentName: z.string().optional().describe("Your agent name")
+    },
+    async (params) => {
+      const existing = db.select().from(memories).where(and2(eq2(memories.id, params.id), isNull2(memories.deletedAt))).get();
+      if (!existing) {
+        return textResult({ error: "Memory not found or deleted" });
+      }
+      const newConfidence = applyCorrect();
+      const timestamp = now2();
+      db.update(memories).set({
+        content: params.content,
+        confidence: newConfidence,
+        correctedCount: existing.correctedCount + 1
+      }).where(eq2(memories.id, params.id)).run();
+      if (vecAvailable) {
+        try {
+          const embedding = await generateEmbedding(params.content);
+          insertEmbedding(sqlite, params.id, embedding);
+        } catch {
+        }
+      }
+      db.insert(memoryEvents).values({
+        id: generateId2(),
+        memoryId: params.id,
+        eventType: "corrected",
+        agentId: params.agentId ?? null,
+        agentName: params.agentName ?? null,
+        oldValue: JSON.stringify({ content: existing.content, confidence: existing.confidence }),
+        newValue: JSON.stringify({ content: params.content, confidence: newConfidence }),
+        timestamp
+      }).run();
+      bumpLastModified(sqlite);
+      return textResult({
+        id: params.id,
+        corrected: true,
+        previousConfidence: existing.confidence,
+        newConfidence,
+        correctedCount: existing.correctedCount + 1
+      });
+    }
+  );
+  server.tool(
+    "memory_flag_mistake",
+    "Flag a memory as wrong or outdated. Call this when you act on a memory and the outcome was incorrect, or when the user says a memory is no longer true. Degrades confidence by 0.15.",
+    {
+      id: z.string().describe("Memory ID to flag"),
+      agentId: z.string().optional().describe("Your agent ID"),
+      agentName: z.string().optional().describe("Your agent name")
+    },
+    async (params) => {
+      const existing = db.select().from(memories).where(and2(eq2(memories.id, params.id), isNull2(memories.deletedAt))).get();
+      if (!existing) {
+        return textResult({ error: "Memory not found or deleted" });
+      }
+      const newConfidence = applyMistake(existing.confidence);
+      const timestamp = now2();
+      db.update(memories).set({
+        confidence: newConfidence,
+        mistakeCount: existing.mistakeCount + 1
+      }).where(eq2(memories.id, params.id)).run();
+      db.insert(memoryEvents).values({
+        id: generateId2(),
+        memoryId: params.id,
+        eventType: "confidence_changed",
+        agentId: params.agentId ?? null,
+        agentName: params.agentName ?? null,
+        oldValue: JSON.stringify({ confidence: existing.confidence }),
+        newValue: JSON.stringify({ confidence: newConfidence, flaggedAsMistake: true }),
+        timestamp
+      }).run();
+      bumpLastModified(sqlite);
+      return textResult({
+        id: params.id,
+        flagged: true,
+        previousConfidence: existing.confidence,
+        newConfidence,
+        mistakeCount: existing.mistakeCount + 1
+      });
+    }
+  );
+  server.tool(
+    "memory_connect",
+    "Create a relationship between two memories",
+    {
+      sourceMemoryId: z.string().describe("Source memory ID"),
+      targetMemoryId: z.string().describe("Target memory ID"),
+      relationship: z.enum(["influences", "supports", "contradicts", "related", "learned-together", "works_at", "involves", "located_at", "part_of", "about"]).describe("Type of relationship")
+    },
+    async (params) => {
+      if (params.sourceMemoryId === params.targetMemoryId) {
+        return textResult({ error: "Cannot connect a memory to itself" });
+      }
+      const source = db.select().from(memories).where(eq2(memories.id, params.sourceMemoryId)).get();
+      const target = db.select().from(memories).where(eq2(memories.id, params.targetMemoryId)).get();
+      if (!source || !target) {
+        return textResult({ error: "One or both memories not found" });
+      }
+      db.insert(memoryConnections).values({
+        sourceMemoryId: params.sourceMemoryId,
+        targetMemoryId: params.targetMemoryId,
+        relationship: params.relationship
+      }).run();
+      bumpLastModified(sqlite);
+      return textResult({
+        connected: true,
+        sourceMemoryId: params.sourceMemoryId,
+        targetMemoryId: params.targetMemoryId,
+        relationship: params.relationship
+      });
+    }
+  );
+  server.tool(
+    "memory_split",
+    "Split a memory that contains multiple distinct facts into separate memories. Call this when a memory covers more than one topic or would be more useful as individual pieces. Each new memory inherits the original's domain and source metadata, and the originals are connected with 'related' relationships.",
+    {
+      id: z.string().describe("Memory ID to split"),
+      parts: z.array(
+        z.object({
+          content: z.string().describe("Content for this part"),
+          detail: z.string().optional().describe("Optional detail for this part"),
+          domain: z.string().optional().describe("Override domain for this part")
+        })
+      ).min(2).describe("The separate memories to create from the original"),
+      agentId: z.string().optional().describe("Your agent ID"),
+      agentName: z.string().optional().describe("Your agent name")
+    },
+    async (params) => {
+      const existing = db.select().from(memories).where(and2(eq2(memories.id, params.id), isNull2(memories.deletedAt))).get();
+      if (!existing) {
+        return textResult({ error: "Memory not found or deleted" });
+      }
+      const timestamp = now2();
+      const newIds = [];
+      for (const part of params.parts) {
+        const newId = generateId2();
+        newIds.push(newId);
+        db.insert(memories).values({
+          id: newId,
+          content: part.content,
+          detail: part.detail ?? null,
+          domain: part.domain ?? existing.domain,
+          sourceAgentId: existing.sourceAgentId,
+          sourceAgentName: existing.sourceAgentName,
+          sourceType: existing.sourceType,
+          sourceDescription: existing.sourceDescription,
+          confidence: Math.min(existing.confidence + 0.05, 0.99),
+          learnedAt: timestamp
+        }).run();
+        if (vecAvailable) {
+          try {
+            const embeddingText = part.content + (part.detail ? " " + part.detail : "");
+            const embedding = await generateEmbedding(embeddingText);
+            insertEmbedding(sqlite, newId, embedding);
+          } catch {
+          }
+        }
+        db.insert(memoryEvents).values({
+          id: generateId2(),
+          memoryId: newId,
+          eventType: "created",
+          agentId: params.agentId ?? null,
+          agentName: params.agentName ?? null,
+          newValue: JSON.stringify({ content: part.content, splitFrom: params.id }),
+          timestamp
+        }).run();
+      }
+      for (let i = 0; i < newIds.length; i++) {
+        for (let j = i + 1; j < newIds.length; j++) {
+          db.insert(memoryConnections).values({
+            sourceMemoryId: newIds[i],
+            targetMemoryId: newIds[j],
+            relationship: "related"
+          }).run();
+        }
+      }
+      db.update(memories).set({ deletedAt: timestamp }).where(eq2(memories.id, params.id)).run();
+      db.insert(memoryEvents).values({
+        id: generateId2(),
+        memoryId: params.id,
+        eventType: "removed",
+        agentId: params.agentId ?? null,
+        agentName: params.agentName ?? null,
+        newValue: JSON.stringify({ reason: "split", splitInto: newIds }),
+        timestamp
+      }).run();
+      bumpLastModified(sqlite);
+      return textResult({
+        split: true,
+        originalId: params.id,
+        newMemories: newIds,
+        count: newIds.length
+      });
+    }
+  );
+  server.tool(
+    "memory_scrub",
+    "Scan a memory for sensitive data (PII, API keys, etc.) and optionally redact it. Use this to check memories before sharing or to clean up accidentally stored secrets.",
+    {
+      id: z.string().describe("Memory ID to scan"),
+      redact: z.boolean().optional().describe("Replace detected PII with redaction tokens (default false)")
+    },
+    async (params) => {
+      const existing = db.select().from(memories).where(and2(eq2(memories.id, params.id), isNull2(memories.deletedAt))).get();
+      if (!existing) {
+        return textResult({ error: "Memory not found or deleted" });
+      }
+      const fullText = existing.content + (existing.detail ? " " + existing.detail : "");
+      const matches = detectSensitiveData(fullText);
+      if (params.redact && matches.length > 0) {
+        const { redacted: redactedContent } = redactSensitiveData(existing.content);
+        const redactedDetail = existing.detail ? redactSensitiveData(existing.detail).redacted : null;
+        db.update(memories).set({
+          content: redactedContent,
+          detail: redactedDetail,
+          hasPiiFlag: 0
+        }).where(eq2(memories.id, params.id)).run();
+        if (vecAvailable) {
+          try {
+            const embeddingText = redactedContent + (redactedDetail ? " " + redactedDetail : "");
+            const embedding = await generateEmbedding(embeddingText);
+            insertEmbedding(sqlite, params.id, embedding);
+          } catch {
+          }
+        }
+        db.insert(memoryEvents).values({
+          id: generateId2(),
+          memoryId: params.id,
+          eventType: "corrected",
+          agentName: "engrams:scrub",
+          oldValue: JSON.stringify({ content: existing.content, detail: existing.detail }),
+          newValue: JSON.stringify({ content: redactedContent, detail: redactedDetail }),
+          timestamp: now2()
+        }).run();
+        bumpLastModified(sqlite);
+        return textResult({
+          id: params.id,
+          scrubbed: true,
+          detected: matches.map((m) => ({ type: m.type, start: m.start, end: m.end })),
+          redactedContent,
+          redactedDetail
+        });
+      }
+      return textResult({
+        id: params.id,
+        detected: matches.map((m) => ({ type: m.type, start: m.start, end: m.end })),
+        hasPii: matches.length > 0,
+        count: matches.length
+      });
+    }
+  );
+  server.tool(
+    "memory_get_connections",
+    "Get all connections for a memory",
+    {
+      memoryId: z.string().describe("Memory ID to get connections for")
+    },
+    async (params) => {
+      const outgoing = db.select().from(memoryConnections).where(eq2(memoryConnections.sourceMemoryId, params.memoryId)).all();
+      const incoming = db.select().from(memoryConnections).where(eq2(memoryConnections.targetMemoryId, params.memoryId)).all();
+      return textResult({
+        memoryId: params.memoryId,
+        outgoing,
+        incoming,
+        totalConnections: outgoing.length + incoming.length
+      });
+    }
+  );
+  server.tool(
+    "memory_list_domains",
+    "List all memory domains with counts",
+    {},
+    async () => {
+      const results = sqlite.prepare(
+        `SELECT domain, COUNT(*) as count FROM memories WHERE deleted_at IS NULL GROUP BY domain ORDER BY count DESC`
+      ).all();
+      return textResult({ domains: results });
+    }
+  );
+  server.tool(
+    "memory_list",
+    "Browse the user's memories by domain. Use this to show the user what you know about them in a specific area, or to review memories before a task.",
+    {
+      domain: z.string().optional().describe("Filter by domain"),
+      entityType: z.enum(["person", "organization", "place", "project", "preference", "event", "goal", "fact"]).optional().describe("Filter by entity type"),
+      entityName: z.string().optional().describe("Filter by entity name (case-insensitive)"),
+      sortBy: z.enum(["confidence", "recency"]).optional().describe("Sort order (default: confidence)"),
+      limit: z.number().optional().describe("Max results (default 20)"),
+      offset: z.number().optional().describe("Offset for pagination")
+    },
+    async (params) => {
+      maybeRunDecay();
+      const limit = params.limit ?? 20;
+      const offset = params.offset ?? 0;
+      const sortBy = params.sortBy ?? "confidence";
+      let query = `SELECT * FROM memories WHERE deleted_at IS NULL`;
+      const queryParams = [];
+      if (params.domain) {
+        query += ` AND domain = ?`;
+        queryParams.push(params.domain);
+      }
+      if (params.entityType) {
+        query += ` AND entity_type = ?`;
+        queryParams.push(params.entityType);
+      }
+      if (params.entityName) {
+        query += ` AND entity_name = ? COLLATE NOCASE`;
+        queryParams.push(params.entityName);
+      }
+      if (sortBy === "confidence") {
+        query += ` ORDER BY confidence DESC`;
+      } else {
+        query += ` ORDER BY learned_at DESC`;
+      }
+      query += ` LIMIT ? OFFSET ?`;
+      queryParams.push(limit, offset);
+      const results = sqlite.prepare(query).all(...queryParams);
+      const countQuery = params.domain ? sqlite.prepare(`SELECT COUNT(*) as total FROM memories WHERE deleted_at IS NULL AND domain = ?`).get(params.domain) : sqlite.prepare(`SELECT COUNT(*) as total FROM memories WHERE deleted_at IS NULL`).get();
+      return textResult({
+        memories: results,
+        count: results.length,
+        total: countQuery.total,
+        offset,
+        limit
+      });
+    }
+  );
+  server.tool(
+    "memory_classify",
+    "Batch-classify untyped memories using entity extraction. Runs in the background and returns progress. Use this to backfill entity types on existing memories.",
+    {
+      limit: z.number().optional().describe("Max memories to classify (default 50)"),
+      domain: z.string().optional().describe("Only classify memories in this domain")
+    },
+    async (params) => {
+      if (!process.env.ANTHROPIC_API_KEY) {
+        return textResult({ error: "ANTHROPIC_API_KEY not set \u2014 entity extraction requires an API key" });
+      }
+      const classifyLimit = params.limit ?? 50;
+      let query = `SELECT id, content, detail FROM memories WHERE entity_type IS NULL AND deleted_at IS NULL`;
+      const queryParams = [];
+      if (params.domain) {
+        query += ` AND domain = ?`;
+        queryParams.push(params.domain);
+      }
+      query += ` LIMIT ?`;
+      queryParams.push(classifyLimit);
+      const untyped = sqlite.prepare(query).all(...queryParams);
+      if (untyped.length === 0) {
+        return textResult({ status: "complete", classified: 0, message: "No untyped memories found" });
+      }
+      const existingNames = sqlite.prepare(`SELECT DISTINCT entity_name FROM memories WHERE entity_name IS NOT NULL AND deleted_at IS NULL`).all();
+      const nameList = existingNames.map((r) => r.entity_name);
+      let classified = 0;
+      let errors = 0;
+      for (const mem of untyped) {
+        try {
+          const extraction = await extractEntity(mem.content, mem.detail, nameList);
+          sqlite.transaction(() => {
+            sqlite.prepare(
+              `UPDATE memories SET entity_type = ?, entity_name = ?, structured_data = ? WHERE id = ? AND entity_type IS NULL AND deleted_at IS NULL`
+            ).run(
+              extraction.entity_type,
+              extraction.entity_name,
+              JSON.stringify(extraction.structured_data),
+              mem.id
+            );
+            for (const conn of extraction.suggested_connections) {
+              const target = sqlite.prepare(`SELECT id FROM memories WHERE entity_name = ? COLLATE NOCASE AND deleted_at IS NULL LIMIT 1`).get(conn.target_entity_name);
+              if (target && target.id !== mem.id) {
+                sqlite.prepare(
+                  `INSERT INTO memory_connections (source_memory_id, target_memory_id, relationship) VALUES (?, ?, ?)`
+                ).run(mem.id, target.id, conn.relationship);
+              }
+            }
+          })();
+          classified++;
+          if (extraction.entity_name) nameList.push(extraction.entity_name);
+        } catch {
+          errors++;
+        }
+        if (classified + errors < untyped.length) {
+          await new Promise((resolve3) => setTimeout(resolve3, 200));
+        }
+      }
+      if (classified > 0) bumpLastModified(sqlite);
+      return textResult({
+        status: "complete",
+        classified,
+        errors,
+        remaining: Math.max(0, sqlite.prepare(`SELECT COUNT(*) as c FROM memories WHERE entity_type IS NULL AND deleted_at IS NULL`).get().c)
+      });
+    }
+  );
+  server.tool(
+    "memory_list_entities",
+    "List all known entities grouped by type. Useful for discovering what the system knows about people, organizations, projects, etc.",
+    {
+      entityType: z.enum(["person", "organization", "place", "project", "preference", "event", "goal", "fact"]).optional().describe("Filter to a specific entity type")
+    },
+    async (params) => {
+      let query = `SELECT entity_type, entity_name, COUNT(*) as memory_count
+        FROM memories
+        WHERE entity_type IS NOT NULL AND entity_name IS NOT NULL AND deleted_at IS NULL`;
+      const queryParams = [];
+      if (params.entityType) {
+        query += ` AND entity_type = ?`;
+        queryParams.push(params.entityType);
+      }
+      query += ` GROUP BY entity_type, entity_name ORDER BY entity_type, memory_count DESC`;
+      const rows = sqlite.prepare(query).all(...queryParams);
+      const grouped = {};
+      for (const row of rows) {
+        if (!grouped[row.entity_type]) grouped[row.entity_type] = [];
+        grouped[row.entity_type].push({ name: row.entity_name, count: row.memory_count });
+      }
+      return textResult({
+        entities: grouped,
+        totalEntities: rows.length,
+        totalMemoriesWithEntities: rows.reduce((sum, r) => sum + r.memory_count, 0)
+      });
+    }
+  );
+  server.tool(
+    "memory_set_permissions",
+    "Set per-agent read/write permissions for a domain",
+    {
+      agentId: z.string().describe("Agent ID"),
+      domain: z.string().describe("Domain (* for all)"),
+      canRead: z.boolean().optional().describe("Allow reading (default true)"),
+      canWrite: z.boolean().optional().describe("Allow writing (default true)")
+    },
+    async (params) => {
+      const existing = db.select().from(agentPermissions).where(
+        and2(
+          eq2(agentPermissions.agentId, params.agentId),
+          eq2(agentPermissions.domain, params.domain)
+        )
+      ).get();
+      const canRead = params.canRead !== void 0 ? params.canRead ? 1 : 0 : 1;
+      const canWrite = params.canWrite !== void 0 ? params.canWrite ? 1 : 0 : 1;
+      if (existing) {
+        db.update(agentPermissions).set({ canRead, canWrite }).where(
+          and2(
+            eq2(agentPermissions.agentId, params.agentId),
+            eq2(agentPermissions.domain, params.domain)
+          )
+        ).run();
+      } else {
+        db.insert(agentPermissions).values({
+          agentId: params.agentId,
+          domain: params.domain,
+          canRead,
+          canWrite
+        }).run();
+      }
+      return textResult({
+        agentId: params.agentId,
+        domain: params.domain,
+        canRead: !!canRead,
+        canWrite: !!canWrite,
+        updated: true
+      });
+    }
+  );
+  server.resource("memory-index", "memory://index", async (uri) => {
+    const domains = sqlite.prepare(
+      `SELECT domain, COUNT(*) as count FROM memories WHERE deleted_at IS NULL GROUP BY domain`
+    ).all();
+    const totalResult = sqlite.prepare(`SELECT COUNT(*) as total FROM memories WHERE deleted_at IS NULL`).get();
+    const confidenceDist = sqlite.prepare(`
+        SELECT
+          SUM(CASE WHEN confidence >= 0.9 THEN 1 ELSE 0 END) as high,
+          SUM(CASE WHEN confidence >= 0.5 AND confidence < 0.9 THEN 1 ELSE 0 END) as medium,
+          SUM(CASE WHEN confidence < 0.5 THEN 1 ELSE 0 END) as low
+        FROM memories WHERE deleted_at IS NULL
+      `).get();
+    return {
+      contents: [
+        {
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify(
+            { total: totalResult.total, domains, confidenceDistribution: confidenceDist },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  });
+  server.resource(
+    "memory-domain",
+    new ResourceTemplate("memory://domain/{name}", { list: void 0 }),
+    async (uri, params) => {
+      const name = params.name;
+      const results = sqlite.prepare(
+        `SELECT * FROM memories WHERE deleted_at IS NULL AND domain = ? ORDER BY confidence DESC`
+      ).all(name);
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify({ domain: name, memories: results }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.resource("memory-recent", "memory://recent", async (uri) => {
+    const results = sqlite.prepare(
+      `SELECT * FROM memories WHERE deleted_at IS NULL ORDER BY learned_at DESC LIMIT 20`
+    ).all();
+    return {
+      contents: [
+        {
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify({ memories: results, count: results.length }, null, 2)
+        }
+      ]
+    };
+  });
+  if (process.argv.includes("--http") || process.env.ENGRAMS_HTTP === "1") {
+    const { startHttpApi: startHttpApi2 } = await Promise.resolve().then(() => (init_http(), http_exports));
+    startHttpApi2(db, sqlite);
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+export {
+  startServer
+};