@hasna/mementos 0.14.58 → 0.14.59

package/dist/server/index.js

@@ -467,6 +467,10 @@ var init_storage = __esm(() => {
 });
 
 // src/db/api-mode.ts
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+import { writeFileSync as writeFileSync3, unlinkSync as unlinkSync2 } from "fs";
+import { randomUUID } from "crypto";
 function firstEnv(...keys) {
   for (const k of keys) {
     const v = process.env[k]?.trim();
@@ -502,33 +506,60 @@ function apiRequestRaw(method, path, body) {
     throw new Error("api-mode: not configured (HASNA_MEMENTOS_API_URL / HASNA_MEMENTOS_API_KEY)");
   const url = `${cfg.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
   const hasBody = body !== undefined && body !== null;
-  const payload = hasBody ? JSON.stringify(body) : "";
-  const script = [
-    "curl -sS --fail-with-body",
-    `-m "$MEM_API_TIMEOUT"`,
-    `-X "$MEM_API_METHOD"`,
-    `-H "Authorization: Bearer $MEM_API_KEY"`,
-    `-H "x-api-key: $MEM_API_KEY"`,
-    `-H "Content-Type: application/json"`,
-    `-H "Accept: application/json"`,
-    hasBody ? "--data-binary @-" : "",
-    `-w '\\n%{http_code}'`,
-    `"$MEM_API_URL"`
-  ].filter(Boolean).join(" ");
-  const proc = Bun.spawnSync(["bash", "-c", script], {
-    stdin: hasBody ? Buffer.from(payload) : undefined,
-    env: {
-      ...process.env,
-      MEM_API_KEY: cfg.apiKey,
-      MEM_API_URL: url,
-      MEM_API_METHOD: method,
-      MEM_API_TIMEOUT: process.env["HASNA_MEMENTOS_API_TIMEOUT"] || DEFAULT_TIMEOUT_S
-    },
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const out = proc.stdout ? new TextDecoder().decode(proc.stdout) : "";
-  const err = proc.stderr ? new TextDecoder().decode(proc.stderr) : "";
+  const timeout = process.env["HASNA_MEMENTOS_API_TIMEOUT"] || DEFAULT_TIMEOUT_S;
+  const headerLines = `Authorization: Bearer ${cfg.apiKey}
+x-api-key: ${cfg.apiKey}
+`;
+  const args = [
+    "curl",
+    "-sS",
+    "--fail-with-body",
+    "-m",
+    timeout,
+    "-X",
+    method,
+    "-H",
+    "@-",
+    "-H",
+    "Content-Type: application/json",
+    "-H",
+    "Accept: application/json",
+    "-w",
+    "\\n%{http_code}"
+  ];
+  let bodyFile;
+  if (hasBody) {
+    bodyFile = join3(tmpdir(), `mem-req-${process.pid}-${randomUUID()}.json`);
+    writeFileSync3(bodyFile, JSON.stringify(body), { mode: 384 });
+    args.push("--data-binary", `@${bodyFile}`);
+  }
+  args.push(url);
+  const childEnv = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === undefined)
+      continue;
+    if (k === "HASNA_MEMENTOS_API_KEY" || k === "MEMENTOS_API_KEY")
+      continue;
+    childEnv[k] = v;
+  }
+  let out = "";
+  let err = "";
+  try {
+    const proc = Bun.spawnSync(args, {
+      stdin: Buffer.from(headerLines),
+      stdout: "pipe",
+      stderr: "pipe",
+      env: childEnv
+    });
+    out = proc.stdout ? new TextDecoder().decode(proc.stdout) : "";
+    err = proc.stderr ? new TextDecoder().decode(proc.stderr) : "";
+  } finally {
+    if (bodyFile) {
+      try {
+        unlinkSync2(bodyFile);
+      } catch {}
+    }
+  }
   const nl = out.lastIndexOf(`
 `);
   const codeStr = nl >= 0 ? out.slice(nl + 1).trim() : "";
@@ -1507,7 +1538,7 @@ __export(exports_database, {
   closeDatabase: () => closeDatabase
 });
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, cpSync as cpSync2 } from "fs";
-import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+import { dirname as dirname2, join as join4, resolve as resolve2 } from "path";
 function isInMemoryDb2(path) {
   return path === ":memory:" || path.startsWith("file::memory:");
 }
@@ -1516,7 +1547,7 @@ function findNearestMementosDb(startDir) {
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
   const legacyHomeDb = resolve2(home, ".mementos", "mementos.db");
   while (true) {
-    const candidate = join3(dir, ".mementos", "mementos.db");
+    const candidate = join4(dir, ".mementos", "mementos.db");
     if (existsSync3(candidate) && resolve2(candidate) !== legacyHomeDb)
       return candidate;
     const parent = dirname2(dir);
@@ -1529,7 +1560,7 @@ function findNearestMementosDb(startDir) {
 function findGitRoot2(startDir) {
   let dir = resolve2(startDir);
   while (true) {
-    if (existsSync3(join3(dir, ".git")))
+    if (existsSync3(join4(dir, ".git")))
       return dir;
     const parent = dirname2(dir);
     if (parent === dir)
@@ -1540,10 +1571,10 @@ function findGitRoot2(startDir) {
 }
 function migrateGlobalDir() {
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-  const newDir = join3(home, ".hasna", "mementos");
-  const oldDir = join3(home, ".mementos");
+  const newDir = join4(home, ".hasna", "mementos");
+  const oldDir = join4(home, ".mementos");
   if (!existsSync3(newDir) && existsSync3(oldDir)) {
-    mkdirSync3(join3(home, ".hasna"), { recursive: true });
+    mkdirSync3(join4(home, ".hasna"), { recursive: true });
     cpSync2(oldDir, newDir, { recursive: true });
   }
 }
@@ -1559,12 +1590,12 @@ function getDbPath2() {
   if (process.env["MEMENTOS_DB_SCOPE"] === "project") {
     const gitRoot = findGitRoot2(cwd);
     if (gitRoot) {
-      return join3(gitRoot, ".mementos", "mementos.db");
+      return join4(gitRoot, ".mementos", "mementos.db");
     }
   }
   migrateGlobalDir();
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-  return join3(home, ".hasna", "mementos", "mementos.db");
+  return join4(home, ".hasna", "mementos", "mementos.db");
 }
 function ensureDir2(filePath) {
   if (isInMemoryDb2(filePath))
@@ -2029,6 +2060,18 @@ var init_poisoning = __esm(() => {
 });
 
 // src/db/entity-memories.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 parseEntityMemoryRow(row) {
   return {
     entity_id: row["entity_id"],
@@ -2072,6 +2115,14 @@ function getMemoriesForEntity(entityId, db) {
        ORDER BY m.importance DESC, m.created_at DESC`).all(entityId);
   return rows.map(parseMemoryRow);
 }
+function getEntitiesForMemory(memoryId, db) {
+  const d = db || getDatabase();
+  const rows = d.query(`SELECT e.* FROM entities e
+       INNER JOIN entity_memories em ON em.entity_id = e.id
+       WHERE em.memory_id = ?
+       ORDER BY e.name ASC`).all(memoryId);
+  return rows.map(parseEntityRow);
+}
 function getEntityMemoryLinks(entityId, memoryId, db) {
   const d = db || getDatabase();
   const conditions = [];
@@ -2107,12 +2158,14 @@ __export(exports_memories, {
   parseMemoryRow: () => parseMemoryRow,
   listMemoryHistory: () => listMemoryHistory,
   listMemories: () => listMemories,
+  listLowTrustMemories: () => listLowTrustMemories,
   indexMemoryEmbedding: () => indexMemoryEmbedding,
   incrementRecallCount: () => incrementRecallCount,
   getMemoryVersions: () => getMemoryVersions,
   getMemoryEmbeddings: () => getMemoryEmbeddings,
   getMemoryChain: () => getMemoryChain,
   getMemoryByKey: () => getMemoryByKey,
+  getMemoryBriefing: () => getMemoryBriefing,
   getMemory: () => getMemory,
   getMemoriesByKey: () => getMemoriesByKey,
   deleteMemory: () => deleteMemory,
@@ -2122,6 +2175,14 @@ __export(exports_memories, {
   bulkDeleteMemories: () => bulkDeleteMemories
 });
 function runEntityExtraction(_memory, _projectId, _d) {}
+function applyContentType(d, id, memory, contentType) {
+  if (!contentType || contentType === "text")
+    return;
+  try {
+    d.run("UPDATE memories SET content_type = ? WHERE id = ?", [contentType, id]);
+    memory.content_type = contentType;
+  } catch {}
+}
 function parseMemoryRow(row) {
   return {
     id: row["id"],
@@ -2226,6 +2287,7 @@ function createMemory(input, dedupeMode = "merge", db) {
         insertTag2.run(existing.id, tag);
       }
       const merged = getMemory(existing.id, d);
+      applyContentType(d, existing.id, merged, input.content_type);
       try {
         const existingMemories = listMemoriesByKey(input.key, d);
         const trustScore = computeTrustScore(safeValue, input.key, existingMemories, input.importance);
@@ -2275,6 +2337,7 @@ function createMemory(input, dedupeMode = "merge", db) {
     insertTag.run(id, tag);
   }
   const memory = getMemory(id, d);
+  applyContentType(d, id, memory, input.content_type);
   try {
     const existingMemories = listMemoriesByKey(input.key, d);
     const trustScore = computeTrustScore(safeValue, input.key, existingMemories, input.importance);
@@ -2609,6 +2672,66 @@ function listMemories(filter, db) {
   const rows = d.query(sql).all(...params);
   return rows.map(parseMemoryRow);
 }
+function getMemoryBriefing(opts, db) {
+  const limit = opts.limit ?? 20;
+  if (!db && isApiMode()) {
+    const q = toQuery({
+      since: opts.since,
+      scope: opts.scope,
+      project_id: opts.project_id,
+      machine_agnostic: opts.visible_machine_id === null || opts.visible_machine_id === undefined ? true : undefined,
+      visible_machine_id: typeof opts.visible_machine_id === "string" ? opts.visible_machine_id : undefined,
+      limit
+    });
+    const { data } = apiJson("GET", `/memories/briefing${q}`);
+    return data ?? { new: [], updated: [], expired: [] };
+  }
+  const d = db || getDatabase();
+  const visibleMachineId = opts.visible_machine_id;
+  const scopeClause = opts.scope ? "AND scope = ?" : "";
+  const projectClause = opts.project_id ? "AND project_id = ?" : "";
+  const machineClause = typeof visibleMachineId === "string" ? "AND (machine_id IS NULL OR machine_id = ?)" : "AND machine_id IS NULL";
+  const extraParams = [
+    ...opts.scope ? [opts.scope] : [],
+    ...opts.project_id ? [opts.project_id] : [],
+    ...typeof visibleMachineId === "string" ? [visibleMachineId] : []
+  ];
+  const newRows = d.prepare(`SELECT * FROM memories
+     WHERE status = 'active' AND created_at > ? ${scopeClause} ${projectClause} ${machineClause}
+     ORDER BY importance DESC, created_at DESC LIMIT ?`).all(opts.since, ...extraParams, limit);
+  const updatedRows = d.prepare(`SELECT * FROM memories
+     WHERE status = 'active' AND updated_at > ? AND created_at <= ? ${scopeClause} ${projectClause} ${machineClause}
+     ORDER BY importance DESC, updated_at DESC LIMIT ?`).all(opts.since, opts.since, ...extraParams, limit);
+  const expiredRows = d.prepare(`SELECT * FROM memories
+     WHERE status != 'active' AND updated_at > ? ${scopeClause} ${projectClause} ${machineClause}
+     ORDER BY updated_at DESC LIMIT ?`).all(opts.since, ...extraParams, Math.min(limit, 10));
+  return {
+    new: newRows.map(parseMemoryRow),
+    updated: updatedRows.map(parseMemoryRow),
+    expired: expiredRows.map(parseMemoryRow)
+  };
+}
+function listLowTrustMemories(opts = {}, db) {
+  const threshold = opts.threshold ?? 0.8;
+  const limit = opts.limit ?? 20;
+  const offset = opts.offset ?? 0;
+  if (!db && isApiMode()) {
+    const q = toQuery({ threshold, project_id: opts.project_id, limit, offset });
+    const { data } = apiJson("GET", `/memories/audit${q}`);
+    return data?.memories ?? [];
+  }
+  const d = db || getDatabase();
+  const conditions = ["trust_score < ?", "status = 'active'"];
+  const params = [threshold];
+  if (opts.project_id) {
+    const resolved = resolvePartialId(d, "projects", opts.project_id);
+    conditions.push("project_id = ?");
+    params.push(resolved ?? opts.project_id);
+  }
+  params.push(limit, offset);
+  const rows = d.prepare(`SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY trust_score ASC LIMIT ? OFFSET ?`).all(...params);
+  return rows.map(parseMemoryRow);
+}
 function listMemoryHistory(opts = {}, db) {
   const limit = opts.limit ?? 20;
   const offset = opts.offset ?? 0;
@@ -2820,6 +2943,10 @@ function incrementRecallCount(id, db) {
   } catch {}
 }
 function cleanExpiredMemories(db) {
+  if (!db && isApiMode()) {
+    const { data } = apiJson("POST", "/memories/clean");
+    return data?.cleaned ?? 0;
+  }
   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);
@@ -2872,6 +2999,12 @@ async function semanticSearch(queryText, options = {}, db) {
   }
   const d = db || getDatabase();
   const { threshold = 0.5, limit = 10, scope, agent_id, project_id } = options;
+  if (options.index_missing) {
+    const unindexed = d.prepare(`SELECT id, value, summary, when_to_use FROM memories
+       WHERE status = 'active' AND id NOT IN (SELECT memory_id FROM memory_embeddings)
+       LIMIT 100`).all();
+    await Promise.all(unindexed.map((m) => indexMemoryEmbedding(m.id, m.when_to_use || [m.value, m.summary].filter(Boolean).join(" "), d)));
+  }
   const { embedding: queryEmbedding } = await generateEmbedding(queryText);
   const conditions = ["m.status = 'active'", "e.embedding IS NOT NULL"];
   const params = [];
@@ -2917,7 +3050,7 @@ var init_memories = __esm(() => {
 });
 
 // src/db/entities.ts
-function parseEntityRow(row) {
+function parseEntityRow2(row) {
   return {
     id: row["id"],
     name: row["name"],
@@ -2987,7 +3120,7 @@ function getEntity(id, db) {
   const row = d.query("SELECT * FROM entities WHERE id = ?").get(id);
   if (!row)
     throw new EntityNotFoundError(id);
-  return parseEntityRow(row);
+  return parseEntityRow2(row);
 }
 function getEntityByName(name, type, projectId, db) {
   if (!db && isApiMode()) {
@@ -3012,7 +3145,7 @@ function getEntityByName(name, type, projectId, db) {
   const row = d.query(sql).get(...params);
   if (!row)
     return null;
-  return parseEntityRow(row);
+  return parseEntityRow2(row);
 }
 function listEntities(filter = {}, db) {
   if (!db && isApiMode()) {
@@ -3056,7 +3189,7 @@ function listEntities(filter = {}, db) {
     params.push(filter.offset);
   }
   const rows = d.query(sql).all(...params);
-  return rows.map(parseEntityRow);
+  return rows.map(parseEntityRow2);
 }
 function updateEntity(id, input, db) {
   if (!db && isApiMode()) {
@@ -3961,7 +4094,7 @@ function parseRelationRow(row) {
     created_at: row["created_at"]
   };
 }
-function parseEntityRow2(row) {
+function parseEntityRow3(row) {
   return {
     id: row["id"],
     name: row["name"],
@@ -4071,7 +4204,7 @@ function getEntityGraph(entityId, depth = 2, db) {
         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 entities = entityRows.map(parseEntityRow3);
   const entityIds = new Set(entities.map((e) => e.id));
   if (entityIds.size === 0) {
     return { entities: [], relations: [] };
@@ -4111,7 +4244,7 @@ function findPath(fromEntityId, toEntityId, maxDepth = 5, db) {
   for (const id of ids) {
     const row = d.query("SELECT * FROM entities WHERE id = ?").get(id);
     if (row)
-      entities.push(parseEntityRow2(row));
+      entities.push(parseEntityRow3(row));
   }
   return entities.length > 0 ? entities : null;
 }
@@ -52199,7 +52332,7 @@ var init_openapi = __esm(() => {
 // src/server/index.ts
 import { existsSync as existsSync5 } from "fs";
 import { createRequire } from "module";
-import { join as join5, resolve as resolve4, sep } from "path";
+import { join as join6, resolve as resolve4, sep } from "path";
 
 // src/lib/config.ts
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync, cpSync } from "fs";
@@ -53820,7 +53953,7 @@ init_router();
 
 // src/server/helpers.ts
 import { existsSync as existsSync4 } from "fs";
-import { dirname as dirname3, extname, join as join4 } from "path";
+import { dirname as dirname3, extname, join as join5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var CORS_HEADERS = {
   "Access-Control-Allow-Origin": process.env["MEMENTOS_CORS_ORIGIN"] ?? "http://localhost:19428",
@@ -53905,20 +54038,20 @@ function resolveDashboardDir() {
   const candidates = [];
   try {
     const scriptDir = dirname3(fileURLToPath2(import.meta.url));
-    candidates.push(join4(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join4(scriptDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join5(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join5(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
     const mainDir = dirname3(process.argv[1]);
-    candidates.push(join4(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join4(mainDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join5(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join5(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join4(process.cwd(), "dashboard", "dist"));
+  candidates.push(join5(process.cwd(), "dashboard", "dist"));
   for (const c of candidates) {
     if (existsSync4(c))
       return c;
   }
-  return join4(process.cwd(), "dashboard", "dist");
+  return join5(process.cwd(), "dashboard", "dist");
 }
 function serveStaticFile(filePath) {
   if (!existsSync4(filePath))
@@ -54468,6 +54601,500 @@ addRoute("GET", "/api/report", (_req, url) => {
 // src/server/routes/memories-search.ts
 init_search();
 init_memories();
+
+// src/lib/asmr/fact-agent.ts
+init_memories();
+function escapeFts5Token(token) {
+  return `"${token.replace(/"/g, '""')}"`;
+}
+function hasFts5Table2(db) {
+  try {
+    const row = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'").get();
+    return !!row;
+  } catch {
+    return false;
+  }
+}
+function buildScopeFilter(opts) {
+  const conditions = [
+    "m.status = 'active'",
+    "(m.expires_at IS NULL OR m.expires_at >= datetime('now'))",
+    "m.category IN ('preference', 'fact', 'knowledge')"
+  ];
+  const params = [];
+  if (opts.project_id) {
+    conditions.push("m.project_id = ?");
+    params.push(opts.project_id);
+  }
+  if (opts.agent_id) {
+    conditions.push("m.agent_id = ?");
+    params.push(opts.agent_id);
+  }
+  return { conditions, params };
+}
+function scoreFactMemory(memory, queryLower) {
+  const keyLower = memory.key.toLowerCase();
+  const valueLower = memory.value.toLowerCase();
+  let score = 0;
+  let matchField = "value";
+  if (keyLower === queryLower) {
+    score = 10;
+    matchField = "key (exact)";
+  } else if (keyLower.includes(queryLower)) {
+    score = 7;
+    matchField = "key (partial)";
+  } else if (valueLower.includes(queryLower)) {
+    score = 3;
+    matchField = "value";
+  }
+  if (score === 0) {
+    const tokens = queryLower.split(/\s+/).filter(Boolean);
+    if (tokens.length > 1) {
+      let tokenHits = 0;
+      for (const token of tokens) {
+        if (keyLower.includes(token))
+          tokenHits += 2;
+        else if (valueLower.includes(token))
+          tokenHits += 1;
+      }
+      if (tokenHits > 0) {
+        score = tokenHits / tokens.length * 5;
+        matchField = "tokens";
+      }
+    }
+  }
+  if (memory.pinned)
+    score *= 1.3;
+  const effectiveImportance = computeDecayScore(memory);
+  score = score * effectiveImportance / 10;
+  if (memory.importance >= 7)
+    score *= 1.2;
+  return { score, matchField };
+}
+async function runFactAgent(db, query, opts) {
+  const queryLower = query.toLowerCase().trim();
+  if (!queryLower)
+    return { memories: [], reasoning: "Empty query" };
+  const { conditions, params } = buildScopeFilter(opts);
+  const limit = (opts.max_results ?? 20) * 2;
+  let rows;
+  if (hasFts5Table2(db)) {
+    const tokens = queryLower.split(/\s+/).filter(Boolean);
+    const ftsQuery = tokens.map(escapeFts5Token).join(" ");
+    try {
+      const ftsCondition = `m.rowid IN (SELECT f.rowid FROM memories_fts f WHERE memories_fts MATCH ?)`;
+      const sql = `SELECT m.* FROM memories m WHERE ${ftsCondition} AND ${conditions.join(" AND ")} LIMIT ?`;
+      rows = db.query(sql).all(ftsQuery, ...params, limit);
+    } catch {
+      rows = [];
+    }
+  } else {
+    rows = [];
+  }
+  if (rows.length === 0) {
+    const likePattern = `%${queryLower}%`;
+    const likeSql = `SELECT m.* FROM memories m WHERE (m.key LIKE ? OR m.value LIKE ?) AND ${conditions.join(" AND ")} LIMIT ?`;
+    rows = db.query(likeSql).all(likePattern, likePattern, ...params, limit);
+  }
+  const results = [];
+  for (const row of rows) {
+    const memory = parseMemoryRow(row);
+    const { score, matchField } = scoreFactMemory(memory, queryLower);
+    if (score <= 0)
+      continue;
+    results.push({
+      memory,
+      score,
+      source_agent: "facts",
+      reasoning: `Direct fact match on ${matchField}`,
+      verbatim_excerpt: memory.value
+    });
+  }
+  results.sort((a, b) => b.score - a.score);
+  const trimmed = results.slice(0, opts.max_results ?? 20);
+  return {
+    memories: trimmed,
+    reasoning: `Fact agent searched ${rows.length} candidate memories, returned ${trimmed.length} factual matches`
+  };
+}
+
+// src/lib/asmr/context-agent.ts
+init_memories();
+init_entities();
+init_entity_memories();
+function deduplicateCandidates(candidates) {
+  const seen = new Map;
+  for (const c of candidates) {
+    const existing = seen.get(c.memory.id);
+    if (!existing) {
+      seen.set(c.memory.id, c);
+    } else {
+      const existingTotal = existing.semanticScore + existing.entityLinkStrength;
+      const currentTotal = c.semanticScore + c.entityLinkStrength;
+      if (currentTotal > existingTotal) {
+        seen.set(c.memory.id, c);
+      }
+    }
+  }
+  return Array.from(seen.values());
+}
+async function runContextAgent(db, query, opts) {
+  const queryLower = query.toLowerCase().trim();
+  if (!queryLower)
+    return { memories: [], reasoning: "Empty query" };
+  const maxResults = opts.max_results ?? 20;
+  const candidates = [];
+  let semanticCount = 0;
+  let entityQueryCount = 0;
+  try {
+    const semanticResults = await semanticSearch(query, {
+      threshold: 0.3,
+      limit: maxResults * 2,
+      project_id: opts.project_id,
+      agent_id: opts.agent_id
+    }, db);
+    for (const sr of semanticResults) {
+      candidates.push({
+        memory: sr.memory,
+        semanticScore: sr.score,
+        entityLinkStrength: 0,
+        entityName: null,
+        entityRelation: null
+      });
+    }
+    semanticCount = semanticResults.length;
+  } catch {}
+  const topSemantic = candidates.slice(0, 10);
+  const entityMemoryIds = new Set;
+  for (const candidate of topSemantic) {
+    try {
+      const entities = getEntitiesForMemory(candidate.memory.id, db);
+      for (const entity of entities) {
+        const linkedMemories = getMemoriesForEntity(entity.id, db);
+        for (const mem of linkedMemories) {
+          if (entityMemoryIds.has(mem.id))
+            continue;
+          entityMemoryIds.add(mem.id);
+          candidates.push({
+            memory: mem,
+            semanticScore: 0,
+            entityLinkStrength: 1,
+            entityName: entity.name,
+            entityRelation: entity.type
+          });
+        }
+      }
+    } catch {}
+  }
+  try {
+    const matchingEntities = listEntities({ search: query, limit: 10, project_id: opts.project_id }, db);
+    const exactEntity = getEntityByName(query, undefined, opts.project_id, db);
+    if (exactEntity && !matchingEntities.find((e) => e.id === exactEntity.id)) {
+      matchingEntities.unshift(exactEntity);
+    }
+    for (const entity of matchingEntities) {
+      entityQueryCount++;
+      const linkedMemories = getMemoriesForEntity(entity.id, db);
+      for (const mem of linkedMemories) {
+        if (entityMemoryIds.has(mem.id))
+          continue;
+        entityMemoryIds.add(mem.id);
+        const nameMatch = entity.name.toLowerCase() === queryLower ? 1 : 0.7;
+        candidates.push({
+          memory: mem,
+          semanticScore: 0,
+          entityLinkStrength: nameMatch,
+          entityName: entity.name,
+          entityRelation: entity.type
+        });
+      }
+    }
+  } catch {}
+  const unique = deduplicateCandidates(candidates);
+  const results = [];
+  for (const c of unique) {
+    if (opts.project_id && c.memory.project_id && c.memory.project_id !== opts.project_id)
+      continue;
+    if (c.memory.status !== "active")
+      continue;
+    const effectiveImportance = computeDecayScore(c.memory) / 10;
+    const score = c.semanticScore * 0.4 + c.entityLinkStrength * 0.3 + effectiveImportance * 0.3;
+    let reasoning;
+    if (c.entityName) {
+      reasoning = `Found via entity ${c.entityName} (relation: ${c.entityRelation})`;
+    } else {
+      reasoning = `Semantic similarity match (score: ${c.semanticScore.toFixed(3)})`;
+    }
+    results.push({
+      memory: c.memory,
+      score,
+      source_agent: "context",
+      reasoning,
+      verbatim_excerpt: c.memory.value
+    });
+  }
+  results.sort((a, b) => b.score - a.score);
+  const trimmed = results.slice(0, maxResults);
+  return {
+    memories: trimmed,
+    reasoning: `Context agent found ${semanticCount} semantic matches, traversed ${entityQueryCount} entities, returned ${trimmed.length} contextual results`
+  };
+}
+
+// src/lib/asmr/temporal-agent.ts
+init_memories();
+function hasFts5Table3(db) {
+  try {
+    const row = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'").get();
+    return !!row;
+  } catch {
+    return false;
+  }
+}
+function escapeFts5Token2(token) {
+  return `"${token.replace(/"/g, '""')}"`;
+}
+function queryRelevance(memory, queryLower) {
+  const keyLower = memory.key.toLowerCase();
+  const valueLower = memory.value.toLowerCase();
+  if (keyLower === queryLower)
+    return 1;
+  if (keyLower.includes(queryLower))
+    return 0.8;
+  if (valueLower.includes(queryLower))
+    return 0.5;
+  const tokens = queryLower.split(/\s+/).filter(Boolean);
+  if (tokens.length > 1) {
+    let hits = 0;
+    for (const t of tokens) {
+      if (keyLower.includes(t) || valueLower.includes(t))
+        hits++;
+    }
+    return hits / tokens.length * 0.6;
+  }
+  return 0.1;
+}
+function formatDate(iso) {
+  if (!iso)
+    return "unknown";
+  return iso.slice(0, 10);
+}
+async function runTemporalAgent(db, query, opts) {
+  const queryLower = query.toLowerCase().trim();
+  if (!queryLower)
+    return { memories: [], reasoning: "Empty query" };
+  const maxResults = opts.max_results ?? 20;
+  const limit = maxResults * 3;
+  const conditions = [
+    "(m.expires_at IS NULL OR m.expires_at >= datetime('now'))"
+  ];
+  const params = [];
+  if (opts.project_id) {
+    conditions.push("m.project_id = ?");
+    params.push(opts.project_id);
+  }
+  if (opts.agent_id) {
+    conditions.push("m.agent_id = ?");
+    params.push(opts.agent_id);
+  }
+  let temporalRows = [];
+  const temporalCondition = "(m.valid_from IS NOT NULL OR m.valid_until IS NOT NULL)";
+  if (hasFts5Table3(db)) {
+    const tokens = queryLower.split(/\s+/).filter(Boolean);
+    const ftsQuery = tokens.map(escapeFts5Token2).join(" ");
+    try {
+      const ftsCondition = `m.rowid IN (SELECT f.rowid FROM memories_fts f WHERE memories_fts MATCH ?)`;
+      const sql = `SELECT m.* FROM memories m WHERE ${ftsCondition} AND ${temporalCondition} AND ${conditions.join(" AND ")} ORDER BY m.valid_from DESC NULLS LAST LIMIT ?`;
+      temporalRows = db.query(sql).all(ftsQuery, ...params, limit);
+    } catch {
+      temporalRows = [];
+    }
+  }
+  if (temporalRows.length === 0) {
+    const likePattern = `%${queryLower}%`;
+    const sql = `SELECT m.* FROM memories m WHERE (m.key LIKE ? OR m.value LIKE ?) AND ${temporalCondition} AND ${conditions.join(" AND ")} ORDER BY m.valid_from DESC NULLS LAST LIMIT ?`;
+    temporalRows = db.query(sql).all(likePattern, likePattern, ...params, limit);
+  }
+  let supersededRows = [];
+  try {
+    const likePattern = `%${queryLower}%`;
+    const sql = `SELECT m.* FROM memories m WHERE (m.key LIKE ? OR m.value LIKE ?) AND (m.status = 'archived' OR m.valid_until IS NOT NULL) ${conditions.length > 0 ? "AND " + conditions.join(" AND ") : ""} ORDER BY m.updated_at DESC LIMIT ?`;
+    supersededRows = db.query(sql).all(likePattern, likePattern, ...params, limit);
+  } catch {}
+  const seen = new Map;
+  const allRows = [...temporalRows, ...supersededRows];
+  for (const row of allRows) {
+    const memory = parseMemoryRow(row);
+    if (!seen.has(memory.id)) {
+      seen.set(memory.id, memory);
+    }
+  }
+  const memories = Array.from(seen.values());
+  const timeline = [];
+  const results = [];
+  for (const memory of memories) {
+    const hasTemporal = memory.valid_from !== null || memory.valid_until !== null;
+    const isSuperseded = memory.status === "archived";
+    const relevance = queryRelevance(memory, queryLower);
+    let versions = [];
+    let newerVersionNote = "";
+    try {
+      versions = getMemoryVersions(memory.id, db);
+      if (versions.length > 1) {
+        const latest = versions[versions.length - 1];
+        if (latest.version > memory.version) {
+          newerVersionNote = `, superseded at version ${latest.version}`;
+        }
+      }
+    } catch {}
+    if (hasTemporal || isSuperseded) {
+      const from = formatDate(memory.valid_from);
+      const until = formatDate(memory.valid_until);
+      const status = isSuperseded ? " [superseded]" : "";
+      timeline.push(`${from} - ${until}: ${memory.key}${status}`);
+    }
+    const recencyMs = memory.valid_from ? Date.now() - new Date(memory.valid_from).getTime() : Date.now() - new Date(memory.created_at).getTime();
+    const daysSince = recencyMs / (1000 * 60 * 60 * 24);
+    const recencyScore = Math.max(0, 1 - daysSince / 365);
+    const temporalBonus = hasTemporal ? 1 : 0.3;
+    const effectiveImportance = computeDecayScore(memory) / 10;
+    const score = recencyScore * 0.4 + relevance * 0.3 + temporalBonus * 0.3;
+    const finalScore = score * effectiveImportance;
+    let reasoning;
+    if (isSuperseded) {
+      reasoning = `Superseded memory from ${formatDate(memory.valid_from)}${newerVersionNote}`;
+    } else if (memory.valid_until && new Date(memory.valid_until) < new Date) {
+      reasoning = `Expired temporal fact (valid ${formatDate(memory.valid_from)} to ${formatDate(memory.valid_until)})${newerVersionNote}`;
+    } else if (hasTemporal) {
+      reasoning = `Current as of ${formatDate(memory.valid_from)}${newerVersionNote}`;
+    } else {
+      reasoning = `Historical record from ${formatDate(memory.created_at)}${newerVersionNote}`;
+    }
+    results.push({
+      memory,
+      score: finalScore,
+      source_agent: "temporal",
+      reasoning,
+      verbatim_excerpt: memory.value
+    });
+  }
+  timeline.sort();
+  results.sort((a, b) => b.score - a.score);
+  const trimmed = results.slice(0, maxResults);
+  return {
+    memories: trimmed,
+    reasoning: `Temporal agent found ${temporalRows.length} temporal memories and ${supersededRows.length} superseded records, built ${timeline.length}-entry timeline`
+  };
+}
+
+// src/lib/asmr/orchestrator.ts
+var DEFAULT_MAX_RESULTS = 20;
+function mergeResults(agentResults) {
+  const byId = new Map;
+  for (const { agent, result } of agentResults) {
+    for (const mem of result.memories) {
+      const existing = byId.get(mem.memory.id);
+      if (!existing) {
+        byId.set(mem.memory.id, {
+          best: mem,
+          sources: new Set([agent]),
+          maxScore: mem.score
+        });
+      } else {
+        existing.sources.add(agent);
+        if (mem.score > existing.maxScore) {
+          existing.best = mem;
+          existing.maxScore = mem.score;
+        }
+      }
+    }
+  }
+  const merged = [];
+  for (const [, entry] of byId) {
+    const multiAgentBoost = entry.sources.size > 1 ? 1.5 : 1;
+    merged.push({
+      ...entry.best,
+      score: entry.maxScore * multiAgentBoost
+    });
+  }
+  merged.sort((a, b) => b.score - a.score);
+  return merged;
+}
+function extractFacts(factResult) {
+  const facts = [];
+  const seen = new Set;
+  for (const mem of factResult.memories) {
+    const statement = `${mem.memory.key}: ${mem.memory.value}`;
+    if (!seen.has(mem.memory.id)) {
+      seen.add(mem.memory.id);
+      facts.push(statement);
+    }
+  }
+  return facts;
+}
+function extractTimeline(temporalResult) {
+  const entries = [];
+  const seen = new Set;
+  for (const mem of temporalResult.memories) {
+    if (seen.has(mem.memory.id))
+      continue;
+    seen.add(mem.memory.id);
+    const date = mem.memory.valid_from ?? mem.memory.created_at;
+    const status = mem.memory.status === "archived" ? " [superseded]" : "";
+    entries.push({
+      date,
+      label: `${date.slice(0, 10)}: ${mem.memory.key}${status}`
+    });
+  }
+  entries.sort((a, b) => a.date.localeCompare(b.date));
+  return entries.map((e) => e.label);
+}
+async function asmrRecall(db, query, opts) {
+  const options = {
+    max_results: DEFAULT_MAX_RESULTS,
+    include_reasoning: true,
+    ...opts
+  };
+  const start = performance.now();
+  const [factResult, contextResult, temporalResult] = await Promise.all([
+    runFactAgent(db, query, options),
+    runContextAgent(db, query, options),
+    runTemporalAgent(db, query, options)
+  ]);
+  const agentResults = [
+    { agent: "facts", result: factResult },
+    { agent: "context", result: contextResult },
+    { agent: "temporal", result: temporalResult }
+  ];
+  const merged = mergeResults(agentResults);
+  const trimmed = merged.slice(0, options.max_results ?? DEFAULT_MAX_RESULTS);
+  const facts = extractFacts(factResult);
+  const timeline = extractTimeline(temporalResult);
+  const agentsUsed = [];
+  if (factResult.memories.length > 0)
+    agentsUsed.push("facts");
+  if (contextResult.memories.length > 0)
+    agentsUsed.push("context");
+  if (temporalResult.memories.length > 0)
+    agentsUsed.push("temporal");
+  const reasoningParts = [
+    factResult.reasoning,
+    contextResult.reasoning,
+    temporalResult.reasoning
+  ].filter(Boolean);
+  const duration = Math.round(performance.now() - start);
+  return {
+    memories: trimmed,
+    facts,
+    timeline,
+    reasoning: reasoningParts.join(". "),
+    agents_used: agentsUsed,
+    duration_ms: duration
+  };
+}
+
+// src/server/routes/memories-search.ts
+init_database();
 init_router();
 addRoute("POST", "/api/memories/search/semantic", async (req) => {
   const body = await readJson(req);
@@ -54479,10 +55106,23 @@ addRoute("POST", "/api/memories/search/semantic", async (req) => {
     limit: body["limit"] ?? undefined,
     scope: body["scope"] ?? undefined,
     agent_id: body["agent_id"] ?? undefined,
-    project_id: body["project_id"] ?? undefined
+    project_id: body["project_id"] ?? undefined,
+    index_missing: body["index_missing"] === true || body["index_missing"] === "true"
   });
   return json({ results, count: results.length });
 });
+addRoute("POST", "/api/memories/recall/deep", async (req) => {
+  const body = await readJson(req);
+  if (!body || typeof body["query"] !== "string") {
+    return errorResponse("Missing required field: query", 400);
+  }
+  const result = await asmrRecall(getDatabase(), body["query"], {
+    max_results: body["max_results"] ?? undefined,
+    project_id: body["project_id"] ?? undefined,
+    agent_id: body["agent_id"] ?? undefined
+  });
+  return json(result);
+});
 addRoute("POST", "/api/memories/search", async (req) => {
   const body = await readJson(req);
   if (!body || typeof body["query"] !== "string") {
@@ -54678,6 +55318,35 @@ init_router();
 addRoute("GET", "/api/health", () => {
   return json({ ok: true, version: "1", db: getDbPath() });
 });
+addRoute("GET", "/api/memories/briefing", (_req, url) => {
+  const q = getSearchParams(url);
+  const since = q["since"];
+  if (!since)
+    return errorResponse("Missing required field: since", 400);
+  let visibleMachineId;
+  if (q["machine_agnostic"] === "true")
+    visibleMachineId = null;
+  else if (q["visible_machine_id"])
+    visibleMachineId = q["visible_machine_id"];
+  const result = getMemoryBriefing({
+    since,
+    scope: q["scope"] || undefined,
+    project_id: q["project_id"] || undefined,
+    visible_machine_id: visibleMachineId,
+    limit: q["limit"] ? parseInt(q["limit"], 10) : undefined
+  });
+  return json(result);
+});
+addRoute("GET", "/api/memories/audit", (_req, url) => {
+  const q = getSearchParams(url);
+  const memories = listLowTrustMemories({
+    threshold: q["threshold"] ? parseFloat(q["threshold"]) : undefined,
+    project_id: q["project_id"] || undefined,
+    limit: q["limit"] ? parseInt(q["limit"], 10) : undefined,
+    offset: q["offset"] ? parseInt(q["offset"], 10) : undefined
+  });
+  return json({ memories, count: memories.length });
+});
 addRoute("POST", "/api/memories/extract", async (req) => {
   const body = await readJson(req);
   if (!body)
@@ -58214,14 +58883,14 @@ function startServer(port) {
         if (existsSync5(dashDir) && (req.method === "GET" || req.method === "HEAD")) {
           if (pathname !== "/") {
             const resolvedDash = resolve4(dashDir) + sep;
-            const requestedPath = resolve4(join5(dashDir, pathname));
+            const requestedPath = resolve4(join6(dashDir, pathname));
             if (requestedPath.startsWith(resolvedDash)) {
               const staticRes = serveStaticFile(requestedPath);
               if (staticRes)
                 return staticRes;
             }
           }
-          const indexRes = serveStaticFile(join5(dashDir, "index.html"));
+          const indexRes = serveStaticFile(join6(dashDir, "index.html"));
           if (indexRes)
             return indexRes;
         }